oh-my-opencode 4.18.0 → 4.18.2

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

@@ -0,0 +1,52 @@
+import type { Diagnostic } from "./types.js";
+
+interface ConfigurationItem {
+	readonly section?: string;
+}
+
+interface DiagnosticsParams {
+	readonly uri: string;
+	readonly diagnostics: Diagnostic[];
+	readonly version?: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function parseConfigurationItems(params: unknown): ConfigurationItem[] {
+	if (!isRecord(params) || !Array.isArray(params["items"])) return [];
+	const items: ConfigurationItem[] = [];
+	for (const item of params["items"]) {
+		if (!isRecord(item)) continue;
+		const section = item["section"];
+		items.push(section === undefined || typeof section !== "string" ? {} : { section });
+	}
+	return items;
+}
+
+export function parseDiagnosticsParams(params: unknown): DiagnosticsParams | null {
+	if (!isRecord(params) || typeof params["uri"] !== "string") return null;
+	const diagnostics = Array.isArray(params["diagnostics"]) ? params["diagnostics"].filter(isDiagnostic) : [];
+	const version = typeof params["version"] === "number" ? params["version"] : undefined;
+	return { uri: params["uri"], diagnostics, ...(version === undefined ? {} : { version }) };
+}
+
+export function createLspSpawnEnv(
+	_root: string,
+	input: Record<string, string | undefined>,
+): Record<string, string | undefined> {
+	return { ...input };
+}
+
+function isDiagnostic(value: unknown): value is Diagnostic {
+	return isRecord(value) && isRange(value["range"]) && typeof value["message"] === "string";
+}
+
+function isRange(value: unknown): value is Diagnostic["range"] {
+	return isRecord(value) && isPosition(value["start"]) && isPosition(value["end"]);
+}
+
+function isPosition(value: unknown): value is Diagnostic["range"]["start"] {
+	return isRecord(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+}

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

@@ -3,41 +3,28 @@ import { INIT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, STOP_HARD_KILL_TIMEOUT_MS, STOP_SI
 import { LspConnectionClosedError, LspProcessExitedError, LspRequestTimeoutError } from "./errors.js";
 import { JsonRpcConnection } from "./json-rpc-connection.js";
 import { type SpawnedProcess, spawnProcess } from "./process.js";
+import { createLspSpawnEnv, parseConfigurationItems, parseDiagnosticsParams } from "./transport-protocol.js";
 import type { Diagnostic, ResolvedServer } from "./types.js";
+import type { WorkspaceApplyEditResponse } from "./workspace-mutation-controller.js";
 
-interface ConfigurationItem {
-	section?: string;
-}
-
-interface DiagnosticsParams {
-	uri: string;
-	diagnostics: Diagnostic[];
-}
+export { createLspSpawnEnv } from "./transport-protocol.js";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+export interface LspClientTimeoutOptions {
+	requestTimeoutMs?: number;
+	initializeTimeoutMs?: number;
 }
 
-function parseConfigurationItems(params: unknown): ConfigurationItem[] {
-	if (!isRecord(params) || !Array.isArray(params["items"])) return [];
-	const items: ConfigurationItem[] = [];
-	for (const item of params["items"]) {
-		if (!isRecord(item)) continue;
-		const section = item["section"];
-		items.push(section === undefined || typeof section !== "string" ? {} : { section });
-	}
-	return items;
-}
+type WorkspaceApplyEditHandler = (params: unknown) => Promise<WorkspaceApplyEditResponse>;
 
-function parseDiagnosticsParams(params: unknown): DiagnosticsParams | null {
-	if (!isRecord(params) || typeof params["uri"] !== "string") return null;
-	const diagnostics = Array.isArray(params["diagnostics"]) ? params["diagnostics"].filter(isDiagnostic) : [];
-	return { uri: params["uri"], diagnostics };
-}
+class LspClientNotStartedError extends Error {
+	override readonly name = "LspClientNotStartedError";
 
-export interface LspClientTimeoutOptions {
-	requestTimeoutMs?: number;
-	initializeTimeoutMs?: number;
+	constructor(
+		readonly serverId: string,
+		readonly root: string,
+	) {
+		super("LSP client not started");
+	}
 }
 
 export class LspClientTransport {
@@ -48,6 +35,8 @@ export class LspClientTransport {
 	protected readonly diagnosticsStore = new Map<string, Diagnostic[]>();
 	protected readonly requestTimeoutMs: number;
 	protected readonly initializeTimeoutMs: number;
+	private workspaceApplyEditHandler: WorkspaceApplyEditHandler | null = null;
+	private diagnosticPullSupported = false;
 
 	constructor(
 		protected readonly root: string,
@@ -66,6 +55,30 @@ export class LspClientTransport {
 		return [...this.server.command];
 	}
 
+	protected setWorkspaceApplyEditHandler(handler: WorkspaceApplyEditHandler): void {
+		this.workspaceApplyEditHandler = handler;
+	}
+
+	protected hasWorkspaceApplyEditHandler(): boolean {
+		return this.workspaceApplyEditHandler !== null;
+	}
+
+	protected setDiagnosticPullSupported(supported: boolean): void {
+		this.diagnosticPullSupported = supported;
+	}
+
+	protected isDiagnosticPullSupported(): boolean {
+		return this.diagnosticPullSupported;
+	}
+
+	protected handlePublishDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		this.diagnosticsStore.set(params.uri, [...params.diagnostics]);
+	}
+
 	async start(): Promise<void> {
 		const env = createLspSpawnEnv(this.root, {
 			...process.env,
@@ -78,8 +91,6 @@ export class LspClientTransport {
 		});
 		this.startStderrReading();
 
-		await new Promise<void>((resolve) => setTimeout(resolve, 100));
-
 		if (this.proc.exitCode !== null) {
 			const stderr = this.stderrBuffer.join("\n");
 			throw new LspProcessExitedError(this.server.id, this.root, this.proc.exitCode, stderr.slice(-2000));
@@ -90,7 +101,7 @@ export class LspClientTransport {
 		this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
 			const diagnosticsParams = parseDiagnosticsParams(params);
 			if (diagnosticsParams?.uri) {
-				this.diagnosticsStore.set(diagnosticsParams.uri, diagnosticsParams.diagnostics);
+				this.handlePublishDiagnostics(diagnosticsParams);
 			}
 		});
 
@@ -104,6 +115,9 @@ export class LspClientTransport {
 
 		this.connection.onRequest("client/registerCapability", () => null);
 		this.connection.onRequest("window/workDoneProgress/create", () => null);
+		if (this.workspaceApplyEditHandler) {
+			this.connection.onRequest("workspace/applyEdit", this.workspaceApplyEditHandler);
+		}
 
 		this.connection.onClose(() => {
 			this.processExited = true;
@@ -140,12 +154,16 @@ export class LspClientTransport {
 
 	protected sendRequest<T>(method: string): Promise<T>;
 	protected sendRequest<T>(method: string, params: unknown): Promise<T>;
-	protected sendRequest<T>(method: string, params: unknown, options: { timeoutMs?: number }): Promise<T>;
+	protected sendRequest<T>(
+		method: string,
+		params: unknown,
+		options: { timeoutMs?: number; signal?: AbortSignal },
+	): Promise<T>;
 	protected async sendRequest<T>(
 		method: string,
-		...args: [] | [unknown] | [unknown, { timeoutMs?: number }]
+		...args: [] | [unknown] | [unknown, { timeoutMs?: number; signal?: AbortSignal }]
 	): Promise<T> {
-		if (!this.connection) throw new Error("LSP client not started");
+		if (!this.connection) throw new LspClientNotStartedError(this.server.id, this.root);
 
 		if (this.processExited || (this.proc && this.proc.exitCode !== null)) {
 			const stderrTail = this.stderrBuffer.slice(-10).join("\n");
@@ -157,25 +175,22 @@ export class LspClientTransport {
 			);
 		}
 
-		const timeoutMs = args[1]?.timeoutMs ?? this.requestTimeoutMs;
-		let timeoutHandle: NodeJS.Timeout | null = null;
-		const timeoutPromise = new Promise<never>((_, reject) => {
-			timeoutHandle = setTimeout(() => {
-				const stderrTail = this.stderrBuffer.slice(-5).join("\n");
-				reject(new LspRequestTimeoutError(method, stderrTail || undefined));
-			}, timeoutMs);
-		});
+		const options = args[1];
+		const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
+		const timeoutController = new AbortController();
+		const timeoutHandle = setTimeout(() => {
+			const stderrTail = this.stderrBuffer.slice(-5).join("\n");
+			timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
+		}, timeoutMs);
+		const combinedSignal = combineAbortSignals(options?.signal, timeoutController.signal);
 
 		try {
-			const requestPromise =
+			const result =
 				args.length === 0
-					? this.connection.sendRequest<T>(method)
-					: this.connection.sendRequest<T>(method, args[0]);
-			const result = await Promise.race([requestPromise, timeoutPromise]);
-			if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+					? await this.connection.sendRequest<T>(method, undefined, { signal: combinedSignal.signal })
+					: await this.connection.sendRequest<T>(method, args[0], { signal: combinedSignal.signal });
 			return result;
 		} catch (error) {
-			if (timeoutHandle !== null) clearTimeout(timeoutHandle);
 			if (this.processExited || (this.proc && this.proc.exitCode !== null)) {
 				throw new LspProcessExitedError(
 					this.server.id,
@@ -188,6 +203,9 @@ export class LspClientTransport {
 				throw new LspConnectionClosedError(this.server.id, this.root, error.message);
 			}
 			throw error;
+		} finally {
+			clearTimeout(timeoutHandle);
+			combinedSignal.dispose();
 		}
 	}
 
@@ -219,17 +237,17 @@ export class LspClientTransport {
 			try {
 				await this.sendRequest<null>("shutdown");
 			} catch (error) {
-				reportBestEffortCleanupError("shutdown request", error);
+				reportBestEffortCleanupError("shutdown request", error instanceof Error ? error : String(error));
 			}
 			try {
 				await this.sendNotification("exit");
 			} catch (error) {
-				reportBestEffortCleanupError("exit notification", error);
+				reportBestEffortCleanupError("exit notification", error instanceof Error ? error : String(error));
 			}
 			try {
 				this.connection.dispose();
 			} catch (error) {
-				reportBestEffortCleanupError("connection dispose", error);
+				reportBestEffortCleanupError("connection dispose", error instanceof Error ? error : String(error));
 			}
 			this.connection = null;
 		}
@@ -262,11 +280,11 @@ export class LspClientTransport {
 							new Promise<void>((resolve) => setTimeout(resolve, STOP_SIGKILL_GRACE_MS)),
 						]);
 					} catch (error) {
-						reportBestEffortCleanupError("hard process kill", error);
+						reportBestEffortCleanupError("hard process kill", error instanceof Error ? error : String(error));
 					}
 				}
 			} catch (error) {
-				reportBestEffortCleanupError("process stop", error);
+				reportBestEffortCleanupError("process stop", error instanceof Error ? error : String(error));
 			}
 		}
 
@@ -279,21 +297,29 @@ export class LspClientTransport {
 	}
 }
 
-export function createLspSpawnEnv(
-	_root: string,
-	input: Record<string, string | undefined>,
-): Record<string, string | undefined> {
-	return { ...input };
-}
-
-function isDiagnostic(value: unknown): value is Diagnostic {
-	return isRecord(value) && isRange(value["range"]) && typeof value["message"] === "string";
-}
-
-function isRange(value: unknown): value is Diagnostic["range"] {
-	return isRecord(value) && isPosition(value["start"]) && isPosition(value["end"]);
-}
-
-function isPosition(value: unknown): value is Diagnostic["range"]["start"] {
-	return isRecord(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+function combineAbortSignals(
+	primary: AbortSignal | undefined,
+	secondary: AbortSignal,
+): { readonly signal: AbortSignal; readonly dispose: () => void } {
+	const controller = new AbortController();
+	const abortFrom = (signal: AbortSignal): void => {
+		if (!controller.signal.aborted) controller.abort(signal.reason);
+	};
+	const onPrimaryAbort = (): void => {
+		if (primary) abortFrom(primary);
+	};
+	const onSecondaryAbort = (): void => abortFrom(secondary);
+
+	if (primary?.aborted) abortFrom(primary);
+	else primary?.addEventListener("abort", onPrimaryAbort, { once: true });
+	if (secondary.aborted) abortFrom(secondary);
+	else secondary.addEventListener("abort", onSecondaryAbort, { once: true });
+
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			primary?.removeEventListener("abort", onPrimaryAbort);
+			secondary.removeEventListener("abort", onSecondaryAbort);
+		},
+	};
 }

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

@@ -0,0 +1,19 @@
+export type WorkspaceApplyEditConcurrentPhase = "applying" | "settled";
+
+const CONCURRENT_FAILURE_REASON_BY_PHASE: Readonly<Record<WorkspaceApplyEditConcurrentPhase, string>> = {
+	applying: "workspace/applyEdit is already in progress for this workspace mutation",
+	settled: "workspace/applyEdit was already handled for this workspace mutation",
+};
+
+export const CANONICAL_CONCURRENT_WORKSPACE_APPLY_EDIT_FAILURE_REASON =
+	"workspace/applyEdit concurrent for this workspace mutation";
+
+export function workspaceApplyEditConcurrentFailureReason(phase: WorkspaceApplyEditConcurrentPhase): string {
+	return CONCURRENT_FAILURE_REASON_BY_PHASE[phase];
+}
+
+export function canonicalizeWorkspaceApplyEditFailureReason(reason: string): string {
+	return Object.values(CONCURRENT_FAILURE_REASON_BY_PHASE).includes(reason)
+		? CANONICAL_CONCURRENT_WORKSPACE_APPLY_EDIT_FAILURE_REASON
+		: reason;
+}

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

@@ -0,0 +1,214 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	readEvents,
+	renameTextEdit,
+	waitForEventCount,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient workspace mutation lease", () => {
+	it("#given no mutating request #when the server calls applyEdit #then the request is rejected as unscoped", async () => {
+		const context = await harness.makeClient({ unscopedApplyEdit: renameTextEdit("before", "after", { version: 1 }) });
+
+		const responses = await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+			1,
+		);
+
+		expect(responses[0]?.result).toEqual({
+			applied: false,
+			failureReason: expect.stringContaining("active workspace mutation"),
+		});
+		expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given one valid server apply #when the server applies twice #then the repeated request is rejected", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{ applyEdit: renameTextEdit("before", "after", { version: 1 }), applyTwice: true, renameResult: "same" },
+			],
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		const responses = readEvents(context.events).filter(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(responses).toHaveLength(2);
+		expect(responses[0]?.result).toEqual({ applied: true });
+		expect(responses[1]?.result).toEqual({
+			applied: false,
+			failureReason: expect.stringContaining("already handled"),
+		});
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given two concurrent server applies #when one enters commit #then the other is rejected without a second write", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{
+					applyEdit: renameTextEdit("before", "after", { version: 1 }),
+					applyConcurrently: true,
+					renameResult: "same",
+				},
+			],
+		});
+		let writes = 0;
+		context.client.setWorkspaceEditIo({
+			writeFile(path, content) {
+				writes += 1;
+				writeFileSync(path, content, "utf-8");
+			},
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(writes).toBe(1);
+		const responses = readEvents(context.events).filter(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(responses.map((response) => response.result)).toContainEqual({ applied: true });
+		const rejection = responses.find(
+			(response) => typeof response.result === "object" && response.result !== null && "failureReason" in response.result,
+		);
+		expect(rejection?.result).toMatchObject({ applied: false });
+		expect(JSON.stringify(rejection?.result)).toMatch(/already (?:in progress|handled)/);
+	});
+
+	it("#given a rename lease is held #when another rename starts #then it is rejected without a second request", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{
+					renameResult: "edit",
+					renameEdit: renameTextEdit("before", "after", { version: 1 }),
+					responseDelayMs: 150,
+				},
+			],
+		});
+		await context.client.openFile(context.source);
+		const firstPromise = context.client.rename(context.source, 1, 6, "after");
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientRequest" && event.method === "textDocument/rename",
+			1,
+		);
+
+		const concurrent = await context.client.rename(context.source, 1, 6, "other_");
+		const first = await firstPromise;
+
+		expect(concurrent.apply.success).toBe(false);
+		expect(concurrent.apply.errors.join("\n")).toContain("workspace mutation is already in progress");
+		expect(first.apply.success).toBe(true);
+		const requests = readEvents(context.events).filter(
+			(event) => event.type === "clientRequest" && event.method === "textDocument/rename",
+		);
+		expect(requests).toHaveLength(1);
+	});
+
+	it("#given no server apply #when rename directly returns an edit #then it is applied exactly once", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ renameResult: "edit", renameEdit: renameTextEdit("before", "after", { version: 1 }) }],
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+		expect(readEvents(context.events).filter((event) => event.method === "workspace/applyEdit")).toHaveLength(0);
+	});
+
+	it("#given cancellation before a delayed server apply #when the rename request is aborted #then no file is mutated", async () => {
+		const controller = new AbortController();
+		const context = await harness.makeClient({
+			renameSteps: [
+				{
+					applyEdit: renameTextEdit("before", "after", { version: 1 }),
+					applyDelayMs: 100,
+					renameResult: "same",
+				},
+			],
+		});
+		await context.client.openFile(context.source);
+		const rename = context.client.rename(context.source, 1, 6, "after", controller.signal);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientRequest" && event.method === "textDocument/rename",
+			1,
+		);
+		controller.abort();
+
+		await expect(rename).rejects.toThrow(/cancel/i);
+
+		const [cancel] = await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientNotification" && event.method === "$/cancelRequest",
+			1,
+		);
+		expect(cancel?.params).toEqual({ id: 2 });
+		expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given cancellation after the commit gate #when applyEdit finishes #then rename reports one completed late-abort mutation", async () => {
+		const controller = new AbortController();
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+		});
+		let writes = 0;
+		context.client.setWorkspaceEditIo({
+			writeFile(path, content) {
+				writes += 1;
+				writeFileSync(path, content, "utf-8");
+				controller.abort();
+			},
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after", controller.signal);
+
+		expect(result.apply).toMatchObject({ success: true, lateAbort: true, totalEdits: 1 });
+		expect(writes).toBe(1);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given lease-backed and bare clients #when initialized #then applyEdit and annotations are advertised honestly", async () => {
+		const active = await harness.makeClient({});
+		const inactive = await harness.makeBareConnection({});
+
+		const activeCapabilities = initializeCapabilities(active.events);
+		const inactiveCapabilities = initializeCapabilities(inactive.events);
+		expect(activeCapabilities.workspace?.applyEdit).toBe(true);
+		expect(inactiveCapabilities.workspace?.applyEdit).toBeUndefined();
+		expect(activeCapabilities.textDocument?.rename?.honorsChangeAnnotations).toBeUndefined();
+		expect(activeCapabilities.workspace?.workspaceEdit?.changeAnnotationSupport).toBeUndefined();
+	});
+});
+
+interface InitializeCapabilities {
+	readonly workspace?: {
+		readonly applyEdit?: boolean;
+		readonly workspaceEdit?: { readonly changeAnnotationSupport?: unknown };
+	};
+	readonly textDocument?: { readonly rename?: { readonly honorsChangeAnnotations?: boolean } };
+}
+
+function initializeCapabilities(path: string): InitializeCapabilities {
+	const initialize = readEvents(path).find(
+		(event) => event.type === "clientRequest" && event.method === "initialize",
+	);
+	return (initialize?.params as { capabilities?: InitializeCapabilities } | undefined)?.capabilities ?? {};
+}

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

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import type { WorkspaceEdit } from "./types.js";
+import {
+	createWorkspaceEditTestHarness,
+	readEvents,
+	renameTextEdit,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient workspace edit synchronization", () => {
+	it("#given an open edited document #when applyEdit commits #then didChange precedes didSave with the next version", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+		});
+		await context.client.openFile(context.source);
+
+		await context.client.rename(context.source, 1, 6, "after");
+
+		const notifications = readEvents(context.events).filter((event) => event.type === "clientNotification");
+		const changeIndex = notifications.findIndex((event) => event.method === "textDocument/didChange");
+		const saveIndex = notifications.findIndex((event) => event.method === "textDocument/didSave");
+		expect(changeIndex).toBeGreaterThan(-1);
+		expect(saveIndex).toBeGreaterThan(changeIndex);
+		expect(notifications[changeIndex]?.params).toMatchObject({ textDocument: { version: 2 } });
+	});
+
+	it("#given an open file resource rename #when applyEdit commits #then didClose and didOpen move document state", async () => {
+		const edit: WorkspaceEdit = {
+			documentChanges: [{ kind: "rename", oldUri: "file:///placeholder", newUri: "file:///destination" }],
+		};
+		const context = await harness.makeClient({ renameSteps: [{ applyEdit: edit, renameResult: "null" }] });
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(existsSync(context.source)).toBe(false);
+		expect(readFileSync(context.destination, "utf-8")).toBe("const before = 1;\n");
+		expect(context.client.getOpenDocumentVersion(context.source)).toBeUndefined();
+		expect(context.client.getOpenDocumentVersion(context.destination)).toBe(1);
+		const methods = readEvents(context.events).map((event) => event.method);
+		expect(methods.indexOf("textDocument/didClose")).toBeLessThan(methods.lastIndexOf("textDocument/didOpen"));
+	});
+
+	it("#given an open file deletion #when applyEdit commits #then didClose removes document state", async () => {
+		const edit: WorkspaceEdit = { documentChanges: [{ kind: "delete", uri: "file:///placeholder" }] };
+		const context = await harness.makeClient({ renameSteps: [{ applyEdit: edit, renameResult: "null" }] });
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(existsSync(context.source)).toBe(false);
+		expect(context.client.getOpenDocumentVersion(context.source)).toBeUndefined();
+		expect(readEvents(context.events).some((event) => event.method === "textDocument/didClose")).toBe(true);
+	});
+
+	it("#given a closed edited file #when applyEdit commits #then one changed watched-file event is emitted", async () => {
+		const edit = renameTextEdit("closed", "after_", { version: null, uri: "file:///closed" });
+		const context = await harness.makeClient({ renameSteps: [{ applyEdit: edit, renameResult: "null" }] });
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(readFileSync(context.closed, "utf-8")).toBe("const after_ = 1;\n");
+		const watched = readEvents(context.events).find(
+			(event) => event.type === "clientNotification" && event.method === "workspace/didChangeWatchedFiles",
+		);
+		expect(watched?.params).toEqual({ changes: [{ uri: pathToFileURL(realpathSync(context.closed)).href, type: 2 }] });
+	});
+
+	it("#given a new closed file #when applyEdit creates it #then one created watched-file event is emitted", async () => {
+		const edit: WorkspaceEdit = { documentChanges: [{ kind: "create", uri: "file:///created" }] };
+		const context = await harness.makeClient({ renameSteps: [{ applyEdit: edit, renameResult: "null" }] });
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(readFileSync(context.created, "utf-8")).toBe("");
+		const watched = readEvents(context.events).find(
+			(event) => event.type === "clientNotification" && event.method === "workspace/didChangeWatchedFiles",
+		);
+		expect(watched?.params).toEqual({ changes: [{ uri: pathToFileURL(realpathSync(context.created)).href, type: 1 }] });
+	});
+
+	it("#given an open file overwritten by create #when applyEdit commits #then didClose and didOpen reset its state", async () => {
+		const edit: WorkspaceEdit = {
+			documentChanges: [{ kind: "create", uri: "file:///closed", options: { overwrite: true } }],
+		};
+		const context = await harness.makeClient({ renameSteps: [{ applyEdit: edit, renameResult: "null" }] });
+		await context.client.openFile(context.source);
+		await context.client.openFile(context.closed);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(true);
+		expect(readFileSync(context.closed, "utf-8")).toBe("");
+		expect(context.client.getOpenDocumentVersion(context.closed)).toBe(1);
+		const methods = readEvents(context.events).map((event) => event.method);
+		expect(methods.indexOf("textDocument/didClose")).toBeLessThan(methods.lastIndexOf("textDocument/didOpen"));
+	});
+});