lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,150 @@
+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[] = [];
+		const documents = new WorkspaceDocumentState(
+			async (method, params) => {
+				if (method === "workspace/didChangeWatchedFiles") notifications.push(params);
+			},
+			() => {},
+			{ versionlessPublishQuiescenceMs: 0 },
+		);
+		const changedPaths = Array.from({ length: 129 }, (_, index) => `/workspace/file-${index}.ts`);
+		const operations: WorkspaceMutation[] = changedPaths.map((path) => ({
+			kind: "create",
+			path,
+			replaced: false,
+		}));
+
+		await documents.synchronize({ operations, changedPaths });
+
+		expect(notifications).toHaveLength(2);
+		expect(notificationChanges(notifications[0])).toHaveLength(128);
+		expect(notificationChanges(notifications[1])).toHaveLength(1);
+	});
+
+	it("#given changed closed files #when synchronized #then sends bounded changed watched-file notifications", async () => {
+		const notifications: unknown[] = [];
+		const documents = new WorkspaceDocumentState(
+			async (method, params) => {
+				if (method === "workspace/didChangeWatchedFiles") notifications.push(params);
+			},
+			() => {},
+			{ versionlessPublishQuiescenceMs: 0 },
+		);
+		const changedPaths = Array.from({ length: 129 }, (_, index) => `/workspace/file-${index}.ts`);
+		const operations: WorkspaceMutation[] = changedPaths.map((path) => ({
+			kind: "text",
+			path,
+			beforeText: "before",
+			afterText: "after",
+		}));
+
+		await documents.synchronize({ operations, changedPaths });
+
+		expect(notifications).toHaveLength(2);
+		expect(notificationChanges(notifications[0])).toHaveLength(128);
+		expect(notificationChanges(notifications[1])).toHaveLength(1);
+		expect(notificationTypes(notifications[0])).toEqual(Array.from({ length: 128 }, () => 2));
+		expect(notificationTypes(notifications[1])).toEqual([2]);
+	});
+});
+
+function notificationChanges(value: unknown): readonly unknown[] {
+	if (typeof value !== "object" || value === null || !("changes" in value) || !Array.isArray(value.changes)) return [];
+	return value.changes;
+}
+
+function notificationTypes(value: unknown): readonly unknown[] {
+	return notificationChanges(value).map((change) => {
+		if (typeof change !== "object" || change === null || !("type" in change)) return undefined;
+		return change.type;
+	});
+}

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

