@shanepadgett/tau-agent 0.33.1 → 0.34.0

package/{extensions/explore → src}/ast/graph/relationships.ts

@@ -1,12 +1,13 @@
 import { lstat } from "node:fs/promises";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { formatPathForDisplay, pathResolutionError, resolveExplorePath } from "../../traverse.ts";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { formatPathForDisplay, pathResolutionError, resolveExplorePath } from "../traverse.ts";
 import type { ExploreEngine } from "../engine.ts";
 import type { Candidate, Resolution } from "../identity.ts";
 import { resolveTarget } from "../identity.ts";
 import {
 	isCallableLike,
 	isTypeLike,
+	type CallKind,
 	type CallSite,
 	type Decl,
 	type DeclKind,
@@ -15,7 +16,7 @@ import {
 } from "../ir.ts";
 import { walkDecls } from "../query.ts";
 import { scanSources } from "../scan.ts";
-import { signatureText } from "../slice.ts";
+import { compactSignature, signatureText } from "../slice.ts";
 import type { ExploreFileGraph, FileGraphEdge } from "./file-graph.ts";
 
 export type RelationshipOp = "callers" | "callees" | "references" | "implementations";
@@ -38,6 +39,7 @@ export type RelationshipSite = {
 	line: number;
 	kind: RelationshipSiteKind;
 	name: string;
+	target: { path: string; startLine: number } | undefined;
 	preview: string;
 	certainty: RelationshipCertainty;
 	competitors: Candidate[];
@@ -102,14 +104,18 @@ function sameDecl(a: DeclRef, b: DeclRef): boolean {
 /** Same callable name in same file — overloads bind as one symbol for edge matching. */
 function sameOverloadGroup(a: DeclRef, b: DeclRef): boolean {
 	return (
-		a.path === b.path && a.decl.name === b.decl.name && isCallableLike(a.decl.kind) && isCallableLike(b.decl.kind)
+		a.path === b.path &&
+		a.decl.name === b.decl.name &&
+		ownerName(a.decl.qualifiedName) === ownerName(b.decl.qualifiedName) &&
+		isCallableLike(a.decl.kind) &&
+		isCallableLike(b.decl.kind)
 	);
 }
 
-function allSameName(refs: readonly DeclRef[]): boolean {
+function allSameOverloadGroup(refs: readonly DeclRef[]): boolean {
 	const first = refs[0];
 	if (first === undefined) return false;
-	return refs.every((ref) => ref.decl.name === first.decl.name);
+	return refs.every((ref) => sameOverloadGroup(ref, first));
 }
 
 function toCandidate(ref: DeclRef): Candidate {
@@ -171,6 +177,33 @@ function buildBundle(path: string, ir: FileIr, source: string): FileBundle {
 	return { path, ir, source, localByName, importByLocal };
 }
 
+/**
+ * Owner for top-level call sites. Kept out of the IR decl tree so it never
+ * reaches outline, discover, or declaration counts.
+ */
+function fileScopeRef(bundle: FileBundle): DeclRef {
+	return {
+		path: bundle.path,
+		ir: bundle.ir,
+		source: bundle.source,
+		decl: {
+			kind: "module",
+			name: "",
+			qualifiedName: "",
+			startLine: 1,
+			endLine: bundle.ir.lineCount,
+			startOffset: 0,
+			endOffset: bundle.source.length,
+			signatureEndOffset: 0,
+			visibility: "private",
+			exported: false,
+			children: [],
+			calls: bundle.ir.fileCalls,
+			bases: [],
+		},
+	};
+}
+
 function internalTargets(edges: readonly FileGraphEdge[]): Set<string> {
 	const out = new Set<string>();
 	for (const edge of edges) {
@@ -179,6 +212,68 @@ function internalTargets(edges: readonly FileGraphEdge[]): Set<string> {
 	return out;
 }
 
+type MethodSetEntry = { ref: DeclRef | undefined; methods: Set<string> };
+
+/** Directory-scoped type key: a Go method set spans every file in the package. */
+function methodSetKey(path: string, typeName: string): string {
+	return `${dirname(path)}|${typeName}`;
+}
+
+function addMethodSetRef(out: Map<string, MethodSetEntry>, ref: DeclRef): void {
+	const key = methodSetKey(ref.path, ref.decl.name);
+	const existing = out.get(key);
+	const entry = existing ?? { ref: undefined, methods: new Set<string>() };
+	if (existing === undefined) out.set(key, entry);
+	entry.ref = ref;
+	for (const child of ref.decl.children) {
+		if (isCallableLike(child.kind)) entry.methods.add(child.name);
+	}
+}
+
+function addMethodSetOwner(out: Map<string, MethodSetEntry>, ref: DeclRef): void {
+	// Go methods are file-level decls owned through qualifiedName.
+	const owner = ownerName(ref.decl.qualifiedName);
+	if (owner.length === 0) return;
+	const key = methodSetKey(ref.path, owner);
+	const existing = out.get(key);
+	const entry = existing ?? { ref: undefined, methods: new Set<string>() };
+	if (existing === undefined) out.set(key, entry);
+	entry.methods.add(ref.decl.name);
+}
+
+function buildMethodSets(bundles: readonly FileBundle[]): Map<string, MethodSetEntry> {
+	const out = new Map<string, MethodSetEntry>();
+	for (const bundle of bundles) {
+		for (const ref of collectDeclRefs(bundle.path, bundle.ir, bundle.source)) {
+			if (isTypeLike(ref.decl.kind)) addMethodSetRef(out, ref);
+			else if (isCallableLike(ref.decl.kind)) addMethodSetOwner(out, ref);
+		}
+	}
+	return out;
+}
+
+/** Interface method names, with embedded interfaces expanded transitively. */
+function requiredMethods(target: DeclRef, sets: Map<string, MethodSetEntry>): Set<string> {
+	const required = new Set<string>();
+	const seen = new Set<string>();
+	const visit = (path: string, decl: Decl): void => {
+		for (const child of decl.children) {
+			if (isCallableLike(child.kind)) required.add(child.name);
+		}
+		for (const base of decl.bases) {
+			const key = methodSetKey(path, base);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			const entry = sets.get(key);
+			if (entry === undefined) continue;
+			for (const name of entry.methods) required.add(name);
+			if (entry.ref !== undefined) visit(entry.ref.path, entry.ref.decl);
+		}
+	};
+	visit(target.path, target.decl);
+	return required;
+}
+
 function pickByDeps(
 	candidates: readonly DeclRef[],
 	depPaths: ReadonlySet<string>,
@@ -190,7 +285,7 @@ function pickByDeps(
 	}
 	if (inClosure.length > 1) {
 		// Overloads of one name bind together; mixed names stay ambiguous.
-		if (allSameName(inClosure)) return { targets: [...inClosure], certainty: "exact", competitors: [] };
+		if (allSameOverloadGroup(inClosure)) return { targets: [...inClosure], certainty: "exact", competitors: [] };
 		return {
 			targets: [],
 			certainty: "ambiguous",
@@ -202,7 +297,7 @@ function pickByDeps(
 		if (only !== undefined) return { targets: [only], certainty: "inferred", competitors: [] };
 	}
 	if (candidates.length > 1) {
-		if (allSameName(candidates)) return { targets: [...candidates], certainty: "inferred", competitors: [] };
+		if (allSameOverloadGroup(candidates)) return { targets: [...candidates], certainty: "inferred", competitors: [] };
 		return {
 			targets: [],
 			certainty: "ambiguous",
@@ -212,42 +307,74 @@ function pickByDeps(
 	return { targets: [], certainty: "inferred", competitors: [] };
 }
 
+type ResolvedCall = { targets: DeclRef[]; certainty: RelationshipCertainty; competitors: Candidate[] };
+
+function exactTargets(refs: readonly DeclRef[]): ResolvedCall {
+	return { targets: [...refs], certainty: "exact", competitors: [] };
+}
+
+function ambiguousTargets(refs: readonly DeclRef[]): ResolvedCall {
+	return {
+		targets: [],
+		certainty: "ambiguous",
+		competitors: refs.slice(0, MAX_COMPETITORS).map(toCandidate),
+	};
+}
+
+function resolveLocalCall(local: readonly DeclRef[]): ResolvedCall | undefined {
+	if (local.length === 1) {
+		const only = local[0];
+		if (only !== undefined) return exactTargets([only]);
+	}
+	if (local.length > 1) {
+		if (allSameOverloadGroup(local)) return exactTargets(local);
+		return ambiguousTargets(local);
+	}
+	return undefined;
+}
+
 function resolveCallName(
 	name: string,
 	receiver: string,
+	kind: CallKind,
+	from: DeclRef,
 	caller: FileBundle,
 	globalByName: Map<string, DeclRef[]>,
 	callerDeps: ReadonlySet<string>,
-): { targets: DeclRef[]; certainty: RelationshipCertainty; competitors: Candidate[] } {
-	const local = caller.localByName.get(name);
-	if (local !== undefined && local.length === 1) {
-		const only = local[0];
-		if (only !== undefined) return { targets: [only], certainty: "exact", competitors: [] };
-	}
-	if (local !== undefined && local.length > 1) {
-		if (allSameName(local)) return { targets: [...local], certainty: "exact", competitors: [] };
-		return {
-			targets: [],
-			certainty: "ambiguous",
-			competitors: local.slice(0, MAX_COMPETITORS).map(toCandidate),
-		};
+): ResolvedCall {
+	const callableCandidates = (globalByName.get(name) ?? []).filter((ref) =>
+		kind === "construct" ? isTypeLike(ref.decl.kind) : isCallableLike(ref.decl.kind),
+	);
+	if (caller.importByLocal.has(name)) {
+		return pickByDeps(callableCandidates, callerDeps);
 	}
 
-	if (caller.importByLocal.has(name)) {
-		return pickByDeps(globalByName.get(name) ?? [], callerDeps);
+	const local = caller.localByName
+		.get(name)
+		?.filter((ref) => (kind === "construct" ? isTypeLike(ref.decl.kind) : isCallableLike(ref.decl.kind)));
+	if (receiver.length === 0 && local !== undefined) {
+		const resolved = resolveLocalCall(local);
+		if (resolved !== undefined) return resolved;
 	}
 
-	const global = globalByName.get(name) ?? [];
-	// Receiver-bearing: never unique-global Exact (blocks obj.foo → random foo).
-	if (receiver.length > 0) return pickByDeps(global, callerDeps);
+	const fromOwner = ownerName(from.decl.qualifiedName);
+	const global =
+		receiver.length === 0
+			? callableCandidates.filter(
+					(ref) => ref.decl.kind !== "method" || ownerName(ref.decl.qualifiedName) === fromOwner,
+				)
+			: callableCandidates;
+	if (receiver.length > 0) {
+		const receiverOwner = receiver === "self" || receiver === "this" ? fromOwner : receiver.split(/[.:]/u).at(-1);
+		const owned = global.filter((ref) => ownerName(ref.decl.qualifiedName) === receiverOwner);
+		if (owned.length > 0) return pickByDeps(owned, callerDeps);
+		return { targets: [], certainty: "inferred", competitors: [] };
+	}
 	if (global.length === 1) {
 		const only = global[0];
-		if (only !== undefined) return { targets: [only], certainty: "exact", competitors: [] };
-	}
-	if (global.length > 1 && allSameName(global)) {
-		// Same-name overloads across files still need dep evidence for Exact.
-		return pickByDeps(global, callerDeps);
+		if (only !== undefined) return exactTargets([only]);
 	}
+	// Same-name overloads across files still need dep evidence for Exact.
 	return pickByDeps(global, callerDeps);
 }
 
@@ -260,21 +387,22 @@ function siteKindFromCall(site: CallSite): RelationshipSiteKind {
 
 function makeSite(
 	path: string,
-	source: string,
 	line: number,
 	kind: RelationshipSiteKind,
 	name: string,
 	certainty: RelationshipCertainty,
 	competitors: Candidate[],
+	preview: string,
 ): RelationshipSite {
 	return {
 		path,
 		line,
 		kind,
 		name,
-		preview: linePreview(source, line),
+		target: undefined,
 		certainty,
 		competitors,
+		preview,
 	};
 }
 
@@ -319,17 +447,29 @@ function edgeHitsTarget(edge: EdgeHit, target: DeclRef): boolean {
 }
 
 function pushEdge(sites: RelationshipSite[], edge: EdgeHit): void {
-	sites.push(
-		makeSite(
-			edge.from.path,
-			edge.from.source,
-			edge.site.line,
-			siteKindFromCall(edge.site),
-			edge.site.name,
-			edge.certainty,
-			edge.competitors,
-		),
+	const site = makeSite(
+		edge.from.path,
+		edge.site.line,
+		siteKindFromCall(edge.site),
+		edge.site.name,
+		edge.certainty,
+		edge.competitors,
+		linePreview(edge.from.source, edge.site.line),
 	);
+	const soleTarget = edge.targets.length === 1 ? edge.targets[0] : undefined;
+	const receiverOwner = edge.site.receiver.split(/[.:]/u).at(-1);
+	// Dependency-free same-module methods can still be pinned when syntax names
+	// their owner. Other inferred single-name matches remain visible guesses.
+	const target =
+		soleTarget !== undefined &&
+		(edge.certainty === "exact" ||
+			edge.site.receiver === "self" ||
+			edge.site.receiver === "this" ||
+			ownerName(soleTarget.decl.qualifiedName) === receiverOwner)
+			? soleTarget
+			: undefined;
+	if (target !== undefined) site.target = { path: target.path, startLine: target.decl.startLine };
+	sites.push(site);
 }
 
 export type RelationshipQueryArgs = {
@@ -422,9 +562,10 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 	for (const bundle of bundles) {
 		signal.throwIfAborted();
 		const deps = await depsOf(bundle.path);
-		for (const from of collectDeclRefs(bundle.path, bundle.ir, bundle.source)) {
+		const owners = [...collectDeclRefs(bundle.path, bundle.ir, bundle.source), fileScopeRef(bundle)];
+		for (const from of owners) {
 			for (const site of from.decl.calls) {
-				const resolved = resolveCallName(site.name, site.receiver, bundle, globalByName, deps);
+				const resolved = resolveCallName(site.name, site.receiver, site.kind, from, bundle, globalByName, deps);
 				edges.push({
 					from,
 					site,
@@ -438,32 +579,51 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 
 	const sites: RelationshipSite[] = [];
 
+	const heritageCertainty = (
+		ref: DeclRef,
+		deps: ReadonlySet<string>,
+		candidates: readonly DeclRef[],
+	): RelationshipCertainty => {
+		// Same file and same directory are one package: no import edge exists to
+		// prove, so label them alike rather than implying a confidence gap.
+		if (ref.path === target.path || dirname(ref.path) === dirname(target.path) || deps.has(target.path)) {
+			return "exact";
+		}
+		return candidates.length === 1 ? "inferred" : "ambiguous";
+	};
+
+	const isHeritageCandidate = (ref: DeclRef, baseName: string): boolean => {
+		if (!ref.decl.bases.includes(baseName) || !isTypeLike(ref.decl.kind)) return false;
+		// Never list the base type as its own implementor.
+		return !(sameDecl(ref, target) || (ref.decl.name === baseName && ref.path === target.path));
+	};
+
+	const pushHeritageSite = async (
+		ref: DeclRef,
+		baseName: string,
+		siteKind: RelationshipSiteKind,
+		candidates: readonly DeclRef[],
+	): Promise<void> => {
+		const certainty = heritageCertainty(ref, await depsOf(ref.path), candidates);
+		sites.push(
+			makeSite(
+				ref.path,
+				ref.decl.startLine,
+				siteKind,
+				baseName,
+				certainty,
+				certainty === "ambiguous" ? candidates.slice(0, MAX_COMPETITORS).map(toCandidate) : [],
+				// Declaration-shaped site: its own signature, not the annotation line above it.
+				compactSignature(signatureText(ref.decl, ref.source)),
+			),
+		);
+	};
+
 	const heritageSites = async (baseName: string, siteKind: RelationshipSiteKind): Promise<void> => {
+		const candidates = globalByName.get(baseName) ?? [];
 		for (const bundle of bundles) {
 			for (const ref of collectDeclRefs(bundle.path, bundle.ir, bundle.source)) {
-				if (!ref.decl.bases.includes(baseName)) continue;
-				if (!isTypeLike(ref.decl.kind)) continue;
-				// Never list the base type as its own implementor.
-				if (sameDecl(ref, target) || (ref.decl.name === baseName && ref.path === target.path)) continue;
-				const deps = await depsOf(ref.path);
-				const candidates = globalByName.get(baseName) ?? [];
-				const certainty =
-					ref.path === target.path || deps.has(target.path)
-						? "exact"
-						: candidates.length === 1
-							? "inferred"
-							: "ambiguous";
-				sites.push(
-					makeSite(
-						ref.path,
-						ref.source,
-						ref.decl.startLine,
-						siteKind,
-						baseName,
-						certainty,
-						certainty === "ambiguous" ? candidates.slice(0, MAX_COMPETITORS).map(toCandidate) : [],
-					),
-				);
+				if (isHeritageCandidate(ref, baseName)) await pushHeritageSite(ref, baseName, siteKind, candidates);
 			}
 		}
 	};
@@ -488,7 +648,6 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 						sites.push(
 							makeSite(
 								edge.from.path,
-								edge.from.source,
 								edge.site.line,
 								"construct",
 								edge.site.name,
@@ -496,6 +655,7 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 								n > 1
 									? (globalByName.get(target.decl.name) ?? []).slice(0, MAX_COMPETITORS).map(toCandidate)
 									: [],
+								linePreview(edge.from.source, edge.site.line),
 							),
 						);
 					} else {
@@ -518,7 +678,6 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 				sites.push(
 					makeSite(
 						target.path,
-						target.source,
 						target.decl.startLine,
 						"implementation",
 						base,
@@ -528,6 +687,7 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 								? "exact"
 								: picked.certainty,
 						picked.competitors,
+						compactSignature(signatureText(target.decl, target.source)),
 					),
 				);
 			}
@@ -543,7 +703,17 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 					if (binding.local !== target.decl.name && remote !== target.decl.name) continue;
 					const deps = await depsOf(bundle.path);
 					const certainty = deps.has(target.path) || bundle.path === target.path ? "exact" : "inferred";
-					sites.push(makeSite(bundle.path, bundle.source, imp.startLine, "import", binding.local, certainty, []));
+					sites.push(
+						makeSite(
+							bundle.path,
+							imp.startLine,
+							"import",
+							binding.local,
+							certainty,
+							[],
+							linePreview(bundle.source, imp.startLine),
+						),
+					);
 				}
 			}
 		}
@@ -552,6 +722,41 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 		// implementations
 		if (isTypeLike(target.decl.kind)) {
 			await heritageSites(target.decl.name, "implementation");
+			// Structurally typed interfaces (Go): a type implements by method set, with
+			// nothing naming the interface. Syntax cannot check signatures — inferred.
+			if (target.decl.kind === "interface" && targetAdapter.capabilities.structuralImplements) {
+				const sets = buildMethodSets(bundles);
+				const required = requiredMethods(target, sets);
+				const reported = new Set(sites.map((site) => `${site.path}|${site.line}`));
+				if (required.size > 0) {
+					for (const entry of sets.values()) {
+						const ref = entry.ref;
+						if (ref === undefined || sameDecl(ref, target)) continue;
+						if (!isTypeLike(ref.decl.kind)) continue;
+						if (reported.has(`${ref.path}|${ref.decl.startLine}`)) continue;
+						if (entry.methods.size < required.size) continue;
+						let covers = true;
+						for (const name of required) {
+							if (!entry.methods.has(name)) {
+								covers = false;
+								break;
+							}
+						}
+						if (!covers) continue;
+						sites.push(
+							makeSite(
+								ref.path,
+								ref.decl.startLine,
+								"implementation",
+								target.decl.name,
+								"inferred",
+								[],
+								compactSignature(signatureText(ref.decl, ref.source)),
+							),
+						);
+					}
+				}
+			}
 		}
 		if (isCallableLike(target.decl.kind)) {
 			const owner = ownerName(target.decl.qualifiedName);
@@ -568,7 +773,15 @@ export async function queryRelationships(args: RelationshipQueryArgs): Promise<R
 								continue;
 							}
 							sites.push(
-								makeSite(typeRef.path, typeRef.source, child.startLine, "override", child.name, "inferred", []),
+								makeSite(
+									typeRef.path,
+									child.startLine,
+									"override",
+									child.name,
+									"inferred",
+									[],
+									compactSignature(signatureText(child, typeRef.source)),
+								),
 							);
 						}
 					}

package/{extensions/explore → src}/ast/ir.ts

@@ -131,6 +131,12 @@ export type FileIr = {
 	lineCount: number;
 	decls: Decl[];
 	imports: ImportRef[];
+	/**
+	 * Call sites in top-level statements, owned by no declaration.
+	 * Relationship queries read these; they are not declarations and never
+	 * appear in outline, discover, or declaration counts.
+	 */
+	fileCalls: CallSite[];
 	/** True when the parse tree contained ERROR/MISSING nodes. */
 	parseDegraded: boolean;
 };

package/src/ast/languages/csharp-file-deps.ts

@@ -0,0 +1,90 @@
+import { resolve } from "node:path";
+import type { FileDepResolver } from "../adapter.ts";
+import { buildDottedIndex, resolveDottedFile, resolveDottedPackage, type HeadScan } from "./dotted-index.ts";
+import { externalId, internalPaths, isWithin, packageDirectory } from "./file-dep-util.ts";
+
+/**
+ * C# file deps. A `using` names a namespace, so it resolves to that namespace's
+ * directory as a package edge; alias usings (`using A = X.Y.Type;`) name one
+ * type and resolve to its file.
+ */
+
+/** BCL / engine — never treat polyfills as project file edges. */
+function isFrameworkNamespace(ns: string): boolean {
+	if (ns === "System" || ns.startsWith("System.")) return true;
+	if (ns === "Microsoft" || ns.startsWith("Microsoft.")) return true;
+	if (ns === "Windows" || ns.startsWith("Windows.")) return true;
+	if (ns === "UnityEngine" || ns.startsWith("UnityEngine.")) return true;
+	if (ns === "UnityEditor" || ns.startsWith("UnityEditor.")) return true;
+	if (ns === "Godot" || ns.startsWith("Godot.")) return true;
+	return false;
+}
+
+function normalizeUsing(specifier: string): string {
+	let s = specifier.trim().replace(/;$/u, "").trim();
+	s = s.replace(/^global\s+/iu, "").trim();
+	s = s.replace(/^static\s+/iu, "").trim();
+	// Alias: using A = X.Y.Z → resolve the target.
+	const eq = s.indexOf("=");
+	if (eq !== -1) s = s.slice(eq + 1).trim();
+	return s;
+}
+
+const TYPE_KEYWORDS = ["class ", "struct ", "interface ", "record ", "enum ", "delegate "] as const;
+
+/**
+ * Namespace + type pairs, scanned sequentially — types bind to the nearest
+ * preceding namespace declaration.
+ */
+function scanCsharpHead(head: string): HeadScan {
+	const names: HeadScan["names"] = [];
+	const packages: string[] = [];
+	let currentNs: string | undefined;
+	for (const raw of head.split("\n")) {
+		const line = raw.trim();
+		if (line.length === 0 || line.startsWith("//")) continue;
+
+		// file-scoped `namespace X;`, block `namespace X {`, or `namespace X` + brace next line
+		const nsMatch =
+			/^(?:internal\s+)?namespace\s+([A-Za-z_][\w.]*)\s*[;{]?\s*$/u.exec(line) ??
+			/^(?:internal\s+)?namespace\s+([A-Za-z_][\w.]*)\s*[{/]/u.exec(line);
+		if (nsMatch?.[1] !== undefined) {
+			currentNs = nsMatch[1];
+			packages.push(currentNs);
+			continue;
+		}
+		if (currentNs === undefined) continue;
+
+		for (const kw of TYPE_KEYWORDS) {
+			const idx = line.indexOf(kw);
+			if (idx === -1) continue;
+			if (idx > 0 && /[A-Za-z0-9_]/u.test(line.charAt(idx - 1))) continue;
+			const rest = line.slice(idx + kw.length).trimStart();
+			const name = /^([A-Za-z_][\w]*)/u.exec(rest)?.[1];
+			if (name !== undefined) names.push({ pkg: currentNs, name });
+			break;
+		}
+	}
+	return { packages, names };
+}
+
+export const resolveCsharpFileDep: FileDepResolver = async (fromPath, specifier, host, signal) => {
+	signal.throwIfAborted();
+	const dotted = normalizeUsing(specifier);
+	if (dotted.length === 0) return { kind: "unresolved" };
+	if (isFrameworkNamespace(dotted)) return externalId(dotted);
+
+	const index = await buildDottedIndex(host, "csharp-dotted", [".cs"], scanCsharpHead, signal);
+
+	// Namespace first: a plain `using` imports the whole namespace, not one file.
+	const pkg = resolveDottedPackage(index, fromPath, dotted);
+	if (pkg !== undefined && isWithin(host.scopeRoot, pkg.dir)) {
+		return packageDirectory(dotted, pkg.dir, pkg.fileCount);
+	}
+
+	const file = resolveDottedFile(index, fromPath, dotted);
+	if (file === undefined) return externalId(dotted);
+	if (!isWithin(host.scopeRoot, file) || !host.ownsPath(file)) return externalId(dotted);
+	if (resolve(file) === resolve(fromPath)) return { kind: "unresolved" };
+	return internalPaths([file]);
+};