lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,218 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	readEvents,
+	renameTextEdit,
+	waitForEventCount,
+	waitForEventCountBySubscription,
+} 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({
+			unscopedApplyEditOnDidOpen: renameTextEdit("before", "after", { version: 1 }),
+		});
+		const response = waitForEventCountBySubscription(
+			context.events,
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+			1,
+		);
+		await context.client.openFile(context.source);
+		const responses = await response;
+
+		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"));
+	});
+});

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

@@ -0,0 +1,194 @@
+import { mkdtempSync, readFileSync, realpathSync, rmSync, watch, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { LspClient } from "./client.js";
+import { LspClientConnection } from "./connection.js";
+import type { LspClientOptions } from "./client.js";
+import type { LspClientTransport } from "./transport.js";
+import type { Diagnostic, ResolvedServer, WorkspaceEdit } from "./types.js";
+
+const fixturePath = join(dirname(fileURLToPath(import.meta.url)), "fixtures", "workspace-edit-server.mjs");
+
+export interface RecordedEvent {
+	readonly type: string;
+	readonly id?: string | number;
+	readonly method?: string;
+	readonly params?: unknown;
+	readonly result?: unknown;
+	readonly error?: unknown;
+}
+
+export interface WorkspaceEditTestContext {
+	readonly client: LspClient;
+	readonly workspace: string;
+	readonly source: string;
+	readonly destination: string;
+	readonly closed: string;
+	readonly created: string;
+	readonly events: string;
+}
+
+export function createWorkspaceEditTestHarness() {
+	const tempDirectories: string[] = [];
+	const clients: LspClientTransport[] = [];
+
+	return {
+		async cleanup(): Promise<void> {
+			for (const client of clients.splice(0)) await client.stop();
+			for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
+		},
+		async makeClient(
+			scenario: Record<string, unknown>,
+			clientOptions: Partial<LspClientOptions> = {},
+		): Promise<WorkspaceEditTestContext> {
+			const fixture = createFixture(scenario, tempDirectories);
+			const client = new LspClient(fixture.workspace, fixture.server, {
+				requestTimeoutMs: 5_000,
+				initializeTimeoutMs: 5_000,
+				...clientOptions,
+			});
+			clients.push(client);
+			await client.start();
+			await client.initialize();
+			return { client, ...fixture.paths };
+		},
+		async makeBareConnection(
+			scenario: Record<string, unknown>,
+		): Promise<{ readonly connection: LspClientConnection; readonly events: string }> {
+			const fixture = createFixture(scenario, tempDirectories);
+			const connection = new LspClientConnection(fixture.workspace, fixture.server, {
+				requestTimeoutMs: 5_000,
+				initializeTimeoutMs: 5_000,
+			});
+			clients.push(connection);
+			await connection.start();
+			await connection.initialize();
+			return { connection, events: fixture.paths.events };
+		},
+	};
+}
+
+function createFixture(scenario: Record<string, unknown>, tempDirectories: string[]) {
+	// The fixture server echoes URIs built from the canonical temp path, so the client root must be
+	// canonical too. On macOS tmpdir() is a /var -> /private/var symlink; without realpath the
+	// publishes target a document the client never opened (#9476).
+	const workspace = mkdtempSync(join(realpathSync(tmpdir()), "lsp-apply-edit-"));
+	tempDirectories.push(workspace);
+	const source = join(workspace, "source.ts");
+	const destination = join(workspace, "destination.ts");
+	const closed = join(workspace, "closed.ts");
+	const created = join(workspace, "created.ts");
+	const scenarioPath = join(workspace, "scenario.json");
+	const events = join(workspace, "events.jsonl");
+	writeFileSync(source, "const before = 1;\n", "utf-8");
+	writeFileSync(closed, "const closed = 1;\n", "utf-8");
+	const uriByPlaceholder = new Map([
+		["file:///placeholder", pathToFileURL(source).href],
+		["file:///destination", pathToFileURL(destination).href],
+		["file:///closed", pathToFileURL(closed).href],
+		["file:///created", pathToFileURL(created).href],
+	]);
+	writeFileSync(scenarioPath, JSON.stringify(replacePlaceholderUris(scenario, uriByPlaceholder)), "utf-8");
+	writeFileSync(events, "", "utf-8");
+	const server: ResolvedServer = {
+		id: "workspace-edit-fixture",
+		command: [process.env["NODE_BINARY"] ?? "node", fixturePath, scenarioPath, events],
+		extensions: [".ts"],
+		priority: 0,
+	};
+	return { workspace, server, paths: { workspace, source, destination, closed, created, events } };
+}
+
+function replacePlaceholderUris(value: unknown, uriByPlaceholder: ReadonlyMap<string, string>): unknown {
+	if (Array.isArray(value)) return value.map((item) => replacePlaceholderUris(item, uriByPlaceholder));
+	if (typeof value !== "object" || value === null) {
+		return typeof value === "string" ? (uriByPlaceholder.get(value) ?? value) : value;
+	}
+	return Object.fromEntries(
+		Object.entries(value).map(([key, item]) => [key, replacePlaceholderUris(item, uriByPlaceholder)]),
+	);
+}
+
+interface RenameTextEditTarget {
+	readonly version: number | null;
+	readonly uri?: string;
+}
+
+export function renameTextEdit(before: string, after: string, target: RenameTextEditTarget): WorkspaceEdit {
+	const uri = target.uri ?? "file:///placeholder";
+	return {
+		documentChanges: [
+			{
+				textDocument: { uri, version: target.version },
+				edits: [
+					{
+						range: { start: { line: 0, character: 6 }, end: { line: 0, character: 6 + before.length } },
+						newText: after,
+					},
+				],
+			},
+		],
+	};
+}
+
+export function diagnostic(message: string): Diagnostic {
+	return { range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } }, message };
+}
+
+export function readEvents(path: string): readonly RecordedEvent[] {
+	const events: RecordedEvent[] = [];
+	for (const line of readFileSync(path, "utf-8").split("\n")) {
+		if (!line) continue;
+		const value: unknown = JSON.parse(line);
+		if (isRecordedEvent(value)) events.push(value);
+	}
+	return events;
+}
+
+export async function waitForEventCount(
+	path: string,
+	predicate: (event: RecordedEvent) => boolean,
+	count: number,
+): Promise<readonly RecordedEvent[]> {
+	const deadline = Date.now() + 2_000;
+	while (Date.now() < deadline) {
+		const matches = readEvents(path).filter(predicate);
+		if (matches.length >= count) return matches;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	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-apply-edit.integration.test.ts

@@ -0,0 +1,163 @@
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	renameTextEdit,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient workspace/applyEdit", () => {
+	it("#given a server-applied edit returned again by rename #when rename completes #then one write is reused truthfully", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+			diagnostics: [diagnostic("fresh")],
+		});
+		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(result.apply.totalEdits).toBe(1);
+		expect(writes).toBe(1);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+		expect(context.client.getOpenDocumentVersion(context.source)).toBe(2);
+		expect(context.client.getStoredDiagnostics(pathToFileURL(realpathSync(context.source)).href)).toEqual([
+			diagnostic("fresh"),
+		]);
+		const responses = readEvents(context.events).filter(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(responses).toHaveLength(1);
+		expect(responses[0]?.result).toEqual({ applied: true });
+	});
+
+	it("#given a server-applied edit and a null rename result #when rename completes #then the recorded result is reused", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "null" }],
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.edit).toBeNull();
+		expect(result.apply.success).toBe(true);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given two versioned server edits #when applied sequentially #then the synchronized version accepts the second edit", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{ applyEdit: renameTextEdit("before", "first_", { version: 1 }), renameResult: "same" },
+				{ applyEdit: renameTextEdit("first_", "second", { version: 2 }), renameResult: "same" },
+			],
+		});
+		await context.client.openFile(context.source);
+
+		const first = await context.client.rename(context.source, 1, 6, "first_");
+		const second = await context.client.rename(context.source, 1, 6, "second");
+
+		expect(first.apply.success).toBe(true);
+		expect(second.apply.success).toBe(true);
+		expect(context.client.getOpenDocumentVersion(context.source)).toBe(3);
+		expect(readFileSync(context.source, "utf-8")).toBe("const second = 1;\n");
+	});
+
+	it("#given a mismatched document version #when the server requests applyEdit #then mutation is rejected truthfully", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 9 }), renameResult: "same" }],
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(false);
+		expect(result.apply.errors.join("\n")).toContain("document version");
+		expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n");
+		const response = readEvents(context.events).find(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(response?.result).toEqual({
+			applied: false,
+			failureReason: expect.stringContaining("document version"),
+			failedChange: 0,
+		});
+	});
+
+	it("#given a server-applied edit and a different rename result #when rename completes #then conflict is reported without a second mutation", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [
+				{
+					applyEdit: renameTextEdit("before", "after", { version: 1 }),
+					renameResult: "different",
+					differentEdit: renameTextEdit("before", "other_", { version: 1 }),
+				},
+			],
+		});
+		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(false);
+		expect(result.apply.errors.join("\n")).toContain("conflicts with server-applied workspace edit");
+		expect(writes).toBe(1);
+		expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given a real commit I/O failure #when the server requests applyEdit #then both protocol and rename result report failure", async () => {
+		const context = await harness.makeClient({
+			renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+		});
+		context.client.setWorkspaceEditIo({
+			writeFile() {
+				throw new InjectedWorkspaceIoError();
+			},
+		});
+		await context.client.openFile(context.source);
+
+		const result = await context.client.rename(context.source, 1, 6, "after");
+
+		expect(result.apply.success).toBe(false);
+		expect(result.apply.errors.join("\n")).toContain("I/O failure during text");
+		expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n");
+		const response = readEvents(context.events).find(
+			(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		);
+		expect(response?.result).toEqual({
+			applied: false,
+			failureReason: expect.stringContaining("I/O failure during text"),
+			failedChange: 0,
+		});
+	});
+});
+
+class InjectedWorkspaceIoError extends Error {
+	override readonly name = "InjectedWorkspaceIoError";
+
+	constructor() {
+		super("injected workspace I/O failure");
+	}
+}