@codragraph/cli 1.6.2

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

@@ -0,0 +1,329 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { cClassConfig, cppClassConfig } from '../class-extractors/configs/c-cpp.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as cCppConfig } from '../type-extractors/c-cpp.js';
+import { cCppExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { cImportConfig, cppImportConfig } from '../import-resolvers/configs/c-cpp.js';
+import { C_QUERIES, CPP_QUERIES } from '../tree-sitter-queries.js';
+/**
+ * Node types for standard function declarations that need C/C++ declarator handling.
+ * Used by cCppExtractFunctionName to determine how to extract the function name.
+ */
+const FUNCTION_DECLARATION_TYPES = new Set([
+    'function_declaration',
+    'function_definition',
+    'async_function_declaration',
+    'generator_function_declaration',
+    'function_item',
+]);
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { cConfig as cFieldConfig, cppConfig as cppFieldConfig, } from '../field-extractors/configs/c-cpp.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { cMethodConfig, cppMethodConfig } from '../method-extractors/configs/c-cpp.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { cVariableConfig, cppVariableConfig } from '../variable-extractors/configs/c-cpp.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+const C_BUILT_INS = new Set([
+    'printf',
+    'fprintf',
+    'sprintf',
+    'snprintf',
+    'vprintf',
+    'vfprintf',
+    'vsprintf',
+    'vsnprintf',
+    'scanf',
+    'fscanf',
+    'sscanf',
+    'malloc',
+    'calloc',
+    'realloc',
+    'free',
+    'memcpy',
+    'memmove',
+    'memset',
+    'memcmp',
+    'strlen',
+    'strcpy',
+    'strncpy',
+    'strcat',
+    'strncat',
+    'strcmp',
+    'strncmp',
+    'strstr',
+    'strchr',
+    'strrchr',
+    'atoi',
+    'atol',
+    'atof',
+    'strtol',
+    'strtoul',
+    'strtoll',
+    'strtoull',
+    'strtod',
+    'sizeof',
+    'offsetof',
+    'typeof',
+    'assert',
+    'abort',
+    'exit',
+    '_exit',
+    'fopen',
+    'fclose',
+    'fread',
+    'fwrite',
+    'fseek',
+    'ftell',
+    'rewind',
+    'fflush',
+    'fgets',
+    'fputs',
+    'likely',
+    'unlikely',
+    'BUG',
+    'BUG_ON',
+    'WARN',
+    'WARN_ON',
+    'WARN_ONCE',
+    'IS_ERR',
+    'PTR_ERR',
+    'ERR_PTR',
+    'IS_ERR_OR_NULL',
+    'ARRAY_SIZE',
+    'container_of',
+    'list_for_each_entry',
+    'list_for_each_entry_safe',
+    'min',
+    'max',
+    'clamp',
+    'abs',
+    'swap',
+    'pr_info',
+    'pr_warn',
+    'pr_err',
+    'pr_debug',
+    'pr_notice',
+    'pr_crit',
+    'pr_emerg',
+    'printk',
+    'dev_info',
+    'dev_warn',
+    'dev_err',
+    'dev_dbg',
+    'GFP_KERNEL',
+    'GFP_ATOMIC',
+    'spin_lock',
+    'spin_unlock',
+    'spin_lock_irqsave',
+    'spin_unlock_irqrestore',
+    'mutex_lock',
+    'mutex_unlock',
+    'mutex_init',
+    'kfree',
+    'kmalloc',
+    'kzalloc',
+    'kcalloc',
+    'krealloc',
+    'kvmalloc',
+    'kvfree',
+    'get',
+    'put',
+]);
+const cClassExtractor = createClassExtractor(cClassConfig);
+const cppClassExtractor = createClassExtractor(cppClassConfig);
+/**
+ * C/C++ function name extraction — unwraps pointer_declarator / reference_declarator /
+ * function_declarator / qualified_identifier chains to find the actual function name.
+ * Handles field_identifier (method inside class body) and parenthesized_declarator.
+ */
+const cCppExtractFunctionName = (node) => {
+    if (!FUNCTION_DECLARATION_TYPES.has(node.type))
+        return null;
+    let funcName = null;
+    let label = 'Function';
+    // C/C++: function_definition -> [pointer_declarator ->] function_declarator -> qualified_identifier/identifier
+    // Unwrap pointer_declarator / reference_declarator wrappers to reach function_declarator
+    let declarator = node.childForFieldName?.('declarator');
+    if (!declarator) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator') {
+                declarator = c;
+                break;
+            }
+        }
+    }
+    while (declarator &&
+        (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) {
+        let nextDeclarator = declarator.childForFieldName?.('declarator');
+        if (!nextDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'function_declarator' ||
+                    c?.type === 'pointer_declarator' ||
+                    c?.type === 'reference_declarator') {
+                    nextDeclarator = c;
+                    break;
+                }
+            }
+        }
+        declarator = nextDeclarator;
+    }
+    if (declarator) {
+        let innerDeclarator = declarator.childForFieldName?.('declarator');
+        if (!innerDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'qualified_identifier' ||
+                    c?.type === 'identifier' ||
+                    c?.type === 'field_identifier' ||
+                    c?.type === 'parenthesized_declarator') {
+                    innerDeclarator = c;
+                    break;
+                }
+            }
+        }
+        if (innerDeclarator?.type === 'qualified_identifier') {
+            let nameNode = innerDeclarator.childForFieldName?.('name');
+            if (!nameNode) {
+                for (let i = 0; i < innerDeclarator.childCount; i++) {
+                    const c = innerDeclarator.child(i);
+                    if (c?.type === 'identifier') {
+                        nameNode = c;
+                        break;
+                    }
+                }
+            }
+            if (nameNode?.text) {
+                funcName = nameNode.text;
+                label = 'Method';
+            }
+        }
+        else if (innerDeclarator?.type === 'identifier' ||
+            innerDeclarator?.type === 'field_identifier') {
+            // field_identifier is used for method names inside C++ class bodies
+            funcName = innerDeclarator.text;
+            if (innerDeclarator.type === 'field_identifier')
+                label = 'Method';
+        }
+        else if (innerDeclarator?.type === 'parenthesized_declarator') {
+            let nestedId = null;
+            for (let i = 0; i < innerDeclarator.childCount; i++) {
+                const c = innerDeclarator.child(i);
+                if (c?.type === 'qualified_identifier' || c?.type === 'identifier') {
+                    nestedId = c;
+                    break;
+                }
+            }
+            if (nestedId?.type === 'qualified_identifier') {
+                let nameNode = nestedId.childForFieldName?.('name');
+                if (!nameNode) {
+                    for (let i = 0; i < nestedId.childCount; i++) {
+                        const c = nestedId.child(i);
+                        if (c?.type === 'identifier') {
+                            nameNode = c;
+                            break;
+                        }
+                    }
+                }
+                if (nameNode?.text) {
+                    funcName = nameNode.text;
+                    label = 'Method';
+                }
+            }
+            else if (nestedId?.type === 'identifier') {
+                funcName = nestedId.text;
+            }
+        }
+    }
+    // Fallback for other node types in FUNCTION_DECLARATION_TYPES (e.g. function_item for Rust in C++ tree)
+    if (!funcName) {
+        let nameNode = node.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c?.type === 'identifier' ||
+                    c?.type === 'property_identifier' ||
+                    c?.type === 'simple_identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        funcName = nameNode?.text ?? null;
+    }
+    return { funcName, label };
+};
+/** Check if a C/C++ function_definition is inside a class or struct body.
+ *  Used by cppLabelOverride to skip duplicate function captures
+ *  that are already covered by definition.method queries. */
+function isCppInsideClassOrStruct(functionNode) {
+    let ancestor = functionNode?.parent ?? null;
+    while (ancestor) {
+        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
+/** Label override shared by C and C++: skip function_definition captures inside class/struct
+ *  bodies (they're duplicates of definition.method captures). */
+const cppLabelOverride = (functionNode, defaultLabel) => {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    return isCppInsideClassOrStruct(functionNode) ? null : defaultLabel;
+};
+export const cProvider = defineLanguage({
+    id: SupportedLanguages.C,
+    extensions: ['.c'],
+    treeSitterQueries: C_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: createImportResolver(cImportConfig),
+    importSemantics: 'wildcard-transitive',
+    callExtractor: createCallExtractor(cCallConfig),
+    fieldExtractor: createFieldExtractor(cFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...cMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(cVariableConfig),
+    classExtractor: cClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.C),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});
+export const cppProvider = defineLanguage({
+    id: SupportedLanguages.CPlusPlus,
+    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+    treeSitterQueries: CPP_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: createImportResolver(cppImportConfig),
+    importSemantics: 'wildcard-transitive',
+    mroStrategy: 'leftmost-base',
+    callExtractor: createCallExtractor(cppCallConfig),
+    fieldExtractor: createFieldExtractor(cppFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...cppMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(cppVariableConfig),
+    classExtractor: cppClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.CPlusPlus),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});

package/dist/core/ingestion/languages/cobol.d.ts

@@ -0,0 +1 @@
+export declare const cobolProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/cobol.js

@@ -0,0 +1,26 @@
+/**
+ * COBOL Language Provider
+ *
+ * Standalone regex-based processor — no tree-sitter grammar.
+ * COBOL files (.cbl, .cob, .cobol, .cpy, .copybook) are detected and
+ * processed by cobol-processor.ts in pipeline Phase 2.6, not by the
+ * tree-sitter pipeline.
+ *
+ * This provider exists to satisfy the SupportedLanguages exhaustiveness
+ * checks and to declare parseStrategy: 'standalone'.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { defineLanguage } from '../language-provider.js';
+export const cobolProvider = defineLanguage({
+    id: SupportedLanguages.Cobol,
+    parseStrategy: 'standalone',
+    extensions: [], // COBOL files detected by cobol-processor's isCobolFile/isJclFile
+    treeSitterQueries: '',
+    typeConfig: {
+        declarationNodeTypes: new Set(),
+        extractDeclaration: () => null,
+        extractParameter: () => null,
+    },
+    exportChecker: () => false,
+    importResolver: () => null,
+});

package/dist/core/ingestion/languages/csharp/accessor-unwrap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * C# collection-accessor unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `unwrapCollectionAccessor` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax
+ * for the same access (`.values()` / `.keys()`), which the compound-
+ * receiver's call-expression branch already handles; they leave this
+ * hook undefined.
+ */
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+export declare function unwrapCsharpCollectionAccessor(receiverType: string, accessor: string): string | undefined;

package/dist/core/ingestion/languages/csharp/accessor-unwrap.js

@@ -0,0 +1,56 @@
+/**
+ * C# collection-accessor unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `unwrapCollectionAccessor` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax
+ * for the same access (`.values()` / `.keys()`), which the compound-
+ * receiver's call-expression branch already handles; they leave this
+ * hook undefined.
+ */
+/** Extract (K, V) from `Dictionary<K, V>` / `IDictionary<K, V>` /
+ *  `IReadOnlyDictionary<K, V>` / `SortedDictionary<K, V>` /
+ *  `ConcurrentDictionary<K, V>` / `ImmutableDictionary<K, V>`.
+ *  Returns undefined if the type name doesn't match or the argument
+ *  list isn't exactly two top-level args. */
+function extractDictionaryArgs(rawName) {
+    const match = rawName.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Dictionary|IDictionary|IReadOnlyDictionary|SortedDictionary|ConcurrentDictionary|ImmutableDictionary)<(.+)>$/);
+    if (match === null)
+        return undefined;
+    const inner = match[1];
+    // Split on the top-level comma (tolerate nested `<...>`).
+    let depth = 0;
+    let commaIdx = -1;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            commaIdx = i;
+            break;
+        }
+    }
+    if (commaIdx === -1)
+        return undefined;
+    return { key: inner.slice(0, commaIdx).trim(), value: inner.slice(commaIdx + 1).trim() };
+}
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+export function unwrapCsharpCollectionAccessor(receiverType, accessor) {
+    if (accessor !== 'Values' && accessor !== 'Keys')
+        return undefined;
+    const args = extractDictionaryArgs(receiverType);
+    if (args === undefined)
+        return undefined;
+    return accessor === 'Values' ? args.value : args.key;
+}

