oh-my-opencode 4.18.0 → 4.18.1

package/packages/lsp-core/src/lsp/client.ts

@@ -1,11 +1,8 @@
-import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
-import { contextCwd } from "../request-context.js";
 import { LspClientConnection } from "./connection.js";
-import { effectiveExtension } from "./effective-extension.js";
-import { getLanguageId } from "./language-mappings.js";
+import type { LspClientTimeoutOptions } from "./transport.js";
 import type {
 	Diagnostic,
 	DocumentSymbol,
@@ -14,105 +11,131 @@ import type {
 	PrepareRenameDefaultBehavior,
 	PrepareRenameResult,
 	Range,
+	ResolvedServer,
 	SymbolInfo,
 	WorkspaceEdit,
 } from "./types.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import { WorkspaceDocumentState } from "./workspace-document-state.js";
+import type { LspRenameResult, WorkspaceEditCommitIo } from "./workspace-edit-types.js";
+import { WorkspaceMutationController } from "./workspace-mutation-controller.js";
 
-const POST_OPEN_DELAY_MS = 1000;
-const POST_DIAGNOSTICS_WAIT_MS = 500;
+const DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3_000;
+const VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+
+export interface LspDiagnosticsResult {
+	readonly items: Diagnostic[];
+	readonly transientError?: {
+		readonly kind: "freshness_timeout";
+		readonly message: string;
+	};
+}
+
+export interface LspClientOptions extends LspClientTimeoutOptions {
+	readonly diagnosticsFreshnessTimeoutMs?: number;
+	readonly versionlessPublishQuiescenceMs?: number;
+}
 
 export class LspClient extends LspClientConnection {
-	private readonly openedFiles = new Set<string>();
-	private readonly documentVersions = new Map<string, number>();
-	private readonly lastSyncedText = new Map<string, string>();
 	private readonly diagnosticPullErrors: Error[] = [];
+	private readonly documents: WorkspaceDocumentState;
+	private readonly workspaceMutations: WorkspaceMutationController;
+	private readonly diagnosticsFreshnessTimeoutMs: number;
+
+	constructor(root: string, server: ResolvedServer, options: LspClientOptions = {}) {
+		super(root, server, options);
+		this.diagnosticsFreshnessTimeoutMs =
+			options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
+		this.documents = new WorkspaceDocumentState(
+			(method, params) => this.sendNotification(method, params),
+			(uri) => this.diagnosticsStore.delete(uri),
+			{
+				versionlessPublishQuiescenceMs:
+					options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS,
+			},
+		);
+		this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
+		this.setWorkspaceApplyEditHandler((params) => this.workspaceMutations.handleApplyEdit(params));
+	}
 
 	getDiagnosticPullErrors(): readonly Error[] {
 		return this.diagnosticPullErrors;
 	}
 
 	async openFile(filePath: string): Promise<void> {
-		const absPath = resolve(contextCwd(), filePath);
-		const uri = pathToFileURL(absPath).href;
-		const text = readFileSync(absPath, "utf-8");
-
-		if (!this.openedFiles.has(absPath)) {
-			const ext = effectiveExtension(absPath);
-			const languageId = getLanguageId(ext);
-			const version = 1;
-
-			await this.sendNotification("textDocument/didOpen", {
-				textDocument: {
-					uri,
-					languageId,
-					version,
-					text,
-				},
-			});
-
-			this.openedFiles.add(absPath);
-			this.documentVersions.set(uri, version);
-			this.lastSyncedText.set(uri, text);
-			await new Promise((r) => setTimeout(r, POST_OPEN_DELAY_MS));
-			return;
-		}
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.documents.openFile(absPath);
+	}
 
-		const prevText = this.lastSyncedText.get(uri);
-		if (prevText === text) {
-			return;
-		}
+	getOpenDocumentVersion(filePath: string): number | undefined {
+		return this.documents.getVersion(this.resolveWorkspacePath(filePath));
+	}
 
-		const nextVersion = (this.documentVersions.get(uri) ?? 1) + 1;
-		this.documentVersions.set(uri, nextVersion);
-		this.lastSyncedText.set(uri, text);
+	override getStoredDiagnostics(uri: string): Diagnostic[] {
+		return [...this.documents.getStoredDiagnostics(uri)];
+	}
 
-		await this.sendNotification("textDocument/didChange", {
-			textDocument: { uri, version: nextVersion },
-			contentChanges: [{ text }],
-		});
+	setWorkspaceEditIo(io: Partial<WorkspaceEditCommitIo>): void {
+		this.workspaceMutations.setIo(io);
+	}
 
-		await this.sendNotification("textDocument/didSave", {
-			textDocument: { uri },
-			text,
-		});
+	protected override handlePublishDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		super.handlePublishDiagnostics(params);
+		this.documents.recordPublishedDiagnostics(params);
 	}
 
 	async definition(
 		filePath: string,
 		line: number,
 		character: number,
+		signal?: AbortSignal,
 	): Promise<Location | LocationLink | Array<Location | LocationLink> | null> {
-		const absPath = resolve(contextCwd(), filePath);
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<Location | LocationLink | Array<Location | LocationLink> | null>(
 			"textDocument/definition",
 			{
 				textDocument: { uri: pathToFileURL(absPath).href },
 				position: { line: line - 1, character },
 			},
+			options,
 		);
 	}
 
-	async references(filePath: string, line: number, character: number, includeDeclaration = true): Promise<Location[]> {
-		const absPath = resolve(contextCwd(), filePath);
+	async references(
+		filePath: string,
+		line: number,
+		character: number,
+		includeDeclaration = true,
+		signal?: AbortSignal,
+	): Promise<Location[]> {
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<Location[]>("textDocument/references", {
 			textDocument: { uri: pathToFileURL(absPath).href },
 			position: { line: line - 1, character },
 			context: { includeDeclaration },
-		});
+		}, options);
 	}
 
