oh-my-opencode 5.0.0-beta.31 → 5.0.0-beta.32

package/packages/lsp-core/src/lsp/transport-request-timeout.test.ts

@@ -0,0 +1,73 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { ControlledClock } from "./controlled-clock-test-support.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+import { LspClientTransport } from "./transport.js";
+import type { LspClientTimeoutOptions } from "./transport.js";
+import type { ResolvedServer } from "./types.js";
+
+const fakeServer: ResolvedServer = {
+	id: "controlled-clock-fake",
+	command: ["controlled-clock-fake"],
+	extensions: [".ts"],
+	priority: 0,
+};
+
+class WiredTransport extends LspClientTransport {
+	constructor(timeouts: LspClientTimeoutOptions, connection: JsonRpcConnection) {
+		super("/tmp", fakeServer, timeouts);
+		this.connection = connection;
+	}
+
+	request<T>(method: string, params: unknown, options: { timeoutMs?: number }): Promise<T> {
+		return this.sendRequest<T>(method, params, options);
+	}
+}
+
+function encodeMessage(message: Record<string, unknown>): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function makeWiredTransport(clock: ControlledClock): { transport: WiredTransport; serverToClient: PassThrough } {
+	const serverToClient = new PassThrough();
+	const clientToServer = new PassThrough();
+	const connection = new JsonRpcConnection(serverToClient, clientToServer);
+	connection.listen();
+	return { transport: new WiredTransport({ timerProvider: clock }, connection), serverToClient };
+}
+
+describe("LspClientTransport request timeout via TimerProvider", () => {
+	it("#given a request the server never answers #when the injected clock passes the timeout #then the request rejects with LspRequestTimeoutError", async () => {
+		const clock = new ControlledClock();
+		const { transport } = makeWiredTransport(clock);
+
+		const pending = transport.request("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			timeoutMs: 50,
+		});
+		await clock.waitForTimer(50);
+		expect(clock.scheduledDelays.at(-1)).toBe(50);
+		clock.advanceBy(50);
+
+		await expect(pending).rejects.toBeInstanceOf(LspRequestTimeoutError);
+	});
+
+	it("#given a request answered before the deadline #when the injected clock later passes the timeout #then the settled result stands", async () => {
+		const clock = new ControlledClock();
+		const { transport, serverToClient } = makeWiredTransport(clock);
+
+		const pending = transport.request<{ items: unknown[] }>(
+			"textDocument/diagnostic",
+			{ textDocument: { uri: "file:///a.ts" } },
+			{ timeoutMs: 50 },
+		);
+		await clock.waitForTimer(50);
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: 1, result: { items: [] } }));
+
+		await expect(pending).resolves.toEqual({ items: [] });
+		clock.advanceBy(50);
+	});
+});

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

@@ -1,4 +1,6 @@
 import { reportBestEffortCleanupError } from "./cleanup-errors.js";
+import { realTimerProvider } from "./timer-provider.js";
+import type { TimerProvider } from "./timer-provider.js";
 import { INIT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, STOP_HARD_KILL_TIMEOUT_MS, STOP_SIGKILL_GRACE_MS } from "./constants.js";
 import { LspConnectionClosedError, LspProcessExitedError, LspRequestTimeoutError } from "./errors.js";
 import { JsonRpcConnection } from "./json-rpc-connection.js";
@@ -12,6 +14,7 @@ export { createLspSpawnEnv } from "./transport-protocol.js";
 export interface LspClientTimeoutOptions {
 	requestTimeoutMs?: number;
 	initializeTimeoutMs?: number;
+	timerProvider?: TimerProvider;
 }
 
 type WorkspaceApplyEditHandler = (params: unknown) => Promise<WorkspaceApplyEditResponse>;
