oh-my-opencode 4.18.0 → 4.18.1

package/packages/lsp-core/src/lsp/workspace-edit-path.ts

@@ -0,0 +1,98 @@
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { WorkspaceSnapshotEntry } from "./workspace-edit-types.js";
+
+export type WorkspacePathResult =
+	| {
+			readonly success: true;
+			readonly path: string;
+			readonly requestedPath: string;
+			readonly followedSymbolicLink: boolean;
+		  }
+		| { readonly success: false; readonly error: string };
+
+class WorkspaceEditPathError extends Error {
+	override readonly name = "WorkspaceEditPathError";
+
+	constructor(
+		readonly path: string,
+		readonly detail: string,
+	) {
+		super(`${detail}: ${path}`);
+	}
+}
+
+export function isPathInsideWorkspace(filePath: string, workspaceRoot: string): boolean {
+	const relativePath = relative(workspaceRoot, filePath);
+	return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+
+function canonicalizeMissingPath(filePath: string): string {
+	let ancestor = filePath;
+	while (!existsSync(ancestor)) {
+		const parent = dirname(ancestor);
+		if (parent === ancestor) throw new WorkspaceEditPathError(filePath, "no existing ancestor");
+		ancestor = parent;
+	}
+	return resolve(realpathSync(ancestor), relative(ancestor, filePath));
+}
+
+export function canonicalWorkspaceRoot(workspaceRoot: string): WorkspacePathResult {
+	try {
+		const canonical = realpathSync(resolve(workspaceRoot));
+		if (!lstatSync(canonical).isDirectory()) {
+			return { success: false, error: `workspace root is not a directory: ${workspaceRoot}` };
+		}
+		return {
+			success: true,
+			path: canonical,
+			requestedPath: resolve(workspaceRoot),
+			followedSymbolicLink: existsSync(resolve(workspaceRoot)) && lstatSync(resolve(workspaceRoot)).isSymbolicLink(),
+		};
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		return { success: false, error: `workspace root ${workspaceRoot}: ${detail}` };
+	}
+}
+
+export function uriToCanonicalWorkspacePath(uri: string, workspaceRoot: string): WorkspacePathResult {
+	let requestedPath: string;
+	try {
+		const parsed = new URL(uri);
+		if (parsed.protocol !== "file:" || parsed.search !== "" || parsed.hash !== "") {
+			return { success: false, error: `non-file URI ${uri}` };
+		}
+		requestedPath = resolve(fileURLToPath(parsed));
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		return { success: false, error: `non-file URI ${uri}: ${detail}` };
+	}
+
+	try {
+		const canonical = existsSync(requestedPath) ? realpathSync(requestedPath) : canonicalizeMissingPath(requestedPath);
+		if (!isPathInsideWorkspace(canonical, workspaceRoot)) {
+			return { success: false, error: `${requestedPath}: outside workspace ${workspaceRoot}` };
+		}
+		return {
+			success: true,
+			path: canonical,
+			requestedPath,
+			followedSymbolicLink: existsSync(requestedPath) && lstatSync(requestedPath).isSymbolicLink(),
+		};
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		return { success: false, error: `${requestedPath}: ${detail}` };
+	}
+}
+
+export function snapshotPath(path: string, includeChildren: boolean): WorkspaceSnapshotEntry {
+	if (!existsSync(path)) return { kind: "missing" };
+	const stats = lstatSync(path);
+	if (stats.isFile()) return { kind: "file", content: readFileSync(path, "utf-8") };
+	if (stats.isDirectory()) {
+		return includeChildren ? { kind: "directory", children: readdirSync(path).sort() } : { kind: "directory" };
+	}
+	throw new WorkspaceEditPathError(path, "unsupported filesystem entry");
+}

package/packages/lsp-core/src/lsp/workspace-edit-plan-types.ts

@@ -0,0 +1,60 @@
+import type { TextEdit } from "./types.js";
+import type { ApplyResult, PlannedWorkspaceOperation } from "./workspace-edit-types.js";
+
+export type ParsedWorkspaceOperation =
+	| {
+			readonly kind: "text";
+			readonly changeIndex: number;
+			readonly path: string;
+			readonly reportedPath: string;
+			readonly edits: readonly TextEdit[];
+			readonly version: number | null;
+	  }
+	| {
+			readonly kind: "create";
+			readonly changeIndex: number;
+			readonly path: string;
+			readonly reportedPath: string;
+			readonly overwrite: boolean;
+			readonly ignoreIfExists: boolean;
+			readonly followedSymbolicLink: boolean;
+	  }
+	| {
+			readonly kind: "rename";
+			readonly changeIndex: number;
+			readonly oldPath: string;
+			readonly newPath: string;
+			readonly reportedOldPath: string;
+			readonly reportedNewPath: string;
+			readonly overwrite: boolean;
+			readonly ignoreIfExists: boolean;
+			readonly followedSymbolicLink: boolean;
+	  }
+	| {
+			readonly kind: "delete";
+			readonly changeIndex: number;
+			readonly path: string;
+			readonly reportedPath: string;
+			readonly recursive: boolean;
+			readonly ignoreIfNotExists: boolean;
+			readonly followedSymbolicLink: boolean;
+	  };
+
+export interface ParseFailure {
+	readonly changeIndex: number;
+	readonly message: string;
+}
+
+export interface ParsedWorkspaceEdit {
+	readonly operations: readonly ParsedWorkspaceOperation[];
+	readonly failures: readonly ParseFailure[];
+}
+
+export interface SimulatedWorkspaceEdit {
+	readonly operations: readonly PlannedWorkspaceOperation[];
+	readonly failures: readonly ParseFailure[];
+}
+
+export type WorkspaceEditFingerprintResult =
+	| { readonly success: true; readonly fingerprint: string }
+	| { readonly success: false; readonly result: ApplyResult };

package/packages/lsp-core/src/lsp/workspace-edit-plan.ts

@@ -0,0 +1,73 @@
+import { canonicalFingerprint } from "./workspace-edit-fingerprint.js";
+import { canonicalWorkspaceRoot } from "./workspace-edit-path.js";
+import { failureResult, parseWorkspaceEdit } from "./workspace-edit-parser.js";
+import type { ParsedWorkspaceOperation, WorkspaceEditFingerprintResult } from "./workspace-edit-plan-types.js";
+import { simulateOperations } from "./workspace-edit-simulation.js";
+import { snapshotOperations } from "./workspace-edit-snapshot.js";
+import type { WorkspaceEditPlan, WorkspaceEditPlanResult } from "./workspace-edit-types.js";
+
+export type { WorkspaceEditFingerprintResult } from "./workspace-edit-plan-types.js";
+
+class PlanPathIndex {
+	readonly firstChangeByPath = new Map<string, number>();
+	readonly reportedPathByCanonical = new Map<string, string>();
+
+	build(operations: readonly ParsedWorkspaceOperation[]): void {
+		for (const operation of operations) {
+			switch (operation.kind) {
+				case "rename":
+					this.add(operation.oldPath, operation.reportedOldPath, operation.changeIndex);
+					this.add(operation.newPath, operation.reportedNewPath, operation.changeIndex);
+					break;
+				case "text":
+				case "create":
+				case "delete":
+					this.add(operation.path, operation.reportedPath, operation.changeIndex);
+					break;
+			}
+		}
+	}
+
+	private add(path: string, reportedPath: string, changeIndex: number): void {
+		if (!this.firstChangeByPath.has(path)) this.firstChangeByPath.set(path, changeIndex);
+		if (!this.reportedPathByCanonical.has(path)) this.reportedPathByCanonical.set(path, reportedPath);
+	}
+}
+
+export function fingerprintWorkspaceEdit(edit: unknown, workspaceRoot: string): WorkspaceEditFingerprintResult {
+	const root = canonicalWorkspaceRoot(workspaceRoot);
+	if (!root.success) return { success: false, result: failureResult([{ changeIndex: 0, message: root.error }]) };
+	const parsed = parseWorkspaceEdit(edit, root.path);
+	if (parsed.failures.length > 0) return { success: false, result: failureResult(parsed.failures) };
+	return { success: true, fingerprint: canonicalFingerprint(parsed.operations) };
+}
+
+export function planWorkspaceEdit(edit: unknown, workspaceRoot: string): WorkspaceEditPlanResult {
+	const root = canonicalWorkspaceRoot(workspaceRoot);
+	if (!root.success) return { success: false, result: failureResult([{ changeIndex: 0, message: root.error }]) };
+	const parsed = parseWorkspaceEdit(edit, root.path);
+	if (parsed.failures.length > 0) return { success: false, result: failureResult(parsed.failures) };
+
+	let snapshots;
+	try {
+		snapshots = snapshotOperations(parsed.operations, root.path);
+	} catch (error) {
+		return {
+			success: false,
+			result: failureResult([{ changeIndex: 0, message: error instanceof Error ? error.message : String(error) }]),
+		};
+	}
+	const simulated = simulateOperations(parsed.operations, snapshots);
+	if (simulated.failures.length > 0) return { success: false, result: failureResult(simulated.failures) };
+	const paths = new PlanPathIndex();
+	paths.build(parsed.operations);
+	const plan: WorkspaceEditPlan = {
+		workspaceRoot: root.path,
+		operations: simulated.operations,
+		snapshots,
+		firstChangeByPath: paths.firstChangeByPath,
+		reportedPathByCanonical: paths.reportedPathByCanonical,
+		fingerprint: canonicalFingerprint(parsed.operations),
+	};
+	return { success: true, plan };
+}

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

@@ -0,0 +1,174 @@
+import { existsSync, mkdtempSync, readFileSync, 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 { applyWorkspaceEdit } from "./workspace-edit.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("applyWorkspaceEdit prevalidation", () => {
+	it("#given a valid edit before an overlapping edit #when validated #then neither file is mutated", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const validFile = join(workspace, "valid.ts");
+		const invalidFile = join(workspace, "invalid.ts");
+		writeFileSync(validFile, "const valid = 1;\n", "utf-8");
+		writeFileSync(invalidFile, "const invalid = 2;\n", "utf-8");
+
+		// when
+		const result = applyWorkspaceEdit(
+			{
+				changes: {
+					[pathToFileURL(validFile).href]: [edit(0, [6, 11], "changed")],
+					[pathToFileURL(invalidFile).href]: [edit(0, [0, 10], "first"), edit(0, [5, 13], "second")],
+				},
+			},
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result.success).toBe(false);
+		expect(result.filesModified).toEqual([]);
+		expect(readFileSync(validFile, "utf-8")).toBe("const valid = 1;\n");
+		expect(readFileSync(invalidFile, "utf-8")).toBe("const invalid = 2;\n");
+	});
+
+	it("#given byte-identical non-empty edits #when applied #then one edit is committed", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "source.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+		const replacement = edit(0, [6, 12], "after");
+
+		// when
+		const result = applyWorkspaceEdit(
+			{ changes: { [pathToFileURL(source).href]: [replacement, replacement] } },
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result.success).toBe(true);
+		expect(result.totalEdits).toBe(1);
+		expect(readFileSync(source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given equal-position insertions #when applied #then all insertions retain declared order", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "source.ts");
+		writeFileSync(source, "abc", "utf-8");
+
+		// when
+		const result = applyWorkspaceEdit(
+			{
+				changes: {
+					[pathToFileURL(source).href]: [edit(0, [1, 1], "X"), edit(0, [1, 1], "X"), edit(0, [1, 1], "Y")],
+				},
+			},
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result.success).toBe(true);
+		expect(result.totalEdits).toBe(3);
+		expect(readFileSync(source, "utf-8")).toBe("aXXYbc");
+	});
+
+	it("#given a range beyond the snapshot #when validated #then the edit fails without mutation", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "source.ts");
+		writeFileSync(source, "short\n", "utf-8");
+
+		// when
+		const result = applyWorkspaceEdit(
+			{ changes: { [pathToFileURL(source).href]: [edit(4, [0, 1], "invalid")] } },
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result.success).toBe(false);
+		expect(result.filesModified).toEqual([]);
+		expect(readFileSync(source, "utf-8")).toBe("short\n");
+	});
+
+	it("#given a create followed by an invalid edit #when the sequence is validated #then no file is created", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "created.ts");
+		const uri = pathToFileURL(source).href;
+
+		// when
+		const result = applyWorkspaceEdit(
+			{
+				documentChanges: [
+					{ kind: "create", uri },
+					{ textDocument: { uri, version: null }, edits: [edit(2, [0, 1], "invalid")] },
+				],
+			},
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result.success).toBe(false);
+		expect(result.filesModified).toEqual([]);
+		expect(result).toMatchObject({ failedChange: 1 });
+		expect(result.errors.join("\n")).toContain("change 1");
+		expect(existsSync(source)).toBe(false);
+	});
+
+	it("#given rename then text edit of the destination #when applied #then declared order uses virtual state", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "before.ts");
+		const destination = join(workspace, "after.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+		const sourceUri = pathToFileURL(source).href;
+		const destinationUri = pathToFileURL(destination).href;
+
+		// when
+		const result = applyWorkspaceEdit(
+			{
+				documentChanges: [
+					{ kind: "rename", oldUri: sourceUri, newUri: destinationUri },
+					{
+						textDocument: { uri: destinationUri, version: null },
+						edits: [edit(0, [6, 12], "after")],
+					},
+				],
+			},
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result.success).toBe(true);
+		expect(existsSync(source)).toBe(false);
+		expect(readFileSync(destination, "utf-8")).toBe("const after = 1;\n");
+	});
+});
+
+function edit(line: number, characters: readonly [start: number, end: number], newText: string) {
+	const [startCharacter, endCharacter] = characters;
+	return {
+		range: {
+			start: { line, character: startCharacter },
+			end: { line, character: endCharacter },
+		},
+		newText,
+	};
+}
+
+function makeTempDirectory(): string {
+	const directory = mkdtempSync(join(tmpdir(), "lsp-workspace-prevalidation-"));
+	tempDirectories.push(directory);
+	return directory;
+}