package/dist/core/ingestion/languages/csharp/arity-metadata.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Extract C# arity metadata from a method-like tree-sitter node —
+ * `method_declaration`, `constructor_declaration`, `destructor_declaration`,
+ * `operator_declaration`, `conversion_operator_declaration`, or
+ * `local_function_statement`.
+ *
+ * Reuses `csharpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `params` variadic collapses `parameterCount` to `undefined`,
+ *     which `csharpArityCompatibility` then treats as "max unknown" —
+ *     the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names (with `ref`/`out`/
+ *     `in` prefix) for overload narrowing; a literal `'params'` marker
+ *     is appended for variadic methods so `csharpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface CsharpArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeCsharpArityMetadata(fnNode: SyntaxNode): CsharpArityMetadata;
+export {};

package/dist/core/ingestion/languages/csharp/arity-metadata.js

@@ -0,0 +1,46 @@
+/**
+ * Extract C# arity metadata from a method-like tree-sitter node —
+ * `method_declaration`, `constructor_declaration`, `destructor_declaration`,
+ * `operator_declaration`, `conversion_operator_declaration`, or
+ * `local_function_statement`.
+ *
+ * Reuses `csharpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `params` variadic collapses `parameterCount` to `undefined`,
+ *     which `csharpArityCompatibility` then treats as "max unknown" —
+ *     the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names (with `ref`/`out`/
+ *     `in` prefix) for overload narrowing; a literal `'params'` marker
+ *     is appended for variadic methods so `csharpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+import { csharpMethodConfig } from '../../method-extractors/configs/csharp.js';
+export function computeCsharpArityMetadata(fnNode) {
+    const params = csharpMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        else if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    if (hasVariadic)
+        types.push('params');
+    const total = params.length;
+    // `params int[] args` declares one formal param but accepts any arg
+    // count ≥ required — mirror Python's treatment of `*args` and leave
+    // `parameterCount` undefined so the registry treats max as unknown.
+    const parameterCount = hasVariadic ? undefined : total;
+    const requiredParameterCount = hasVariadic ? undefined : total - optionalCount;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

package/dist/core/ingestion/languages/csharp/arity.d.ts

@@ -0,0 +1,23 @@
+/**
+ * C# arity check, accommodating `params` variadic and default parameters.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has `params T[]` variadic.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and `params` variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'params'` when the method is
+ *                                variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `params` (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount is below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function csharpArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/csharp/arity.js

@@ -0,0 +1,37 @@
+/**
+ * C# arity check, accommodating `params` variadic and default parameters.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has `params T[]` variadic.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and `params` variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'params'` when the method is
+ *                                variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `params` (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount is below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+export function csharpArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVarArgs = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === 'params' || t.startsWith('params '));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/csharp/cache-stats.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache
+ * (C# mirror of `languages/python/cache-stats.ts`).
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. Production builds fold every
+ * increment into dead code via the module-level `PROF` constant, so
+ * the hot path in `captures.ts` stays branch-free.
+ */
+export declare function recordCacheHit(): void;
+export declare function recordCacheMiss(): void;
+export declare function getCsharpCaptureCacheStats(): {
+    hits: number;
+    misses: number;
+};
+export declare function resetCsharpCaptureCacheStats(): void;

package/dist/core/ingestion/languages/csharp/cache-stats.js

@@ -0,0 +1,26 @@
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache
+ * (C# mirror of `languages/python/cache-stats.ts`).
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. Production builds fold every
+ * increment into dead code via the module-level `PROF` constant, so
+ * the hot path in `captures.ts` stays branch-free.
+ */
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+export function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+export function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+export function getCsharpCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+export function resetCsharpCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}

package/dist/core/ingestion/languages/csharp/captures.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `emitScopeCaptures` for C#.
+ *
+ * Drives the C# scope query against tree-sitter-c-sharp and groups raw
+ * matches into `CaptureMatch[]` for the central extractor. Layers one
+ * synthesized stream on top today:
+ *
+ *   1. **Decomposed using directives** — each `using_directive` is
+ *      re-emitted with `@import.kind/source/name/alias` markers so
+ *      `interpretCsharpImport` can recover the ParsedImport shape
+ *      without re-parsing raw text (see `import-decomposer.ts`).
+ *
+ * Receiver-binding synthesis (`this` / `base` type anchors) and arity
+ * metadata synthesis (Unit 5) layer on top later.
+ *
+ * Pure given the input source text. No I/O, no globals consulted.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitCsharpScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];