arceus-s 1.6.4

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[];

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

@@ -0,0 +1,346 @@
+/**
+ * `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';
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.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',
+];
+const BUILTIN_TYPE_NAMES = new Set([
+    'bool',
+    'byte',
+    'char',
+    'decimal',
+    'double',
+    'float',
+    'int',
+    'long',
+    'object',
+    'sbyte',
+    'short',
+    'string',
+    'uint',
+    'ulong',
+    'ushort',
+    'void',
+]);
+function shouldEmitReadMember(memberNode) {
+    const parent = memberNode.parent;
+    if (parent === null)
+        return true;
+    switch (parent.type) {
+        case 'invocation_expression':
+            return parent.childForFieldName('function')?.id !== memberNode.id;
+        case 'assignment_expression':
+            return parent.childForFieldName('left')?.id !== memberNode.id;
+        default:
+            return true;
+    }
+}
+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 = parseSourceSafe(getCsharpParser(), sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(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;
+        }
+        if (grouped['@reference.read.member'] !== undefined) {
+            const anchor = grouped['@reference.read.member'];
+            const memberNode = findNodeAtRange(tree.rootNode, anchor.range, 'member_access_expression');
+            if (memberNode === null || !shouldEmitReadMember(memberNode)) {
+                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);
+            }
+        }
+    }
+    out.push(...synthesizeGenericTypeArgumentReferences(tree.rootNode));
+    return out;
+}
+function synthesizeGenericTypeArgumentReferences(root) {
+    const out = [];
+    // Treat all generic type arguments as static type references, including
+    // declaration signatures and call-site generic instantiations.
+    visit(root, (node) => {
+        if (node.type !== 'generic_name')
+            return;
+        const args = findNamedChild(node, 'type_argument_list');
+        if (args === null)
+            return;
+        for (const arg of args.namedChildren) {
+            if (arg === null)
+                continue;
+            const nameNode = terminalTypeNameNode(arg);
+            if (nameNode === null)
+                continue;
+            if (BUILTIN_TYPE_NAMES.has(nameNode.text))
+                continue;
+            out.push({
+                '@reference.type': nodeToCapture('@reference.type', nameNode),
+                '@reference.name': nodeToCapture('@reference.name', nameNode),
+            });
+        }
+    });
+    return out;
+}
+function terminalTypeNameNode(node) {
+    switch (node.type) {
+        case 'identifier':
+            return node;
+        case 'nullable_type':
+            return node.firstNamedChild === null ? null : terminalTypeNameNode(node.firstNamedChild);
+        case 'qualified_name':
+            return node.lastNamedChild;
+        case 'generic_name':
+            return node.childForFieldName('name') ?? node.firstNamedChild;
+        default:
+            return null;
+    }
+}
+function findNamedChild(node, type) {
+    for (const child of node.namedChildren) {
+        if (child !== null && child.type === type)
+            return child;
+    }
+    return null;
+}
+function visit(node, cb) {
+    cb(node);
+    for (const child of node.namedChildren) {
+        if (child !== null)
+            visit(child, cb);
+    }
+}
+/** 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;