gitnexus 1.6.3-rc.8 → 1.6.3

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

@@ -0,0 +1,249 @@
+/**
+ * `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 { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { splitUsingDirective } from './import-decomposer.js';
+import { computeCsharpArityMetadata } from './arity-metadata.js';
+import { synthesizeCsharpReceiverBinding } from './receiver-binding.js';
+import { getCsharpParser, getCsharpScopeQuery } from './query.js';
+import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
+/** Declaration anchors that carry function-like arity metadata. */
+const FUNCTION_DECL_TAGS = [
+    '@declaration.method',
+    '@declaration.constructor',
+    '@declaration.function',
+];
+/** tree-sitter-c-sharp node types that the method extractor accepts. */
+const FUNCTION_NODE_TYPES = [
+    'method_declaration',
+    'constructor_declaration',
+    'destructor_declaration',
+    'operator_declaration',
+    'conversion_operator_declaration',
+    'local_function_statement',
+];
+export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
+    // Skip the parse when the caller (parse phase's scopeTreeCache)
+    // already produced a Tree for this source. Cache miss = re-parse,
+    // same as before. The cachedTree parameter is typed as `unknown` at
+    // the LanguageProvider contract layer; cast here at the use site.
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = getCsharpParser().parse(sourceText);
+        recordCacheMiss();
+    }
+    else {
+        recordCacheHit();
+    }
+    const rawMatches = getCsharpScopeQuery().matches(tree.rootNode);
+    const out = [];
+    for (const m of rawMatches) {
+        // Group captures by their tag name. Tree-sitter strips the leading
+        // `@`; we put it back so the central extractor's prefix lookups
+        // (`@scope.`, `@declaration.`, …) work.
+        const grouped = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            grouped[tag] = nodeToCapture(tag, c.node);
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Decompose each `using_directive` so `interpretCsharpImport` sees
+        // the kind/source/name/alias markers it consumes. Raw query match
+        // only carries the @import.statement anchor.
+        if (grouped['@import.statement'] !== undefined) {
+            const stmtCapture = grouped['@import.statement'];
+            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'using_directive');
+            if (stmtNode !== null) {
+                const decomposed = splitUsingDirective(stmtNode);
+                if (decomposed !== null) {
+                    out.push(decomposed);
+                    continue;
+                }
+            }
+            // Defensive fallback: emit the raw match so the extractor at
+            // least sees an anchor, even without markers.
+            out.push(grouped);
+            continue;
+        }
+        // Synthesize `this` / `base` receiver type-bindings on every
+        // instance method-like. Tree-sitter can't cleanly express "the
+        // implicit receiver of a non-static member of a class/struct/
+        // record/interface" via a static `.scm` pattern, so we walk up
+        // the AST in code. Mirrors Python's `self`/`cls` synthesis on
+        // `@scope.function` matches.
+        if (grouped['@scope.function'] !== undefined) {
+            out.push(grouped);
+            const anchor = grouped['@scope.function'];
+            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            if (fnNode !== null) {
+                for (const synth of synthesizeCsharpReceiverBinding(fnNode)) {
+                    out.push(synth);
+                }
+            }
+            continue;
+        }
+        // Synthesize arity metadata on function-like declarations so the
+        // registry can narrow overloads (C# relies heavily on this). Mirrors
+        // Python's captures.ts pattern — one anchor per match, so we find
+        // the first tag that matches.
+        const declTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
+        if (declTag !== undefined) {
+            const anchor = grouped[declTag];
+            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            if (fnNode !== null) {
+                const arity = computeCsharpArityMetadata(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
+                }
+            }
+        }
+        // Synthesize `@reference.arity` on every callsite so the
+        // registry's arity filter can narrow overloads. Count the
+        // `argument` named children of the backing `argument_list`.
+        // Python doesn't synthesize this today; C# needs it because the
+        // language has method overloading and the suite asserts overload
+        // resolution.
+        const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((t) => grouped[t] !== undefined);
+        if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
+            const anchor = grouped[callTag];
+            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'invocation_expression') ??
+                findNodeAtRange(tree.rootNode, anchor.range, 'object_creation_expression');
+            if (callNode !== null) {
+                const argList = callNode.childForFieldName('arguments');
+                const args = argList === null
+                    ? []
+                    : argList.namedChildren.filter((c) => c !== null && c.type === 'argument');
+                grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
+                // Infer argument types from literal nodes so overload
+                // disambiguation can narrow same-arity candidates by param
+                // type. Non-literal arguments emit empty string to indicate
+                // "unknown" — consumers treat unknown as any-match.
+                const argTypes = args.map((arg) => inferArgType(arg));
+                grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
+            }
+        }
+        out.push(grouped);
+        // Synthesize primary-constructor declarations on class/record
+        // declarations that carry a `parameter_list` child (C# 12 syntax
+        // `public class User(string name, int age) { ... }` or
+        // `public record Person(string FirstName, string LastName)`).
+        // Legacy `csharpMethodConfig.extractPrimaryConstructor` runs via
+        // the parse phase; the scope-resolution path needs its own emit so
+        // `new User(...)` resolves to a Constructor def in memberByOwner.
+        if (grouped['@declaration.class'] !== undefined ||
+            grouped['@declaration.record'] !== undefined) {
+            const anchor = grouped['@declaration.class'] ?? grouped['@declaration.record'];
+            const typeNode = findNodeAtRange(tree.rootNode, anchor.range, 'class_declaration') ??
+                findNodeAtRange(tree.rootNode, anchor.range, 'record_declaration');
+            if (typeNode !== null) {
+                const synth = synthesizePrimaryConstructor(typeNode);
+                if (synth !== null)
+                    out.push(synth);
+            }
+        }
+    }
+    return out;
+}
+/** C# 12 primary constructor: `class X(a, b) { }` / `record X(a, b)`.
+ *  The parameters are a bare `parameter_list` named child of the type
+ *  declaration (no `constructor_declaration` node). Emit a synthetic
+ *  @declaration.constructor match so the extractor creates a
+ *  Constructor def in memberByOwner — free-call-fallback's
+ *  `pickConstructorOrClass` then targets it for `new X(...)` calls. */
+function synthesizePrimaryConstructor(typeNode) {
+    // Skip types with an explicit constructor_declaration — that would
+    // create duplicate defs.
+    const body = typeNode.childForFieldName('body');
+    if (body !== null) {
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child !== null && child.type === 'constructor_declaration')
+                return null;
+        }
+    }
+    let paramList = null;
+    for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const child = typeNode.namedChild(i);
+        if (child !== null && child.type === 'parameter_list') {
+            paramList = child;
+            break;
+        }
+    }
+    if (paramList === null)
+        return null;
+    const nameNode = typeNode.childForFieldName('name');
+    if (nameNode === null)
+        return null;
+    const paramCount = paramList.namedChildren.filter((c) => c !== null && c.type === 'parameter').length;
+    const m = {
+        '@declaration.constructor': nodeToCapture('@declaration.constructor', paramList),
+        '@declaration.name': syntheticCapture('@declaration.name', nameNode, nameNode.text),
+        '@declaration.parameter-count': syntheticCapture('@declaration.parameter-count', paramList, String(paramCount)),
+        '@declaration.required-parameter-count': syntheticCapture('@declaration.required-parameter-count', paramList, String(paramCount)),
+    };
+    return m;
+}
+/** Infer a C# argument's static type from literal / constructor
+ *  patterns. Returns `''` when the arg has no statically-derivable
+ *  type (e.g. identifier — would require full type inference). */
+function inferArgType(argNode) {
+    // `argument > expression` — tree-sitter-c-sharp wraps the value.
+    const expr = argNode.namedChild(0);
+    if (expr === null)
+        return '';
+    switch (expr.type) {
+        case 'integer_literal':
+            return 'int';
+        case 'real_literal':
+            return 'double';
+        case 'string_literal':
+        case 'verbatim_string_literal':
+        case 'interpolated_string_expression':
+        case 'raw_string_literal':
+            return 'string';
+        case 'character_literal':
+            return 'char';
+        case 'boolean_literal':
+            return 'bool';
+        case 'null_literal':
+            return 'null';
+        case 'object_creation_expression': {
+            const typeNode = expr.childForFieldName('type');
+            return typeNode?.text ?? '';
+        }
+        default:
+            return '';
+    }
+}
+/** Find the first C# function-like node at the given range. The
+ *  declaration anchor range covers the whole method/constructor/etc.
+ *  node, but the tag alone doesn't tell us which node type. */
+function findFunctionNode(rootNode, range) {
+    for (const nodeType of FUNCTION_NODE_TYPES) {
+        const n = findNodeAtRange(rootNode, range, nodeType);
+        if (n !== null)
+            return n;
+    }
+    return null;
+}