@@ -0,0 +1,392 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { relative, resolve } from "node:path";
+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;
+const DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+
+type SendNotification = (method: string, params: unknown) => Promise<void>;
+
+interface OpenDocumentState {
+	readonly path: string;
+	readonly uri: string;
+	readonly languageId: string;
+	text: string;
+	version: number;
+	generation: number;
+	publishGeneration: number;
+	lastPublish?: PublishedDiagnostics;
+	pullCache?: PullDiagnosticsCache;
+	waiters: Set<() => void>;
+}
+
+interface WatchedFileEvent {
+	readonly uri: string;
+	readonly type: 1 | 2 | 3;
+}
+
+interface PublishedDiagnostics {
+	readonly diagnostics: readonly Diagnostic[];
+	readonly publishGeneration: number;
+	readonly documentGenerationAtArrival: number;
+	readonly arrivedAt: number;
+	readonly version?: number;
+}
+
+interface PullDiagnosticsCache {
+	readonly documentVersion: number;
+	readonly diagnostics: readonly Diagnostic[];
+	readonly resultId?: string;
+}
+
+export interface DocumentVersionFailure {
+	readonly changeIndex: number;
+	readonly message: string;
+}
+
+export interface DiagnosticSnapshot {
+	readonly path: string;
+	readonly uri: string;
+	readonly version: number;
+	readonly documentGeneration: number;
+	readonly publishGeneration: number;
+}
+
+export interface PullDiagnosticsReport {
+	readonly diagnostics: readonly Diagnostic[];
+	readonly kind: "full";
+	readonly resultId?: string;
+}
+
+export interface PullDiagnosticsCacheHit {
+	readonly documentVersion: number;
+	readonly diagnostics: readonly Diagnostic[];
+	readonly resultId?: string;
+}
+
+export type PushDiagnosticsResolution =
+	| { readonly status: "ready"; readonly diagnostics: readonly Diagnostic[] }
+	| { readonly status: "wait"; readonly waitMs: number }
+	| { readonly status: "missing" };
+
+export interface WorkspaceDocumentStateOptions {
+	readonly now?: () => number;
+	readonly timerProvider?: TimerProvider;
+	readonly versionlessPublishQuiescenceMs?: number;
+}
+
+function canonicalPath(filePath: string): string {
+	const absolute = resolve(filePath);
+	try {
+		return realpathSync(absolute);
+	} catch {
+		return absolute;
+	}
+}
+
+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 !== "..");
+}
+
+function movedPath(candidate: string, oldPath: string, newPath: string): string {
+	const suffix = relative(oldPath, candidate);
+	return suffix === "" ? newPath : resolve(newPath, suffix);
+}
+
+export class WorkspaceDocumentState {
+	private readonly openDocuments = new Map<string, OpenDocumentState>();
+	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(
+		private readonly sendNotification: SendNotification,
+		private readonly clearDiagnostics: (uri: string) => void,
+		options: WorkspaceDocumentStateOptions = {},
+	) {
+		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: string): Promise<void> {
+		const path = canonicalPath(filePath);
+		const existingOpen = this.openPromises.get(path);
+		if (existingOpen) {
+			await existingOpen;
+			return this.openFile(path);
+		}
+
+		const text = readFileSync(path, "utf-8");
+		const existing = this.openDocuments.get(path);
+		if (!existing) return this.openDocumentSingleFlight(path, text);
+		if (existing.text === text) return;
+		await this.changeDocument(existing, text);
+	}
+
+	getVersion(filePath: string): number | undefined {
+		return this.openDocuments.get(canonicalPath(filePath))?.version;
+	}
+
+	getStoredDiagnostics(uri: string): readonly Diagnostic[] {
+		const state = this.openByUri.get(normalizeDocumentUri(uri));
+		if (!state) return [];
+		return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
+	}
+
+	captureDiagnosticSnapshot(filePath: string): DiagnosticSnapshot | null {
+		const state = this.openDocuments.get(canonicalPath(filePath));
+		if (!state) return null;
+		return {
+			path: state.path,
+			uri: state.uri,
+			version: state.version,
+			documentGeneration: state.generation,
+			publishGeneration: state.publishGeneration,
+		};
+	}
+
+	isCurrentSnapshot(snapshot: DiagnosticSnapshot): boolean {
+		const state = this.openDocuments.get(snapshot.path);
+		return (
+			state !== undefined &&
+			state.uri === snapshot.uri &&
+			state.version === snapshot.version &&
+			state.generation === snapshot.documentGeneration
+		);
+	}
+
+	getPullCache(snapshot: DiagnosticSnapshot): PullDiagnosticsCacheHit | null {
+		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(normalizeDocumentUri(snapshot.uri));
+		if (!state) return;
+		state.pullCache = {
+			documentVersion: snapshot.version,
+			diagnostics: [...report.diagnostics],
+			...(report.resultId === undefined ? {} : { resultId: report.resultId }),
+		};
+	}
+
+	recordPublishedDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		const state = this.openByUri.get(normalizeDocumentUri(params.uri));
+		if (!state) return;
+		state.publishGeneration += 1;
+		state.lastPublish = {
+			diagnostics: [...params.diagnostics],
+			publishGeneration: state.publishGeneration,
+			documentGenerationAtArrival: state.generation,
+			arrivedAt: this.now(),
+			...(params.version === undefined ? {} : { version: params.version }),
+		};
+		this.notifyWaiters(state);
+	}
+
+	resolvePushDiagnostics(snapshot: DiagnosticSnapshot): PushDiagnosticsResolution {
+		const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
+		if (!state?.lastPublish) return { status: "missing" };
+		const publish = state.lastPublish;
+		if (publish.version !== undefined) {
+			return publish.version === snapshot.version
+				? { status: "ready", diagnostics: publish.diagnostics }
+				: { status: "missing" };
+		}
+		if (publish.documentGenerationAtArrival < snapshot.documentGeneration) return { status: "missing" };
+		const readyAt = publish.arrivedAt + this.versionlessPublishQuiescenceMs;
+		const waitMs = Math.max(0, readyAt - this.now());
+		return waitMs === 0
+			? { status: "ready", diagnostics: publish.diagnostics }
+			: { status: "wait", waitMs };
+	}
+
+	waitForDiagnosticsActivity(snapshot: DiagnosticSnapshot, timeoutMs: number): Promise<void> {
+		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;
+				this.timerProvider.clearTimeout(timer);
+				state.waiters.delete(finish);
+				resolveActivity();
+			};
+			const timer = this.timerProvider.setTimeout(finish, timeoutMs);
+			if (typeof timer.unref === "function") timer.unref();
+			state.waiters.add(finish);
+		});
+	}
+
+	validateVersions(operations: readonly PlannedWorkspaceOperation[]): DocumentVersionFailure | null {
+		const versions = new Map([...this.openDocuments].map(([path, state]) => [path, state.version]));
+		for (const operation of operations) {
+			if (operation.kind === "text") {
+				const current = versions.get(operation.path);
+				if (operation.documentVersion !== null && current !== operation.documentVersion) {
+					const observed = current === undefined ? "closed document" : `open document version ${current}`;
+					return {
+						changeIndex: operation.changeIndex,
+						message: `document version ${operation.documentVersion} does not match ${observed} for ${operation.path}`,
+					};
+				}
+				if (current !== undefined) versions.set(operation.path, current + 1);
+				continue;
+			}
+			if (operation.kind === "rename") {
+				const moved = [...versions].filter(([path]) => isSameOrDescendant(path, operation.oldPath));
+				for (const [path] of moved) versions.delete(path);
+				for (const [path] of moved) versions.set(movedPath(path, operation.oldPath, operation.newPath), 1);
+				continue;
+			}
+			if (operation.kind === "delete") {
+				for (const path of [...versions.keys()]) {
+					if (isSameOrDescendant(path, operation.path)) versions.delete(path);
+				}
+				continue;
+			}
+			if (operation.kind === "create" && operation.replaced && versions.has(operation.path)) {
+				versions.set(operation.path, 1);
+			}
+		}
+		return null;
+	}
+
+	async synchronize(delta: WorkspaceMutationDelta): Promise<void> {
+		const watched: WatchedFileEvent[] = [];
+		for (const mutation of delta.operations) await this.synchronizeMutation(mutation, watched);
+		for (let index = 0; index < watched.length; index += WATCHED_FILE_BATCH_SIZE) {
+			await this.sendNotification("workspace/didChangeWatchedFiles", {
+				changes: watched.slice(index, index + WATCHED_FILE_BATCH_SIZE),
+			});
+		}
+	}
+
+	private async synchronizeMutation(mutation: WorkspaceMutation, watched: WatchedFileEvent[]): Promise<void> {
+		if (mutation.kind === "text") {
+			const state = this.openDocuments.get(mutation.path);
+			if (state) await this.changeDocument(state, mutation.afterText);
+			else watched.push({ uri: pathToFileURL(mutation.path).href, type: 2 });
+			return;
+		}
+		if (mutation.kind === "create") {
+			const state = this.openDocuments.get(mutation.path);
+			if (state) {
+				await this.closeDocument(state);
+				await this.openDocumentSingleFlight(mutation.path, readFileSync(mutation.path, "utf-8"));
+			} else {
+				watched.push({ uri: pathToFileURL(mutation.path).href, type: mutation.replaced ? 2 : 1 });
+			}
+			return;
+		}
+		if (mutation.kind === "rename") {
+			const moved = [...this.openDocuments.values()].filter((state) =>
+				isSameOrDescendant(state.path, mutation.oldPath),
+			);
+			for (const state of moved) await this.closeDocument(state);
+			for (const state of moved) {
+				const path = movedPath(state.path, mutation.oldPath, mutation.newPath);
+				await this.openDocumentSingleFlight(path, readFileSync(path, "utf-8"));
+			}
+			if (moved.length === 0) {
+				watched.push({ uri: pathToFileURL(mutation.oldPath).href, type: 3 });
+				watched.push({ uri: pathToFileURL(mutation.newPath).href, type: 1 });
+			}
+			return;
+		}
+		const removed = [...this.openDocuments.values()].filter((state) =>
+			isSameOrDescendant(state.path, mutation.path),
+		);
+		for (const state of removed) await this.closeDocument(state);
+		if (removed.length === 0) watched.push({ uri: pathToFileURL(mutation.path).href, type: 3 });
+	}
+
+	private async openDocumentSingleFlight(path: string, text: string): Promise<void> {
+		const existing = this.openPromises.get(path);
+		if (existing) return existing;
+		const open = (async () => {
+			const state: OpenDocumentState = {
+				path,
+				uri: pathToFileURL(path).href,
+				languageId: getLanguageId(effectiveExtension(path)),
+				text,
+				version: 1,
+				generation: 1,
+				publishGeneration: 0,
+				waiters: new Set(),
+			};
+			this.openDocuments.set(path, 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 },
+			});
+		})().finally(() => {
+			this.openPromises.delete(path);
+		});
+		this.openPromises.set(path, open);
+		return open;
+	}
+
+	private async changeDocument(state: OpenDocumentState, text: string): Promise<void> {
+		state.text = text;
+		state.version += 1;
+		state.generation += 1;
+		this.clearDiagnostics(state.uri);
+		this.notifyWaiters(state);
+		await this.sendNotification("textDocument/didChange", {
+			textDocument: { uri: state.uri, version: state.version },
+			contentChanges: [{ text }],
+		});
+		await this.sendNotification("textDocument/didSave", { textDocument: { uri: state.uri }, text });
+	}
+
+	private async closeDocument(state: OpenDocumentState): Promise<void> {
+		this.openDocuments.delete(state.path);
+		this.openByUri.delete(normalizeDocumentUri(state.uri));
+		this.clearDiagnostics(state.uri);
+		this.notifyWaiters(state);
+		await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });
+	}
+
+	private notifyWaiters(state: OpenDocumentState): void {
+		for (const waiter of [...state.waiters]) waiter();
+	}
+}

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