package/packages/lsp-core/src/lsp/workspace-edit-resource-parser.ts

@@ -0,0 +1,89 @@
+import { uriToCanonicalWorkspacePath } from "./workspace-edit-path.js";
+import { parseOptions } from "./workspace-edit-parse-helpers.js";
+import type { ParsedWorkspaceOperation, ParseFailure } from "./workspace-edit-plan-types.js";
+import { WorkspaceEditValidationError } from "./workspace-edit-types.js";
+
+interface ResourceParseTarget {
+	readonly operations: ParsedWorkspaceOperation[];
+	readonly failures: ParseFailure[];
+}
+
+export interface ResourceChangeInput {
+	readonly change: Record<string, unknown>;
+	readonly changeIndex: number;
+	readonly workspaceRoot: string;
+	readonly target: ResourceParseTarget;
+}
+
+export function parseResourceChange(input: ResourceChangeInput): void {
+	const kind = input.change["kind"];
+	if (kind === "create" || kind === "delete") {
+		parseSinglePathResource(input, kind);
+		return;
+	}
+	if (kind !== "rename") {
+		throw new WorkspaceEditValidationError(input.changeIndex, `unsupported resource operation ${String(kind)}`);
+	}
+	parseRename(input);
+}
+
+function parseSinglePathResource(input: ResourceChangeInput, kind: "create" | "delete"): void {
+	const { change, changeIndex, workspaceRoot, target } = input;
+	if (typeof change["uri"] !== "string") throw new WorkspaceEditValidationError(changeIndex, `${kind}.uri is required`);
+	const resolvedPath = uriToCanonicalWorkspacePath(change["uri"], workspaceRoot);
+	if (!resolvedPath.success) {
+		target.failures.push({ changeIndex, message: resolvedPath.error });
+		return;
+	}
+	if (kind === "create") {
+		const options = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
+		target.operations.push({
+			kind,
+			changeIndex,
+			path: resolvedPath.path,
+			reportedPath: resolvedPath.requestedPath,
+			overwrite: options["overwrite"] ?? false,
+			ignoreIfExists: options["ignoreIfExists"] ?? false,
+			followedSymbolicLink: resolvedPath.followedSymbolicLink,
+		});
+		return;
+	}
+	const options = parseOptions(change["options"], ["recursive", "ignoreIfNotExists"], changeIndex);
+	target.operations.push({
+		kind,
+		changeIndex,
+		path: resolvedPath.path,
+		reportedPath: resolvedPath.requestedPath,
+		recursive: options["recursive"] ?? false,
+		ignoreIfNotExists: options["ignoreIfNotExists"] ?? false,
+		followedSymbolicLink: resolvedPath.followedSymbolicLink,
+	});
+}
+
+function parseRename(input: ResourceChangeInput): void {
+	const { change, changeIndex, workspaceRoot, target } = input;
+	if (typeof change["oldUri"] !== "string" || typeof change["newUri"] !== "string") {
+		throw new WorkspaceEditValidationError(changeIndex, "rename requires oldUri and newUri");
+	}
+	const oldPath = uriToCanonicalWorkspacePath(change["oldUri"], workspaceRoot);
+	const newPath = uriToCanonicalWorkspacePath(change["newUri"], workspaceRoot);
+	if (!oldPath.success || !newPath.success) {
+		target.failures.push({
+			changeIndex,
+			message: !oldPath.success ? oldPath.error : !newPath.success ? newPath.error : "invalid rename path",
+		});
+		return;
+	}
+	const options = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
+	target.operations.push({
+		kind: "rename",
+		changeIndex,
+		oldPath: oldPath.path,
+		newPath: newPath.path,
+		reportedOldPath: oldPath.requestedPath,
+		reportedNewPath: newPath.requestedPath,
+		overwrite: options["overwrite"] ?? false,
+		ignoreIfExists: options["ignoreIfExists"] ?? false,
+		followedSymbolicLink: oldPath.followedSymbolicLink || newPath.followedSymbolicLink,
+	});
+}