package/dist/core/ingestion/languages/csharp/import-decomposer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Decompose a C# `using_directive` into a `CaptureMatch` carrying the
+ * synthesized markers `@import.kind` / `@import.source` / `@import.name`
+ * / `@import.alias` that `interpretCsharpImport` consumes.
+ *
+ * Unlike Python's decomposer this is 1:1 — each `using` produces exactly
+ * one import. The split layer exists to expose the kind (namespace vs
+ * alias vs static) without pushing raw-text parsing into `interpret.ts`.
+ *
+ *   using System;                           → namespace
+ *   using System.Collections.Generic;       → namespace
+ *   using Foo = System.Bar;                 → alias
+ *   using static System.Math;               → static
+ *   global using System.IO;                 → namespace (treated as file-scoped)
+ *   using global::System.IO;                → namespace (global:: alias stripped)
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export declare function splitUsingDirective(stmtNode: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/csharp/import-decomposer.js

@@ -0,0 +1,93 @@
+/**
+ * Decompose a C# `using_directive` into a `CaptureMatch` carrying the
+ * synthesized markers `@import.kind` / `@import.source` / `@import.name`
+ * / `@import.alias` that `interpretCsharpImport` consumes.
+ *
+ * Unlike Python's decomposer this is 1:1 — each `using` produces exactly
+ * one import. The split layer exists to expose the kind (namespace vs
+ * alias vs static) without pushing raw-text parsing into `interpret.ts`.
+ *
+ *   using System;                           → namespace
+ *   using System.Collections.Generic;       → namespace
+ *   using Foo = System.Bar;                 → alias
+ *   using static System.Math;               → static
+ *   global using System.IO;                 → namespace (treated as file-scoped)
+ *   using global::System.IO;                → namespace (global:: alias stripped)
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+export function splitUsingDirective(stmtNode) {
+    if (stmtNode.type !== 'using_directive')
+        return null;
+    const spec = parseUsingDirective(stmtNode);
+    if (spec === null)
+        return null;
+    return buildImportMatch(stmtNode, spec);
+}
+function parseUsingDirective(node) {
+    // tree-sitter-c-sharp's using_directive exposes named children
+    // corresponding to the parts of the directive but omits keyword tokens
+    // (`using`, `static`, `global`) from the named-child list. We inspect
+    // the raw source text to detect the flavor — the grammar doesn't give
+    // us a cleaner signal.
+    const raw = node.text;
+    // Named child layout:
+    //   namespace form:  [pathNode]
+    //   alias form:      [aliasIdNode, pathNode]         (name field = aliasId)
+    //   static form:     [pathNode]                      (same as namespace)
+    //   global using:    [pathNode]                      (same as namespace)
+    const aliasField = node.childForFieldName('name');
+    const children = node.namedChildren;
+    if (children.length === 0)
+        return null;
+    // Alias form — the `name:` field is the alias identifier; the
+    // remaining named child is the type/namespace path.
+    if (aliasField !== null) {
+        const pathNode = children.find((c) => c !== null && c.startIndex !== aliasField.startIndex);
+        if (pathNode === undefined)
+            return null;
+        return {
+            kind: 'alias',
+            source: stripGenericArgs(unwrapGlobalAlias(pathNode.text)),
+            name: aliasField.text,
+            alias: aliasField.text,
+            atNode: node,
+        };
+    }
+    const pathNode = children[0];
+    if (pathNode === null)
+        return null;
+    const source = stripGenericArgs(unwrapGlobalAlias(pathNode.text));
+    if (source === '')
+        return null;
+    const lastSegment = source.split('.').pop() ?? source;
+    // `using static X.Y;` — detect by scanning the raw text before the path.
+    // `global using` behaves semantically as a file-scoped using for our
+    // purposes, so it isn't a separate kind here.
+    if (/^\s*(?:global\s+)?using\s+static\s/.test(raw)) {
+        return { kind: 'static', source, name: '*', atNode: node };
+    }
+    return { kind: 'namespace', source, name: lastSegment, atNode: node };
+}
+/** Strip `global::` prefix — `global::System.IO` → `System.IO`. */
+function unwrapGlobalAlias(text) {
+    return text.replace(/^global::/, '');
+}
+/** Strip generic type arguments — `Dictionary<string, int>` → `Dictionary`. */
+function stripGenericArgs(text) {
+    const lt = text.indexOf('<');
+    if (lt === -1)
+        return text;
+    return text.slice(0, lt);
+}
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': nodeToCapture('@import.statement', stmtNode),
+        '@import.kind': syntheticCapture('@import.kind', spec.atNode, spec.kind),
+        '@import.source': syntheticCapture('@import.source', spec.atNode, spec.source),
+        '@import.name': syntheticCapture('@import.name', spec.atNode, spec.name),
+    };
+    if (spec.alias !== undefined) {
+        m['@import.alias'] = syntheticCapture('@import.alias', spec.atNode, spec.alias);
+    }
+    return m;
+}