@@ -0,0 +1,132 @@
+import { mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, 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 { applyWorkspaceEdit, planWorkspaceEdit } from "./workspace-edit.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
+});
+
+describe("workspace edit adversarial inputs", () => {
+	it("#given malformed and decorated URIs #when planned #then every variant is rejected before mutation", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const source = join(workspace, "source.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+		const decorated = `${pathToFileURL(source).href}?query=forbidden`;
+
+		for (const uri of ["untitled:source.ts", decorated, "file:///%ZZ"] as const) {
+			const result = planWorkspaceEdit({ changes: { [uri]: [insertion()] } }, workspace);
+			expect(result.success).toBe(false);
+		}
+		expect(readFileSync(source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given invalid ranges and resource options #when planned #then each failure retains its operation index", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const source = join(workspace, "source.ts");
+		const created = join(workspace, "created.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+		const invalidRange = planWorkspaceEdit(
+			{
+				documentChanges: [
+					{
+						textDocument: { uri: pathToFileURL(source).href, version: null },
+						edits: [
+							{
+								range: { start: { line: 0, character: -1 }, end: { line: 0, character: 2 } },
+								newText: "bad",
+							},
+						],
+					},
+				],
+			},
+			workspace,
+		);
+		const invalidOption = planWorkspaceEdit(
+			{
+				documentChanges: [
+					{
+						textDocument: { uri: pathToFileURL(source).href, version: null },
+						edits: [],
+					},
+					{ kind: "create", uri: pathToFileURL(created).href, options: { overwrite: "yes" } },
+				],
+			},
+			workspace,
+		);
+
+		expect(invalidRange.success).toBe(false);
+		if (!invalidRange.success) expect(invalidRange.result.errors[0]).toContain("change 0");
+		expect(invalidOption.success).toBe(false);
+		if (!invalidOption.success) expect(invalidOption.result.errors[0]).toContain("change 1");
+		expect(readFileSync(source, "utf-8")).toBe("const before = 1;\n");
+	});
+
+	it("#given an outside target and a dirty unrelated file #when prevalidation fails #then neither is touched", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const outside = makeTempDirectory("lsp-outside-");
+		const dirty = join(workspace, "dirty.ts");
+		const outsideFile = join(outside, "outside.ts");
+		writeFileSync(dirty, "user-owned dirty bytes\n", "utf-8");
+		writeFileSync(outsideFile, "outside bytes\n", "utf-8");
+
+		const result = applyWorkspaceEdit(
+			{ changes: { [pathToFileURL(outsideFile).href]: [insertion()] } },
+			{ workspaceRoot: workspace },
+		);
+
+		expect(result.success).toBe(false);
+		expect(result.errors.join("\n")).toContain("outside workspace");
+		expect(readFileSync(dirty, "utf-8")).toBe("user-owned dirty bytes\n");
+		expect(readFileSync(outsideFile, "utf-8")).toBe("outside bytes\n");
+	});
+
+	it("#given an in-workspace symlink to an outside file #when applying an edit #then rejects without modifying target", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const outside = makeTempDirectory("lsp-outside-");
+		const outsideFile = join(outside, "outside.ts");
+		const canonicalWorkspace = realpathSync(workspace);
+		const linkedDirectory = join(canonicalWorkspace, "linked");
+		writeFileSync(outsideFile, "outside bytes\n", "utf-8");
+		symlinkSync(outside, linkedDirectory);
+
+		const result = applyWorkspaceEdit(
+			{ changes: { [pathToFileURL(join(linkedDirectory, "outside.ts")).href]: [insertion()] } },
+			{ workspaceRoot: canonicalWorkspace },
+		);
+
+		expect(result.success).toBe(false);
+		expect(result.errors.join("\n")).toContain("outside workspace");
+		expect(readFileSync(outsideFile, "utf-8")).toBe("outside bytes\n");
+	});
+
+	it("#given annotations or mixed edit representations #when planned #then unsupported claims are rejected", () => {
+		const workspace = makeTempDirectory("lsp-workspace-");
+		const unsupported = [
+			{ changeAnnotations: { change: { label: "unsupported" } } },
+			{ changes: {}, documentChanges: [] },
+			{ documentChanges: [{ kind: "create", uri: "file:///missing", annotationId: "change" }] },
+		];
+
+		for (const edit of unsupported) expect(planWorkspaceEdit(edit, workspace).success).toBe(false);
+	});
+});
+
+function insertion() {
+	return {
+		range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+		newText: "x",
+	};
+}
+
+function makeTempDirectory(prefix: string): string {
+	const directory = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(directory);
+	return directory;
+}