package/packages/lsp-core/src/lsp/workspace-edit-simulation.ts

@@ -0,0 +1,183 @@
+import { dirname, relative, resolve } from "node:path";
+
+import { normalizeTextEdits } from "./workspace-edit-text.js";
+import type {
+	ParsedWorkspaceOperation,
+	ParseFailure,
+	SimulatedWorkspaceEdit,
+} from "./workspace-edit-plan-types.js";
+import type { PlannedWorkspaceOperation, WorkspaceSnapshotEntry } from "./workspace-edit-types.js";
+import { WorkspaceEditValidationError } from "./workspace-edit-types.js";
+
+function isSameOrDescendant(candidate: string, parent: string): boolean {
+	const relativePath = relative(parent, candidate);
+	return relativePath === "" || (!relativePath.startsWith("..") && relativePath !== "..");
+}
+
+function removeVirtualSubtree(virtual: Map<string, WorkspaceSnapshotEntry>, path: string): void {
+	for (const candidate of [...virtual.keys()]) {
+		if (isSameOrDescendant(candidate, path)) virtual.delete(candidate);
+	}
+	virtual.set(path, { kind: "missing" });
+}
+
+function moveVirtualSubtree(virtual: Map<string, WorkspaceSnapshotEntry>, oldPath: string, newPath: string): void {
+	const moved = [...virtual.entries()].filter(([candidate]) => isSameOrDescendant(candidate, oldPath));
+	removeVirtualSubtree(virtual, oldPath);
+	removeVirtualSubtree(virtual, newPath);
+	for (const [candidate, entry] of moved) {
+		const suffix = relative(oldPath, candidate);
+		virtual.set(suffix === "" ? newPath : resolve(newPath, suffix), entry);
+	}
+}
+
+function virtualDirectoryHasChildren(virtual: ReadonlyMap<string, WorkspaceSnapshotEntry>, path: string): boolean {
+	for (const [candidate, entry] of virtual) {
+		if (candidate !== path && entry.kind !== "missing" && isSameOrDescendant(candidate, path)) return true;
+	}
+	return false;
+}
+
+function requireVirtualParent(
+	virtual: ReadonlyMap<string, WorkspaceSnapshotEntry>,
+	path: string,
+	changeIndex: number,
+): void {
+	if (virtual.get(dirname(path))?.kind !== "directory") {
+		throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path}`);
+	}
+}
+
+export function simulateOperations(
+	parsed: readonly ParsedWorkspaceOperation[],
+	snapshots: ReadonlyMap<string, WorkspaceSnapshotEntry>,
+): SimulatedWorkspaceEdit {
+	const virtual = new Map(snapshots);
+	const planned: PlannedWorkspaceOperation[] = [];
+	const failures: ParseFailure[] = [];
+	for (const operation of parsed) {
+		try {
+			planned.push(simulateOperation(operation, virtual));
+		} catch (error) {
+			if (error instanceof WorkspaceEditValidationError) {
+				failures.push({ changeIndex: operation.changeIndex, message: error.detail });
+				continue;
+			}
+			throw error;
+		}
+	}
+	return { operations: planned, failures };
+}
+
+function simulateOperation(
+	operation: ParsedWorkspaceOperation,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	switch (operation.kind) {
+		case "text":
+			return simulateText(operation, virtual);
+		case "create":
+			return simulateCreate(operation, virtual);
+		case "rename":
+			return simulateRename(operation, virtual);
+		case "delete":
+			return simulateDelete(operation, virtual);
+	}
+}
+
+function rejectSymbolicLink(operation: Exclude<ParsedWorkspaceOperation, { readonly kind: "text" }>): void {
+	if (operation.followedSymbolicLink) {
+		throw new WorkspaceEditValidationError(operation.changeIndex, "resource operations through symbolic links are unsupported");
+	}
+}
+
+function simulateText(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "text" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	const entry = virtual.get(operation.path);
+	if (entry?.kind !== "file") throw new WorkspaceEditValidationError(operation.changeIndex, `${operation.path} is not a file`);
+	const normalized = normalizeTextEdits(entry.content, operation.edits, operation.changeIndex);
+	virtual.set(operation.path, { kind: "file", content: normalized.text });
+	return {
+		kind: "text",
+		changeIndex: operation.changeIndex,
+		path: operation.path,
+		beforeText: entry.content,
+		afterText: normalized.text,
+		editCount: normalized.edits.length,
+		documentVersion: operation.version,
+	};
+}
+
+function simulateCreate(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "create" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	rejectSymbolicLink(operation);
+	requireVirtualParent(virtual, operation.path, operation.changeIndex);
+	const target = virtual.get(operation.path) ?? { kind: "missing" };
+	if (target.kind !== "missing") {
+		if (operation.overwrite && target.kind === "file") {
+			virtual.set(operation.path, { kind: "file", content: "" });
+			return { kind: "create", changeIndex: operation.changeIndex, path: operation.path, replaced: true };
+		}
+		if (operation.ignoreIfExists) return { kind: "noop", changeIndex: operation.changeIndex };
+		throw new WorkspaceEditValidationError(operation.changeIndex, `create target already exists: ${operation.path}`);
+	}
+	virtual.set(operation.path, { kind: "file", content: "" });
+	return { kind: "create", changeIndex: operation.changeIndex, path: operation.path, replaced: false };
+}
+
+function simulateRename(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "rename" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	rejectSymbolicLink(operation);
+	const source = virtual.get(operation.oldPath) ?? { kind: "missing" };
+	if (source.kind === "missing") {
+		throw new WorkspaceEditValidationError(operation.changeIndex, `rename source does not exist: ${operation.oldPath}`);
+	}
+	if (operation.oldPath === operation.newPath) return { kind: "noop", changeIndex: operation.changeIndex };
+	if (isSameOrDescendant(operation.newPath, operation.oldPath)) {
+		throw new WorkspaceEditValidationError(operation.changeIndex, "cannot rename a path into its own subtree");
+	}
+	requireVirtualParent(virtual, operation.newPath, operation.changeIndex);
+	const destination = virtual.get(operation.newPath) ?? { kind: "missing" };
+	if (destination.kind !== "missing" && !operation.overwrite) {
+		if (operation.ignoreIfExists) return { kind: "noop", changeIndex: operation.changeIndex };
+		throw new WorkspaceEditValidationError(operation.changeIndex, `rename target already exists: ${operation.newPath}`);
+	}
+	moveVirtualSubtree(virtual, operation.oldPath, operation.newPath);
+	return {
+		kind: "rename",
+		changeIndex: operation.changeIndex,
+		oldPath: operation.oldPath,
+		newPath: operation.newPath,
+		sourceKind: source.kind,
+		replaceDestination: destination.kind !== "missing",
+	};
+}
+
+function simulateDelete(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "delete" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	rejectSymbolicLink(operation);
+	const target = virtual.get(operation.path) ?? { kind: "missing" };
+	if (target.kind === "missing") {
+		if (operation.ignoreIfNotExists) return { kind: "noop", changeIndex: operation.changeIndex };
+		throw new WorkspaceEditValidationError(operation.changeIndex, `delete target does not exist: ${operation.path}`);
+	}
+	if (target.kind === "directory" && !operation.recursive && virtualDirectoryHasChildren(virtual, operation.path)) {
+		throw new WorkspaceEditValidationError(operation.changeIndex, `directory is not empty: ${operation.path}`);
+	}
+	removeVirtualSubtree(virtual, operation.path);
+	return {
+		kind: "delete",
+		changeIndex: operation.changeIndex,
+		path: operation.path,
+		targetKind: target.kind,
+		recursive: operation.recursive,
+	};
+}