-	async documentSymbols(filePath: string): Promise<Array<DocumentSymbol | SymbolInfo>> {
-		const absPath = resolve(contextCwd(), filePath);
+	async documentSymbols(filePath: string, signal?: AbortSignal): Promise<Array<DocumentSymbol | SymbolInfo>> {
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<Array<DocumentSymbol | SymbolInfo>>("textDocument/documentSymbol", {
 			textDocument: { uri: pathToFileURL(absPath).href },
-		});
+		}, options);
 	}
 
-	async workspaceSymbols(query: string): Promise<SymbolInfo[]> {
-		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query });
+	async workspaceSymbols(query: string, signal?: AbortSignal): Promise<SymbolInfo[]> {
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query }, options);
 	}
 
 	private isUnsupportedDiagnosticPullError(error: unknown): boolean {
@@ -122,51 +145,210 @@ export class LspClient extends LspClientConnection {
 		return /unsupported|not supported|method not found|unknown request/i.test(error.message);
 	}
 
-	async diagnostics(filePath: string): Promise<{ items: Diagnostic[] }> {
-		const absPath = resolve(contextCwd(), filePath);
+	private freshnessTimeout(absPath: string): LspDiagnosticsResult {
+		return {
+			items: [],
+			transientError: {
+				kind: "freshness_timeout",
+				message: `Timed out waiting for fresh diagnostics for ${absPath} within ${this.diagnosticsFreshnessTimeoutMs}ms.`,
+			},
+		};
+	}
+
+	private parseDiagnosticPullReport(value: { items?: Diagnostic[]; kind?: string; resultId?: string }): {
+		readonly type: "full";
+		readonly diagnostics: readonly Diagnostic[];
+		readonly resultId?: string;
+	} | {
+		readonly type: "unchanged";
+		readonly resultId?: string;
+	} {
+		if (value.kind === "unchanged") {
+			return {
+				type: "unchanged",
+				...(value.resultId === undefined ? {} : { resultId: value.resultId }),
+			};
+		}
+		return {
+			type: "full",
+			diagnostics: value.items ?? [],
+			...(value.resultId === undefined ? {} : { resultId: value.resultId }),
+		};
+	}
+
+	async diagnostics(filePath: string, signal?: AbortSignal): Promise<LspDiagnosticsResult> {
+		signal?.throwIfAborted();
+		const absPath = this.resolveWorkspacePath(filePath);
 		const uri = pathToFileURL(absPath).href;
 		await this.openFile(absPath);
-		await new Promise((r) => setTimeout(r, POST_DIAGNOSTICS_WAIT_MS));
+		const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
 
-		try {
-			const result = await this.sendRequest<{ items?: Diagnostic[] }>("textDocument/diagnostic", {
-				textDocument: { uri },
-			});
-			if (result.items) {
-				return { items: result.items };
-			}
-		} catch (error) {
-			if (!this.isUnsupportedDiagnosticPullError(error)) {
-				this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+		for (;;) {
+			signal?.throwIfAborted();
+			const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
+			if (!snapshot) return this.freshnessTimeout(absPath);
+			const push = this.documents.resolvePushDiagnostics(snapshot);
+			if (push.status === "ready") return { items: [...push.diagnostics] };
+
+			let pushFallbackOnly = !this.isDiagnosticPullSupported();
+			if (!pushFallbackOnly) {
+				const cached = this.documents.getPullCache(snapshot);
+				try {
+					const remainingMs = deadlineAt - Date.now();
+					if (remainingMs <= 0) return this.freshnessTimeout(absPath);
+					const result = await this.sendRequest<{ items?: Diagnostic[]; kind?: string; resultId?: string }>(
+						"textDocument/diagnostic",
+						{
+							textDocument: { uri },
+							...(cached?.resultId === undefined ? {} : { previousResultId: cached.resultId }),
+						},
+						{ timeoutMs: remainingMs, ...(signal === undefined ? {} : { signal }) },
+					);
+					if (!this.documents.isCurrentSnapshot(snapshot)) continue;
+					const report = this.parseDiagnosticPullReport(result);
+					if (report.type === "full") {
+						this.documents.recordPullDiagnostics(snapshot, {
+							kind: "full",
+							diagnostics: report.diagnostics,
+							...(report.resultId === undefined ? {} : { resultId: report.resultId }),
+						});
+						return { items: [...report.diagnostics] };
+					}
+					if (
+						cached !== null &&
+						cached.documentVersion === snapshot.version &&
+						cached.resultId === report.resultId
+					) {
+						return { items: [...cached.diagnostics] };
+					}
+				} catch (error) {
+					if (this.isUnsupportedDiagnosticPullError(error)) {
+						this.setDiagnosticPullSupported(false);
+						pushFallbackOnly = true;
+					} else if (error instanceof LspRequestTimeoutError) {
+						pushFallbackOnly = true;
+					} else {
+						this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+						throw error;
+					}
+				}
 			}
-		}
 
-		return { items: this.getStoredDiagnostics(uri) };
+			if (!pushFallbackOnly) continue;
+
+			const remainingMs = deadlineAt - Date.now();
+			if (remainingMs <= 0) return this.freshnessTimeout(absPath);
+			const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
+			await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
+		}
 	}
 
 	async prepareRename(
 		filePath: string,
 		line: number,
 		character: number,
+		signal?: AbortSignal,
 	): Promise<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null> {
-		const absPath = resolve(contextCwd(), filePath);
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null>(
 			"textDocument/prepareRename",
 			{
 				textDocument: { uri: pathToFileURL(absPath).href },
 				position: { line: line - 1, character },
 			},
+			options,
 		);
 	}
 
-	async rename(filePath: string, line: number, character: number, newName: string): Promise<WorkspaceEdit | null> {
-		const absPath = resolve(contextCwd(), filePath);
+	async rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+		signal?: AbortSignal,
+	): Promise<LspRenameResult> {
+		const absPath = this.resolveWorkspacePath(filePath);
 		await this.openFile(absPath);
-		return this.sendRequest<WorkspaceEdit | null>("textDocument/rename", {
-			textDocument: { uri: pathToFileURL(absPath).href },
-			position: { line: line - 1, character },
-			newName,
-		});
+		const acquired = this.workspaceMutations.acquire(signal);
+		if (!acquired.success) return { edit: null, apply: acquired.result };
+		const preCommitSignal = createPreCommitAbortSignal(signal, () =>
+			this.workspaceMutations.isBeforeCommit(acquired.lease),
+		);
+		try {
+			const renameParams = {
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+				newName,
+			};
+			const edit =
+				preCommitSignal === undefined
+					? await this.sendRequest<WorkspaceEdit | null>("textDocument/rename", renameParams)
+					: await this.sendRequest<WorkspaceEdit | null>("textDocument/rename", renameParams, {
+							signal: preCommitSignal.signal,
+						});
+			return await this.workspaceMutations.reconcileRename(acquired.lease, edit);
+		} finally {
+			preCommitSignal?.dispose();
+			this.workspaceMutations.release(acquired.lease);
+			}
 	}
+
+	private resolveWorkspacePath(filePath: string): string {
+		return resolve(this.root, filePath);
+	}
+}
+
+function waitForDiagnosticsActivity(wait: Promise<void>, signal: AbortSignal | undefined): Promise<void> {
+	if (!signal) return wait;
+	if (signal.aborted) return Promise.reject(abortError(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = (): void => {
+			signal.removeEventListener("abort", onAbort);
+			reject(abortError(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		wait.then(
+			() => {
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			},
+			(error) => {
+				signal.removeEventListener("abort", onAbort);
+				reject(error);
+			},
+		);
+	});
+}
+
+function createPreCommitAbortSignal(
+	source: AbortSignal | undefined,
+	isBeforeCommit: () => boolean,
+): { readonly signal: AbortSignal; readonly dispose: () => void } | undefined {
+	if (!source) return undefined;
+	const controller = new AbortController();
+	const onAbort = (): void => {
+		if (isBeforeCommit() && !controller.signal.aborted) controller.abort(preCommitAbortReason(source));
+	};
+	if (source.aborted) onAbort();
+	else source.addEventListener("abort", onAbort, { once: true });
+	return {
+		signal: controller.signal,
+		dispose: () => source.removeEventListener("abort", onAbort),
+	};
+}
+
+function preCommitAbortReason(source: AbortSignal): Error {
+	const reason = source.reason;
+	if (reason instanceof Error && reason.name !== "AbortError") return reason;
+	return new Error("LSP request cancelled before workspace edit commit");
+}
+
+function abortError(signal: AbortSignal): Error {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	const error = new Error(typeof reason === "string" ? reason : "operation cancelled");
+	error.name = "AbortError";
+	return error;
 }

package/packages/lsp-core/src/lsp/config-loader.ts

@@ -1,8 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter, isAbsolute, join } from "node:path";
 
-import { contextCwd, contextEnv } from "../request-context.js";
+import { lspRequestContext } from "../request-context.js";
 import { BUILTIN_SERVERS } from "./server-definitions.js";
 import type { ResolvedServer } from "./types.js";
 
@@ -27,27 +25,17 @@ export interface ServerWithSource extends ResolvedServer {
 
 export function getConfigPaths(): { project: string; user: string } {
 	return {
-		project: getProjectConfigPaths()[0] ?? join(process.cwd(), ".codex", "lsp-client.json"),
+		project: getProjectConfigPaths()[0] ?? lspRequestContext().projectConfigPaths[0] ?? "",
 		user: getUserConfigPath(),
 	};
 }
 
-function resolveProjectConfigPath(path: string): string {
-	return isAbsolute(path) ? path : join(contextCwd(), path);
-}
-
-function getProjectConfigPaths(): string[] {
-	const projectOverride = contextEnv("LSP_TOOLS_MCP_PROJECT_CONFIG");
-	if (projectOverride) {
-		return projectOverride.split(delimiter).filter(Boolean).map(resolveProjectConfigPath);
-	}
-	return [join(contextCwd(), ".codex", "lsp-client.json")];
+function getProjectConfigPaths(): readonly string[] {
+	return lspRequestContext().projectConfigPaths;
 }
 
 function getUserConfigPath(): string {
-	const userOverride = contextEnv("LSP_TOOLS_MCP_USER_CONFIG");
-	if (!userOverride) return join(homedir(), ".codex", "lsp-client.json");
-	return isAbsolute(userOverride) ? userOverride : join(homedir(), userOverride);
+	return lspRequestContext().userConfigPath;
 }
 
 function loadJsonFile(path: string): ConfigJson | null {

package/packages/lsp-core/src/lsp/connection.ts

@@ -2,12 +2,19 @@ import { pathToFileURL } from "node:url";
 
 import { LspClientTransport } from "./transport.js";
 
-const INITIALIZE_SETTLE_MS = 300;
+interface InitializeCapabilities {
+	readonly diagnosticProvider?: unknown;
+}
+
+function supportsDiagnosticPull(capabilities: InitializeCapabilities | undefined): boolean {
+	if (capabilities === undefined) return false;
+	return Object.hasOwn(capabilities, "diagnosticProvider");
+}
 
 export class LspClientConnection extends LspClientTransport {
 	async initialize(): Promise<void> {
 		const rootUri = pathToFileURL(this.root).href;
-		await this.sendRequest(
+		const result = await this.sendRequest<{ readonly capabilities?: InitializeCapabilities }>(
 			"initialize",
 			{
 				processId: process.pid,
@@ -24,7 +31,6 @@ export class LspClientConnection extends LspClientTransport {
 						rename: {
 							prepareSupport: true,
 							prepareSupportDefaultBehavior: 1,
-							honorsChangeAnnotations: true,
 						},
 						codeAction: {
 							codeActionLiteralSupport: {
@@ -53,9 +59,10 @@ export class LspClientConnection extends LspClientTransport {
 						symbol: {},
 						workspaceFolders: true,
 						configuration: true,
-						applyEdit: true,
+						...(this.hasWorkspaceApplyEditHandler() ? { applyEdit: true } : {}),
 						workspaceEdit: {
 							documentChanges: true,
+							resourceOperations: ["create", "rename", "delete"],
 						},
 					},
 				},
@@ -63,11 +70,10 @@ export class LspClientConnection extends LspClientTransport {
 			},
 			{ timeoutMs: this.initializeTimeoutMs },
 		);
+		this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
 		await this.sendNotification("initialized");
 		await this.sendNotification("workspace/didChangeConfiguration", {
 			settings: { json: { validate: { enable: true } } },
 		});
-		// Some servers accept initialized before their diagnostics/indexing handlers are ready.
-		await new Promise((r) => setTimeout(r, INITIALIZE_SETTLE_MS));
 	}
 }

package/packages/lsp-core/src/lsp/directory-diagnostics.test.ts

@@ -0,0 +1,104 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { aggregateDiagnosticsForDirectory } from "./directory-diagnostics.js";
+import type { LspClient } from "./client.js";
+import type { Diagnostic, ResolvedServer } from "./types.js";
+
+describe("directory diagnostics", () => {
+	it("#given multiple files and one per-file failure #when directory diagnostics run #then work stays bounded and file failures stay structured", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-"));
+		const active: string[] = [];
+		let maxActive = 0;
+		const diagnosticsByFile = new Map<string, Diagnostic[] | Error>([
+			[join(workspace, "a.ts"), [diagnostic("a")]],
+			[join(workspace, "b.ts"), new Error("b failed")],
+			[join(workspace, "c.ts"), [diagnostic("c")]],
+			[join(workspace, "d.ts"), [diagnostic("d")]],
+			[join(workspace, "e.ts"), [diagnostic("e")]],
+		]);
+		const client = {
+			async diagnostics(filePath: string) {
+				active.push(filePath);
+				maxActive = Math.max(maxActive, active.length);
+				await Promise.resolve();
+				active.splice(active.indexOf(filePath), 1);
+				const entry = diagnosticsByFile.get(filePath);
+				if (entry instanceof Error) throw entry;
+				return { items: entry ?? [] };
+			},
+		} as Pick<LspClient, "diagnostics"> as LspClient;
+		const server: ResolvedServer = { id: "typescript", command: ["typescript-language-server"], extensions: [".ts"], priority: 1 };
+		const manager = {
+			async getClient() {
+				return client;
+			},
+			releaseClient() {},
+		};
+
+		try {
+			const result = await aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 4, {
+				manager: manager as never,
+				listFiles: () => [...diagnosticsByFile.keys()],
+				workspaceRoot: workspace,
+				server,
+				maxConcurrency: 2,
+			});
+
+			expect(maxActive).toBeLessThanOrEqual(2);
+			expect(result.fileFailures).toEqual([{ file: join(workspace, "b.ts"), error: "b failed" }]);
+			expect(result.totalDiagnostics).toBe(3);
+			expect(result.output).toContain("File processing errors:");
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("#given directory diagnostics are aborted after one file #when the worker loops #then no later file is scheduled", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-cancel-"));
+		const controller = new AbortController();
+		const visited: string[] = [];
+		const firstFile = join(workspace, "a.ts");
+		const files = [firstFile, join(workspace, "b.ts"), join(workspace, "c.ts")];
+		const client = {
+			async diagnostics(filePath: string) {
+				visited.push(filePath);
+				controller.abort();
+				return { items: [] };
+			},
+		} as Pick<LspClient, "diagnostics"> as LspClient;
+		const server: ResolvedServer = { id: "typescript", command: ["typescript-language-server"], extensions: [".ts"], priority: 1 };
+		const manager = {
+			async getClient() {
+				return client;
+			},
+			releaseClient() {},
+		};
+
+		try {
+			const result = await aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 3, {
+				manager: manager as never,
+				listFiles: () => files,
+				workspaceRoot: workspace,
+				server,
+				maxConcurrency: 1,
+				signal: controller.signal,
+			});
+
+			expect(result.totalDiagnostics).toBe(0);
+			expect(visited).toEqual([firstFile]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+});
+
+function diagnostic(message: string): Diagnostic {
+	return {
+		range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+		message,
+	};
+}