package/dist/core/ingestion/languages/csharp/import-target.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ *
+ * Unit 2 shape: suffix-match against the repo's `.cs` files. Each
+ * `using System.Collections.Generic;` could legally expand to multiple
+ * files (every `.cs` that declares `namespace System.Collections.Generic`
+ * — partial classes, assembly-wide namespaces). The scope-resolver
+ * contract returns a single primary target, so we pick the first
+ * match. Cross-file partial-class aggregation runs at graph-bridge
+ * time (Unit 6) via `populateOwners`.
+ *
+ * The legacy csproj-based `resolveCSharpImportInternal` needs config
+ * objects the scope-resolver doesn't carry; the Unit 7 parity gate
+ * will surface cases where the suffix-match diverges from the
+ * namespace-based resolver and we'll adjust the contract if needed.
+ *
+ * Returning `null` lets the finalize algorithm mark the edge as
+ * `linkStatus: 'unresolved'`.
+ */
+import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+export interface CsharpResolveContext {
+    readonly fromFile: string;
+    readonly allFilePaths: ReadonlySet<string>;
+}
+export declare function resolveCsharpImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;

package/dist/core/ingestion/languages/csharp/import-target.js

@@ -0,0 +1,123 @@
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ *
+ * Unit 2 shape: suffix-match against the repo's `.cs` files. Each
+ * `using System.Collections.Generic;` could legally expand to multiple
+ * files (every `.cs` that declares `namespace System.Collections.Generic`
+ * — partial classes, assembly-wide namespaces). The scope-resolver
+ * contract returns a single primary target, so we pick the first
+ * match. Cross-file partial-class aggregation runs at graph-bridge
+ * time (Unit 6) via `populateOwners`.
+ *
+ * The legacy csproj-based `resolveCSharpImportInternal` needs config
+ * objects the scope-resolver doesn't carry; the Unit 7 parity gate
+ * will surface cases where the suffix-match diverges from the
+ * namespace-based resolver and we'll adjust the contract if needed.
+ *
+ * Returning `null` lets the finalize algorithm mark the edge as
+ * `linkStatus: 'unresolved'`.
+ */
+export function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
+    // WorkspaceIndex is `unknown` in the shared contract (Ring 1
+    // placeholder). The scope-resolution orchestrator hands us a
+    // CsharpResolveContext-shaped object; narrow structurally rather
+    // than via a cast chain so unexpected shapes return null cleanly.
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    if (parsedImport.kind === 'dynamic-unresolved')
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    // Namespace path: `System.Collections.Generic` → `System/Collections/Generic`.
+    const pathLike = parsedImport.targetRaw.replace(/\./g, '/');
+    const suffix = `/${pathLike}`;
+    // Exact file match: `System/Collections/Generic.cs` (rare but legal).
+    // Suffix match for nested layouts: `src/lib/System/Collections/Generic.cs`.
+    // Directory match: first `.cs` file directly inside the namespace dir
+    // (e.g. `System/Collections/Generic/List.cs` matches namespace Generic).
+    let exactFile = null;
+    let suffixFile = null;
+    let directoryChild = null;
+    const dirPrefix = `${pathLike}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    for (const raw of ctx.allFilePaths) {
+        const f = raw.replace(/\\/g, '/');
+        if (!f.endsWith('.cs'))
+            continue;
+        if (f === `${pathLike}.cs`) {
+            exactFile = raw;
+            break;
+        }
+        if (suffixFile === null && f.endsWith(`${suffix}.cs`)) {
+            suffixFile = raw;
+        }
+        if (directoryChild === null) {
+            // Namespace-to-directory match: pick the first `.cs` directly in
+            // the namespace dir (not nested deeper). Legacy resolver emits
+            // all of them; we take one so the scope-resolver contract stays
+            // single-target.
+            const atRoot = f.startsWith(dirPrefix);
+            const atNested = f.includes(suffixDirPrefix);
+            if (atRoot || atNested) {
+                const idx = atRoot ? 0 : f.indexOf(suffixDirPrefix) + 1;
+                const after = f.slice(idx + dirPrefix.length);
+                if (after.length > 0 && !after.includes('/')) {
+                    directoryChild = raw;
+                }
+            }
+        }
+    }
+    if (exactFile !== null)
+        return exactFile;
+    if (suffixFile !== null)
+        return suffixFile;
+    if (directoryChild !== null)
+        return directoryChild;
+    // Progressive prefix stripping — mirrors csproj's root-namespace
+    // mapping without the csproj. `using CrossFile.Models;` in a repo
+    // laid out `Models/User.cs` (no `CrossFile/` prefix) works because
+    // the legacy resolver consults csproj; the scope-resolver layer
+    // doesn't have csproj, so we try each suffix of the namespace path
+    // against `.cs` files and directories.
+    //
+    // Also handles `using static CrossFile.Models.UserFactory;` —
+    // strip the leading segment, try `Models/UserFactory.cs`; strip
+    // two, try `UserFactory.cs`.
+    const segments = pathLike.split('/').filter(Boolean);
+    for (let skip = 1; skip < segments.length; skip++) {
+        const tail = segments.slice(skip).join('/');
+        if (tail === '')
+            continue;
+        const tailFile = `${tail}.cs`;
+        const tailSuffix = `/${tailFile}`;
+        const tailDir = `${tail}/`;
+        const tailSuffixDir = `/${tailDir}`;
+        let tailDirectChild = null;
+        for (const raw of ctx.allFilePaths) {
+            const f = raw.replace(/\\/g, '/');
+            if (!f.endsWith('.cs'))
+                continue;
+            if (f === tailFile)
+                return raw;
+            if (f.endsWith(tailSuffix))
+                return raw;
+            if (tailDirectChild === null) {
+                const atRoot = f.startsWith(tailDir);
+                const atNested = f.includes(tailSuffixDir);
+                if (atRoot || atNested) {
+                    const idx = atRoot ? 0 : f.indexOf(tailSuffixDir) + 1;
+                    const after = f.slice(idx + tailDir.length);
+                    if (after.length > 0 && !after.includes('/'))
+                        tailDirectChild = raw;
+                }
+            }
+        }
+        if (tailDirectChild !== null)
+            return tailDirectChild;
+    }
+    return null;
+}

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

@@ -0,0 +1,82 @@
+/**
+ * C# scope-resolution hooks (RFC #909 Ring 3, RFC §5).
+ *
+ * Public API barrel. Consumers should import from this file rather than
+ * the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`               — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`            — `emitCsharpScopeCaptures` orchestrator
+ *   - `import-decomposer.ts`   — each `using` → ParsedImport-shaped captures
+ *   - `interpret.ts`           — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`        — small/no-op hooks made explicit
+ *   - `receiver-binding.ts`    — synthesize `this`/`base` type-bindings on
+ *                                instance-method entry
+ *   - `merge-bindings.ts`      — C# `using` precedence
+ *   - `arity.ts`               — C# arity compatibility (`params`, default values)
+ *   - `arity-metadata.ts`      — synthesize arity metadata from declarations
+ *   - `accessor-unwrap.ts`     — `.Values` / `.Keys` receiver-type unwrap for
+ *                                `Dictionary<K,V>` chains
+ *   - `namespace-siblings.ts`  — AST-driven cross-file implicit-namespace
+ *                                visibility (file/namespace attribution, no
+ *                                regex; reuses orchestrator's treeCache)
+ *   - `import-target.ts`       — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *   - `scope-resolver.ts`      — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`         — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ *
+ * ## Known limitations
+ *
+ * The C# registry-primary path intentionally does NOT resolve the
+ * following. Each is a conscious trade-off at migration time.
+ *
+ *   1. **csproj-driven namespace resolution** — the legacy path
+ *      consults `csharpConfigs` (the parsed .csproj workspace) to map
+ *      `using X.Y;` back to the exact files declaring `namespace X.Y`.
+ *      The scope-resolver contract passes only `allFilePaths`, so we
+ *      fall back to suffix matching on `.cs` files. Unit 7's parity
+ *      gate flags any divergence.
+ *   2. **Multi-file namespace expansion** — a single `using X.Y;` in
+ *      the legacy path can emit multiple IMPORTS edges (every file
+ *      declaring that namespace). The scope-resolver contract returns
+ *      a single target, so we pick the first match; partial-class
+ *      aggregation runs at graph-bridge time.
+ *   3. **Overload resolution by parameter type** — arity narrowing is
+ *      wired (`arity.ts` + `arity-metadata.ts`), but type-based
+ *      disambiguation (`F(int)` vs `F(string)` at a call with a typed
+ *      argument) is left to the registry's type-binding layer.
+ *   4. **Generic type parameter resolution** — `List<User>` binds the
+ *      bound name to `User` via the single-arg-generic stripper;
+ *      nested generics (`Dictionary<K, List<V>>`) fall through the
+ *      receiver-type heuristic.
+ *   5. **`dynamic` typed expressions** — runtime dispatch through
+ *      `dynamic` is not followed.
+ *   6. **Preprocessor-conditional code** — `#if DEBUG` blocks parse
+ *      as usual; branch selection is ignored, so both arms contribute
+ *      bindings.
+ *   7. **Global using propagation across files** — treated as a
+ *      file-scoped using for the declaring file. Unit 7 parity gate
+ *      will flag cases where this matters.
+ *   8. **Expression-bodied `=>` members** — handled by the method
+ *      extractor, but receiver synthesis for `=> this.Field` shortcuts
+ *      follows the same path as block-bodied methods.
+ *   9. **Multi-namespace file attribution** — when a single file
+ *      declares two namespaces (rare), all top-level classes are
+ *      attributed to the first declared namespace via a `first-wins`
+ *      rule in `namespace-siblings.ts`. Namespace detection itself is
+ *      AST-driven (tree-sitter), so `global using static`, aliased
+ *      `using static X = Y.Z;`, attributes, and preprocessor-gated
+ *      declarations are all recognized correctly.
+ *
+ * Shadow-harness corpus parity is the authoritative signal for which
+ * of these matter in practice. The CI parity gate blocks any PR that
+ * regresses either the legacy or registry-primary run of
+ * `test/integration/resolvers/csharp.test.ts`.
+ */
+export { emitCsharpScopeCaptures } from './captures.js';
+export { getCsharpCaptureCacheStats, resetCsharpCaptureCacheStats } from './cache-stats.js';
+export { interpretCsharpImport, interpretCsharpTypeBinding } from './interpret.js';
+export { csharpMergeBindings } from './merge-bindings.js';
+export { csharpArityCompatibility } from './arity.js';
+export { resolveCsharpImportTarget, type CsharpResolveContext } from './import-target.js';
+export { csharpBindingScopeFor, csharpImportOwningScope, csharpReceiverBinding, } from './simple-hooks.js';