oh-my-opencode 5.0.0-beta.8 → 5.0.0-beta.81

package/packages/lsp-core/src/lsp/server-resolution-local-binary.test.ts

@@ -0,0 +1,170 @@
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { runWithRequestContext } from "../request-context.js";
+import { formatServerLookupError } from "./client-wrapper.js";
+import { __resetServerBinaryResolutionCacheForTests } from "./server-installation.js";
+import { findServerForExtension } from "./server-resolution.js";
+
+const tempDirectories: string[] = [];
+let previousPath: string | undefined;
+
+function makeTempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+function writeExecutable(path: string): string {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, "#!/bin/sh\nexit 0\n");
+	chmodSync(path, 0o755);
+	return path;
+}
+
+function contextFor(cwd: string) {
+	return {
+		cwd,
+		projectConfigPaths: [join(cwd, ".codex", "lsp-client.json")],
+		userConfigPath: join(cwd, "home-config", "lsp-client.json"),
+		installDecisionsPath: join(cwd, "home-config", "lsp-install-decisions.json"),
+		capabilities: { installDecisionTool: true },
+	} as const;
+}
+
+beforeEach(() => {
+	previousPath = process.env["PATH"];
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+afterEach(() => {
+	if (previousPath === undefined) delete process.env["PATH"];
+	else process.env["PATH"] = previousPath;
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+describe("findServerForExtension local binary substitution", () => {
+	test("#given a repo-local biome #when looking up a typescript file #then the command spawns the absolute local path", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-local-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command[0]).toBe(binaryPath);
+		expect(result.server.command.slice(1)).toEqual(["lsp-proxy", "--stdio"]);
+	});
+
+	test("#given a PATH-only server #when looking up #then the resolved PATH entry is substituted", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-path-root-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const pathDir = makeTempRoot("lsp-resolution-path-");
+		const pathBinary = writeExecutable(join(pathDir, "biome"));
+		process.env["PATH"] = pathDir;
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command[0]).toBe(pathBinary);
+	});
+
+	test("#given no server anywhere #when looking up #then the not_installed result is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-missing-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("not_installed");
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+		expect(result.installHint.length).toBeGreaterThan(0);
+	});
+
+	test("#given an unknown extension #when looking up #then the not_configured result is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-unknown-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".unknown-ext"));
+
+		// then
+		expect(result.status).toBe("not_configured");
+	});
+});
+
+describe("not-installed message repo-local guidance", () => {
+	test("#given a missing biome #when formatting the message #then the repo-local install is suggested before the global hint", () => {
+		// given: .css is served by biome alone, so the lookup cannot fall through to typescript
+		const root = makeTempRoot("lsp-message-biome-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".css"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+		expect(result.server.id).toBe("biome");
+
+		// when
+		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("bun add -d @biomejs/biome");
+		expect(message).toContain("npm install -g @biomejs/biome");
+		expect(message.indexOf("bun add -d @biomejs/biome")).toBeLessThan(message.indexOf("npm install -g @biomejs/biome"));
+		expect(message).toContain("ACTION REQUIRED");
+		expect(message).toContain("NOT INSTALLED");
+	});
+
+	test("#given a server with no repo-local route #when formatting the message #then only the global hint is shown", () => {
+		// given
+		const root = makeTempRoot("lsp-message-global-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".rs"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+
+		// when
+		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("To install, run:");
+		expect(message).not.toContain("THIS repository");
+		expect(message).toContain("ACTION REQUIRED");
+	});
+
+	test("#given a pre-authorized install #when formatting the message #then both install routes stay visible", () => {
+		// given
+		const root = makeTempRoot("lsp-message-allowed-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const context = contextFor(root);
+		mkdirSync(join(root, "home-config"), { recursive: true });
+		writeFileSync(
+			context.installDecisionsPath,
+			`${JSON.stringify({ biome: { decision: "allowed", decidedAt: new Date().toISOString() } })}\n`,
+		);
+		const result = runWithRequestContext(context, () => findServerForExtension(".css"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+
+		// when
+		const message = runWithRequestContext(context, () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("pre-authorized");
+		expect(message).toContain("bun add -d @biomejs/biome");
+		expect(message).toContain("npm install -g @biomejs/biome");
+	});
+});

package/packages/lsp-core/src/lsp/server-resolution.ts

@@ -1,16 +1,28 @@
+import { contextCwd } from "../request-context.js";
 import { getDisabledServerIds, getMergedServers } from "./config-loader.js";
 import { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./server-definitions.js";
-import { isServerInstalled } from "./server-installation.js";
+import { isServerInstalled, resolveServerBinary } from "./server-installation.js";
 import type { ServerLookupResult } from "./types.js";
 
+/**
+ * Replaces the command name with the absolute binary path so the client spawns the exact
+ * binary that was resolved -- in particular a repo-local one that is absent from PATH.
+ */
+function withResolvedCommand(command: string[], binaryPath: string): string[] {
+	return [binaryPath, ...command.slice(1)];
+}
+
 export function findServerForExtension(ext: string): ServerLookupResult {
 	const servers = getMergedServers();
+	const workingDirectory = contextCwd();
 
 	for (const server of servers) {
-		if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
+		if (!server.extensions.includes(ext)) continue;
+		const binaryPath = resolveServerBinary(server.command, workingDirectory);
+		if (binaryPath !== null) {
 			const resolvedServer = {
 				id: server.id,
-				command: server.command,
+				command: withResolvedCommand(server.command, binaryPath),
 				extensions: server.extensions,
 				priority: server.priority,
 			};
@@ -70,6 +82,7 @@ export interface ServerStatus {
 export function getAllServers(): ServerStatus[] {
 	const servers = getMergedServers();
 	const disabled = getDisabledServerIds();
+	const workingDirectory = contextCwd();
 
 	const result: ServerStatus[] = [];
 	const seen = new Set<string>();
@@ -78,7 +91,7 @@ export function getAllServers(): ServerStatus[] {
 		if (seen.has(server.id)) continue;
 		result.push({
 			id: server.id,
-			installed: isServerInstalled(server.command),
+			installed: isServerInstalled(server.command, workingDirectory),
 			extensions: server.extensions,
 			disabled: false,
 			source: server.source,
@@ -92,7 +105,7 @@ export function getAllServers(): ServerStatus[] {
 		const builtin = BUILTIN_SERVERS[id];
 		result.push({
 			id,
-			installed: builtin ? isServerInstalled(builtin.command) : false,
+			installed: builtin ? isServerInstalled(builtin.command, workingDirectory) : false,
 			extensions: builtin?.extensions ?? [],
 			disabled: true,
 			source: "disabled",

package/packages/lsp-core/src/lsp/timer-provider.ts

@@ -0,0 +1,13 @@
+export type TimerHandle = ReturnType<typeof setTimeout>;
+
+export interface TimerProvider {
+	readonly now: () => number;
+	readonly setTimeout: (callback: () => void, delayMs: number) => TimerHandle;
+	readonly clearTimeout: (handle: TimerHandle) => void;
+}
+
+export const realTimerProvider: TimerProvider = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle),
+};

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,8 +38,10 @@ 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;
 
 	constructor(
 		protected readonly root: string,
@@ -45,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 {
@@ -71,6 +77,14 @@ export class LspClientTransport {
 		return this.diagnosticPullSupported;
 	}
 
+	protected setDocumentFormattingSupported(supported: boolean): void {
+		this.documentFormattingSupported = supported;
+	}
+
+	isDocumentFormattingSupported(): boolean {
+		return this.documentFormattingSupported;
+	}
+
 	protected handlePublishDiagnostics(params: {
 		readonly uri: string;
 		readonly diagnostics: readonly Diagnostic[];
@@ -178,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);
@@ -204,7 +218,7 @@ export class LspClientTransport {
 			}
 			throw error;
 		} finally {
-			clearTimeout(timeoutHandle);
+			this.timerProvider.clearTimeout(timeoutHandle);
 			combinedSignal.dispose();
 		}
 	}

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

@@ -72,6 +72,14 @@ export interface Diagnostic {
 	message: string;
 }
 
+export interface FormattingOptions {
+	tabSize: number;
+	insertSpaces: boolean;
+	trimTrailingWhitespace?: boolean;
+	insertFinalNewline?: boolean;
+	trimFinalNewlines?: boolean;
+}
+
 export interface TextDocumentIdentifier {
 	uri: string;
 }

package/packages/lsp-core/src/lsp/workspace-apply-edit-test-support.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, watch, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -158,6 +158,34 @@ export async function waitForEventCount(
 	return readEvents(path).filter(predicate);
 }
 
+export async function waitForEventCountBySubscription(
+	path: string,
+	predicate: (event: RecordedEvent) => boolean,
+	count: number,
+): Promise<readonly RecordedEvent[]> {
+	const initial = readEvents(path).filter(predicate);
+	if (initial.length >= count) return initial;
+	return new Promise((resolve) => {
+		let watcher: ReturnType<typeof watch> | undefined;
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		let settled = false;
+		const finish = (matches: readonly RecordedEvent[]): void => {
+			if (settled) return;
+			settled = true;
+			if (timeout !== undefined) clearTimeout(timeout);
+			watcher?.close();
+			resolve(matches);
+		};
+		const check = (): void => {
+			const matches = readEvents(path).filter(predicate);
+			if (matches.length >= count) finish(matches);
+		};
+		watcher = watch(path, { persistent: false }, check);
+		timeout = setTimeout(() => finish(readEvents(path).filter(predicate)), 2_000);
+		check();
+	});
+}
+
 function isRecordedEvent(value: unknown): value is RecordedEvent {
 	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
 }

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,23 @@ 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();
+		// A publish that landed between the caller's snapshot and this registration already IS the
+		// activity being waited for, and its notifyWaiters ran before this waiter existed. Without
+		// this check that wake-up is lost and the wait can only end at the freshness deadline, which
+		// turns the deadline from a fallback into the poll interval the result depends on (#8323).
+		if (state.publishGeneration !== snapshot.publishGeneration) 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 +353,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 +380,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 } });