@@ -35,6 +38,7 @@ export class LspClientTransport {
 	protected readonly diagnosticsStore = new Map<string, Diagnostic[]>();
 	protected readonly requestTimeoutMs: number;
 	protected readonly initializeTimeoutMs: number;
+	protected readonly timerProvider: TimerProvider;
 	private workspaceApplyEditHandler: WorkspaceApplyEditHandler | null = null;
 	private diagnosticPullSupported = false;
 	private documentFormattingSupported = false;
@@ -46,6 +50,7 @@ export class LspClientTransport {
 	) {
 		this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
 		this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
+		this.timerProvider = timeouts.timerProvider ?? realTimerProvider;
 	}
 
 	pid(): number | undefined {
@@ -187,7 +192,7 @@ export class LspClientTransport {
 		const options = args[1];
 		const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
 		const timeoutController = new AbortController();
-		const timeoutHandle = setTimeout(() => {
+		const timeoutHandle = this.timerProvider.setTimeout(() => {
 			const stderrTail = this.stderrBuffer.slice(-5).join("\n");
 			timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
 		}, timeoutMs);
@@ -213,7 +218,7 @@ export class LspClientTransport {
 			}
 			throw error;
 		} finally {
-			clearTimeout(timeoutHandle);
+			this.timerProvider.clearTimeout(timeoutHandle);
 			combinedSignal.dispose();
 		}
 	}

package/packages/lsp-core/src/lsp/workspace-document-state.test.ts

@@ -1,8 +1,91 @@
-import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 
+import { afterEach, describe, expect, it } from "bun:test";
+
+import type { Diagnostic } from "./types.js";
 import { WorkspaceDocumentState } from "./workspace-document-state.js";
 import type { WorkspaceMutation } from "./workspace-edit.js";
 
+const workspaces: string[] = [];
+
+afterEach(() => {
+	while (workspaces.length > 0) {
+		const workspace = workspaces.pop();
+		if (workspace) rmSync(workspace, { recursive: true, force: true });
+	}
+});
+
+function makeDocuments(): WorkspaceDocumentState {
+	return new WorkspaceDocumentState(
+		async () => {},
+		() => {},
+		{ versionlessPublishQuiescenceMs: 0 },
+	);
+}
+
+function makeSourceFile(directorySegment: string): string {
+	const workspace = realpathSync(mkdtempSync(join(tmpdir(), "lsp-document-uri-")));
+	workspaces.push(workspace);
+	const directory = join(workspace, directorySegment);
+	mkdirSync(directory, { recursive: true });
+	const source = join(directory, "page.ts");
+	writeFileSync(source, "const value: number = 'text';\n", "utf-8");
+	return source;
+}
+
+const diagnostic: Diagnostic = {
+	range: { start: { line: 0, character: 6 }, end: { line: 0, character: 11 } },
+	severity: 1,
+	message: "Type 'string' is not assignable to type 'number'.",
+};
+
+describe("WorkspaceDocumentState published diagnostics under a re-encoded uri", () => {
+	it("#given a server that percent-encodes a path segment #when it publishes #then the diagnostics reach the open document", async () => {
+		const documents = makeDocuments();
+		const source = makeSourceFile("(marketing)");
+		await documents.openFile(source);
+		const snapshot = documents.captureDiagnosticSnapshot(source);
+		expect(snapshot).not.toBeNull();
+		const publishedUri = snapshot!.uri.replaceAll("(", "%28").replaceAll(")", "%29");
+		expect(publishedUri).not.toBe(snapshot!.uri);
+
+		documents.recordPublishedDiagnostics({ uri: publishedUri, diagnostics: [diagnostic], version: snapshot!.version });
+
+		expect(documents.getStoredDiagnostics(snapshot!.uri)).toEqual([diagnostic]);
+		expect(documents.resolvePushDiagnostics(snapshot!)).toEqual({ status: "ready", diagnostics: [diagnostic] });
+	});
+
+	it.skipIf(process.platform !== "win32")(
+		"#given a server that lowercases and percent-encodes the drive #when it publishes #then the diagnostics reach the open document",
+		async () => {
+			const documents = makeDocuments();
+			const source = makeSourceFile("routes");
+			await documents.openFile(source);
+			const snapshot = documents.captureDiagnosticSnapshot(source);
+			expect(snapshot).not.toBeNull();
+			const publishedUri = snapshot!.uri.replace(/^file:\/\/\/([A-Za-z]):/, (_match, drive: string) => `file:///${drive.toLowerCase()}%3A`);
+			expect(publishedUri).not.toBe(snapshot!.uri);
+
+			documents.recordPublishedDiagnostics({ uri: publishedUri, diagnostics: [diagnostic], version: snapshot!.version });
+
+			expect(documents.getStoredDiagnostics(snapshot!.uri)).toEqual([diagnostic]);
+			expect(documents.resolvePushDiagnostics(snapshot!)).toEqual({ status: "ready", diagnostics: [diagnostic] });
+		},
+	);
+
+	it("#given a document opened from a path the client already encodes #when the server echoes it verbatim #then the outgoing uri is unchanged", async () => {
+		const documents = makeDocuments();
+		const source = makeSourceFile("plain");
+		await documents.openFile(source);
+		const snapshot = documents.captureDiagnosticSnapshot(source);
+
+		expect(snapshot?.uri).toBe(pathToFileURL(source).href);
+	});
+});
+
 describe("WorkspaceDocumentState watched-file bounds", () => {
 	it("#given more closed-file mutations than one batch #when synchronized #then every notification stays bounded", async () => {
 		const notifications: unknown[] = [];

package/packages/lsp-core/src/lsp/workspace-document-state.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 import { effectiveExtension } from "./effective-extension.js";
 import { getLanguageId } from "./language-mappings.js";
 import type { Diagnostic } from "./types.js";
+import type { TimerProvider } from "./timer-provider.js";
 import type { PlannedWorkspaceOperation, WorkspaceMutation, WorkspaceMutationDelta } from "./workspace-edit-types.js";
 
 const WATCHED_FILE_BATCH_SIZE = 128;
@@ -76,6 +77,7 @@ export type PushDiagnosticsResolution =
 
 export interface WorkspaceDocumentStateOptions {
 	readonly now?: () => number;
+	readonly timerProvider?: TimerProvider;
 	readonly versionlessPublishQuiescenceMs?: number;
 }
 
@@ -88,6 +90,17 @@ function canonicalPath(filePath: string): string {
 	}
 }
 
+function normalizeDocumentUri(uri: string): string {
+	let decoded = uri;
+	try {
+		decoded = decodeURIComponent(uri);
+	} catch {
+		decoded = uri;
+	}
+	if (process.platform !== "win32") return decoded;
+	return decoded.replace(/^(file:\/\/\/)([a-z]):/, (_match, prefix: string, drive: string) => `${prefix}${drive.toUpperCase()}:`);
+}
+
 function isSameOrDescendant(candidate: string, parent: string): boolean {
 	const suffix = relative(parent, candidate);
 	return suffix === "" || (!suffix.startsWith("..") && suffix !== "..");
@@ -103,6 +116,7 @@ export class WorkspaceDocumentState {
 	private readonly openByUri = new Map<string, OpenDocumentState>();
 	private readonly openPromises = new Map<string, Promise<void>>();
 	private readonly now: () => number;
+	private readonly timerProvider: TimerProvider;
 	private readonly versionlessPublishQuiescenceMs: number;
 
 	constructor(
@@ -110,7 +124,12 @@ export class WorkspaceDocumentState {
 		private readonly clearDiagnostics: (uri: string) => void,
 		options: WorkspaceDocumentStateOptions = {},
 	) {
-		this.now = options.now ?? (() => Date.now());
+		this.timerProvider = options.timerProvider ?? {
+			now: options.now ?? (() => Date.now()),
+			setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+			clearTimeout: (handle) => clearTimeout(handle),
+		};
+		this.now = () => this.timerProvider.now();
 		this.versionlessPublishQuiescenceMs =
 			options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
 	}
@@ -135,7 +154,7 @@ export class WorkspaceDocumentState {
 	}
 
 	getStoredDiagnostics(uri: string): readonly Diagnostic[] {
-		const state = this.openByUri.get(uri);
+		const state = this.openByUri.get(normalizeDocumentUri(uri));
 		if (!state) return [];
 		return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
 	}
@@ -163,13 +182,13 @@ export class WorkspaceDocumentState {
 	}
 
 	getPullCache(snapshot: DiagnosticSnapshot): PullDiagnosticsCacheHit | null {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version) return null;
 		return state.pullCache;
 	}
 
 	recordPullDiagnostics(snapshot: DiagnosticSnapshot, report: PullDiagnosticsReport): void {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state) return;
 		state.pullCache = {
 			documentVersion: snapshot.version,
@@ -183,7 +202,7 @@ export class WorkspaceDocumentState {
 		readonly diagnostics: readonly Diagnostic[];
 		readonly version?: number;
 	}): void {
-		const state = this.openByUri.get(params.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(params.uri));
 		if (!state) return;
 		state.publishGeneration += 1;
 		state.lastPublish = {
@@ -197,7 +216,7 @@ export class WorkspaceDocumentState {
 	}
 
 	resolvePushDiagnostics(snapshot: DiagnosticSnapshot): PushDiagnosticsResolution {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state?.lastPublish) return { status: "missing" };
 		const publish = state.lastPublish;
 		if (publish.version !== undefined) {
@@ -214,18 +233,18 @@ export class WorkspaceDocumentState {
 	}
 
 	waitForDiagnosticsActivity(snapshot: DiagnosticSnapshot, timeoutMs: number): Promise<void> {
-		const state = this.openByUri.get(snapshot.uri);
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
 		if (!state || timeoutMs <= 0) return Promise.resolve();
 		return new Promise((resolveActivity) => {
 			let settled = false;
 			const finish = () => {
 				if (settled) return;
 				settled = true;
-				clearTimeout(timer);
+				this.timerProvider.clearTimeout(timer);
 				state.waiters.delete(finish);
 				resolveActivity();
 			};
-			const timer = setTimeout(finish, timeoutMs);
+			const timer = this.timerProvider.setTimeout(finish, timeoutMs);
 			if (typeof timer.unref === "function") timer.unref();
 			state.waiters.add(finish);
 		});
@@ -329,7 +348,7 @@ export class WorkspaceDocumentState {
 				waiters: new Set(),
 			};
 			this.openDocuments.set(path, state);
-			this.openByUri.set(state.uri, state);
+			this.openByUri.set(normalizeDocumentUri(state.uri), state);
 			this.notifyWaiters(state);
 			await this.sendNotification("textDocument/didOpen", {
 				textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text },
@@ -356,7 +375,7 @@ export class WorkspaceDocumentState {
 
 	private async closeDocument(state: OpenDocumentState): Promise<void> {
 		this.openDocuments.delete(state.path);
-		this.openByUri.delete(state.uri);
+		this.openByUri.delete(normalizeDocumentUri(state.uri));
 		this.clearDiagnostics(state.uri);
 		this.notifyWaiters(state);
 		await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });

package/packages/lsp-core/src/tools/parameters.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+	clientOptions,
+	optionalBoolean,
+	optionalNumber,
+	optionalString,
+	requireNumber,
+	requireString,
+	severityFilter,
+} from "./parameters.js";
+
+describe("LSP tool parameter helpers", () => {
+	test("#given required string parameter #when value is missing or empty #then throws clear error", () => {
+		expect(requireString({ filePath: "index.ts" }, "filePath")).toBe("index.ts");
+		expect(() => requireString({}, "filePath")).toThrow("Missing required string parameter 'filePath'");
+		expect(() => requireString({ filePath: "" }, "filePath")).toThrow("Missing required string parameter 'filePath'");
+		expect(() => requireString({ filePath: 42 }, "filePath")).toThrow("Missing required string parameter 'filePath'");
+	});
+
+	test("#given required number parameter #when value is non-finite #then throws clear error", () => {
+		expect(requireNumber({ line: 3 }, "line")).toBe(3);
+		expect(() => requireNumber({}, "line")).toThrow("Missing required number parameter 'line'");
+		expect(() => requireNumber({ line: Number.NaN }, "line")).toThrow("Missing required number parameter 'line'");
+		expect(() => requireNumber({ line: Number.POSITIVE_INFINITY }, "line")).toThrow(
+			"Missing required number parameter 'line'",
+		);
+	});
+
+	test("#given optional parameters #when values have wrong type #then ignores them", () => {
+		expect(optionalString({ query: "symbol" }, "query")).toBe("symbol");
+		expect(optionalString({ query: 7 }, "query")).toBeUndefined();
+		expect(optionalNumber({ limit: 10 }, "limit")).toBe(10);
+		expect(optionalNumber({ limit: Number.NaN }, "limit")).toBeUndefined();
+		expect(optionalBoolean({ includeDeclaration: false }, "includeDeclaration")).toBe(false);
+		expect(optionalBoolean({ includeDeclaration: "false" }, "includeDeclaration")).toBeUndefined();
+	});
+
+	test("#given severity parameter #when value is unknown #then defaults to all", () => {
+		expect(severityFilter({ severity: "warning" })).toBe("warning");
+		expect(severityFilter({ severity: "fatal" })).toBe("all");
+		expect(severityFilter({})).toBe("all");
+	});
+
+	test("#given optional abort signal #when building client options #then includes only defined signal", () => {
+		const controller = new AbortController();
+
+		expect(clientOptions(undefined)).toEqual({});
+		expect(clientOptions(controller.signal)).toEqual({ signal: controller.signal });
+	});
+});

package/packages/lsp-daemon/dist/cli.js

@@ -595,6 +595,13 @@ import { pathToFileURL as pathToFileURL3 } from "node:url";
 // ../lsp-core/src/lsp/connection.ts
 import { pathToFileURL } from "node:url";
 
+// ../lsp-core/src/lsp/timer-provider.ts
+var realTimerProvider = {
+  now: () => Date.now(),
+  setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+
 // ../lsp-core/src/lsp/constants.ts
 var DEFAULT_MAX_REFERENCES = 200;
 var DEFAULT_MAX_SYMBOLS = 200;
@@ -1134,6 +1141,7 @@ class LspClientTransport {
     this.documentFormattingSupported = false;
     this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
     this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
+    this.timerProvider = timeouts.timerProvider ?? realTimerProvider;
   }
   pid() {
     return this.proc?.pid;
@@ -1234,7 +1242,7 @@ class LspClientTransport {
     const options = args[1];
     const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
     const timeoutController = new AbortController;
-    const timeoutHandle = setTimeout(() => {
+    const timeoutHandle = this.timerProvider.setTimeout(() => {
       const stderrTail = this.stderrBuffer.slice(-5).join(`
 `);
       timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
@@ -1253,7 +1261,7 @@ class LspClientTransport {
       }
       throw error;
     } finally {
-      clearTimeout(timeoutHandle);
+      this.timerProvider.clearTimeout(timeoutHandle);
       combinedSignal.dispose();
     }
   }
@@ -1634,6 +1642,17 @@ function canonicalPath(filePath) {
     return absolute;
   }
 }
+function normalizeDocumentUri(uri) {
+  let decoded = uri;
+  try {
+    decoded = decodeURIComponent(uri);
+  } catch {
+    decoded = uri;
+  }
+  if (process.platform !== "win32")
+    return decoded;
+  return decoded.replace(/^(file:\/\/\/)([a-z]):/, (_match, prefix, drive) => `${prefix}${drive.toUpperCase()}:`);
+}
 function isSameOrDescendant(candidate, parent) {
   const suffix = relative2(parent, candidate);
   return suffix === "" || !suffix.startsWith("..") && suffix !== "..";
@@ -1650,7 +1669,12 @@ class WorkspaceDocumentState {
     this.openDocuments = new Map;
     this.openByUri = new Map;
     this.openPromises = new Map;
-    this.now = options.now ?? (() => Date.now());
+    this.timerProvider = options.timerProvider ?? {
+      now: options.now ?? (() => Date.now()),
+      setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+      clearTimeout: (handle) => clearTimeout(handle)
+    };
+    this.now = () => this.timerProvider.now();
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
   async openFile(filePath) {
@@ -1672,7 +1696,7 @@ class WorkspaceDocumentState {
     return this.openDocuments.get(canonicalPath(filePath))?.version;
   }
   getStoredDiagnostics(uri) {
-    const state = this.openByUri.get(uri);
+    const state = this.openByUri.get(normalizeDocumentUri(uri));
     if (!state)
       return [];
     return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
@@ -1694,13 +1718,13 @@ class WorkspaceDocumentState {
     return state !== undefined && state.uri === snapshot.uri && state.version === snapshot.version && state.generation === snapshot.documentGeneration;
   }
   getPullCache(snapshot) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version)
       return null;
     return state.pullCache;
   }
   recordPullDiagnostics(snapshot, report) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state)
       return;
     state.pullCache = {
@@ -1710,7 +1734,7 @@ class WorkspaceDocumentState {
     };
   }
   recordPublishedDiagnostics(params) {
-    const state = this.openByUri.get(params.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(params.uri));
     if (!state)
       return;
     state.publishGeneration += 1;
@@ -1724,7 +1748,7 @@ class WorkspaceDocumentState {
     this.notifyWaiters(state);
   }
   resolvePushDiagnostics(snapshot) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state?.lastPublish)
       return { status: "missing" };
     const publish = state.lastPublish;
@@ -1738,7 +1762,7 @@ class WorkspaceDocumentState {
     return waitMs === 0 ? { status: "ready", diagnostics: publish.diagnostics } : { status: "wait", waitMs };
   }
   waitForDiagnosticsActivity(snapshot, timeoutMs) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state || timeoutMs <= 0)
       return Promise.resolve();
     return new Promise((resolveActivity) => {
@@ -1747,11 +1771,11 @@ class WorkspaceDocumentState {
         if (settled)
           return;
         settled = true;
-        clearTimeout(timer);
+        this.timerProvider.clearTimeout(timer);
         state.waiters.delete(finish);
         resolveActivity();
       };
-      const timer = setTimeout(finish, timeoutMs);
+      const timer = this.timerProvider.setTimeout(finish, timeoutMs);
       if (typeof timer.unref === "function")
         timer.unref();
       state.waiters.add(finish);
@@ -1859,7 +1883,7 @@ class WorkspaceDocumentState {
         waiters: new Set
       };
       this.openDocuments.set(path, state);
-      this.openByUri.set(state.uri, state);
+      this.openByUri.set(normalizeDocumentUri(state.uri), state);
       this.notifyWaiters(state);
       await this.sendNotification("textDocument/didOpen", {
         textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text }
@@ -1884,7 +1908,7 @@ class WorkspaceDocumentState {
   }
   async closeDocument(state) {
     this.openDocuments.delete(state.path);
-    this.openByUri.delete(state.uri);
+    this.openByUri.delete(normalizeDocumentUri(state.uri));
     this.clearDiagnostics(state.uri);
     this.notifyWaiters(state);
     await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });
@@ -2971,6 +2995,7 @@ class LspClient extends LspClientConnection {
     this.diagnosticPullErrors = [];
     this.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
     this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
+      timerProvider: this.timerProvider,
       versionlessPublishQuiescenceMs: options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS
     });
     this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
@@ -3074,7 +3099,7 @@ class LspClient extends LspClientConnection {
     const absPath = this.resolveWorkspacePath(filePath);
     const uri = pathToFileURL3(absPath).href;
     await this.openFile(absPath);
-    const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
+    const deadlineAt = this.timerProvider.now() + this.diagnosticsFreshnessTimeoutMs;
     for (;; ) {
       signal?.throwIfAborted();
       const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
@@ -3087,7 +3112,7 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly) {
         const cached = this.documents.getPullCache(snapshot);
         try {
-          const remainingMs2 = deadlineAt - Date.now();
+          const remainingMs2 = deadlineAt - this.timerProvider.now();
           if (remainingMs2 <= 0)
             return this.freshnessTimeout(absPath);
           const result = await this.sendRequest("textDocument/diagnostic", {
@@ -3122,7 +3147,7 @@ class LspClient extends LspClientConnection {
       }
       if (!pushFallbackOnly)
         continue;
-      const remainingMs = deadlineAt - Date.now();
+      const remainingMs = deadlineAt - this.timerProvider.now();
       if (remainingMs <= 0) {
         if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
           const cached = this.documents.getPullCache(snapshot);