lazycodex-ai 5.1.48 → 5.1.51

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

@@ -0,0 +1,130 @@
+import { uriToCanonicalWorkspacePath } from "./workspace-edit-path.js";
+import { isRecord, parseTextEdits } from "./workspace-edit-parse-helpers.js";
+import type { ParsedWorkspaceEdit, ParsedWorkspaceOperation, ParseFailure } from "./workspace-edit-plan-types.js";
+import { parseResourceChange } from "./workspace-edit-resource-parser.js";
+import type { ApplyResult } from "./workspace-edit-types.js";
+import { WorkspaceEditValidationError } from "./workspace-edit-types.js";
+
+interface ParseTarget {
+	readonly operations: ParsedWorkspaceOperation[];
+	readonly failures: ParseFailure[];
+}
+
+interface DocumentChangeInput {
+	readonly change: unknown;
+	readonly changeIndex: number;
+	readonly workspaceRoot: string;
+	readonly target: ParseTarget;
+}
+
+export function failureResult(failures: readonly ParseFailure[]): ApplyResult {
+	const sorted = [...failures].sort((left, right) => left.changeIndex - right.changeIndex);
+	const first = sorted[0];
+	return {
+		success: false,
+		filesModified: [],
+		totalEdits: 0,
+		errors: sorted.map((failure) => `change ${failure.changeIndex}: ${failure.message}`),
+		...(first ? { failedChange: first.changeIndex } : {}),
+	};
+}
+
+export function parseWorkspaceEdit(edit: unknown, workspaceRoot: string): ParsedWorkspaceEdit {
+	if (!isRecord(edit)) return { operations: [], failures: [{ changeIndex: 0, message: "No edit provided" }] };
+	if (edit["changeAnnotations"] !== undefined) {
+		return { operations: [], failures: [{ changeIndex: 0, message: "change annotations are unsupported" }] };
+	}
+	const hasChanges = edit["changes"] !== undefined;
+	const hasDocumentChanges = edit["documentChanges"] !== undefined;
+	if (hasChanges && hasDocumentChanges) {
+		return {
+			operations: [],
+			failures: [{ changeIndex: 0, message: "changes and documentChanges cannot be combined" }],
+		};
+	}
+
+	const target: ParseTarget = { operations: [], failures: [] };
+	if (hasChanges) return parseChanges(edit["changes"], workspaceRoot, target);
+	return parseDocumentChanges(edit["documentChanges"], workspaceRoot, target);
+}
+
+function parseChanges(value: unknown, workspaceRoot: string, target: ParseTarget): ParsedWorkspaceEdit {
+	if (!isRecord(value)) return { ...target, failures: [{ changeIndex: 0, message: "changes must be an object" }] };
+	const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+	for (const [changeIndex, [uri, rawEdits]] of entries.entries()) {
+		const resolvedPath = uriToCanonicalWorkspacePath(uri, workspaceRoot);
+		if (!resolvedPath.success) {
+			target.failures.push({ changeIndex, message: resolvedPath.error });
+			continue;
+		}
+		try {
+			target.operations.push({
+				kind: "text",
+				changeIndex,
+				path: resolvedPath.path,
+				reportedPath: resolvedPath.requestedPath,
+				edits: parseTextEdits(rawEdits, changeIndex),
+				version: null,
+			});
+		} catch (error) {
+			if (error instanceof WorkspaceEditValidationError) {
+				target.failures.push({ changeIndex, message: error.detail });
+				continue;
+			}
+			throw error;
+		}
+	}
+	return target;
+}
+
+function parseDocumentChanges(value: unknown, workspaceRoot: string, target: ParseTarget): ParsedWorkspaceEdit {
+	if (value === undefined) return target;
+	if (!Array.isArray(value)) {
+		return { ...target, failures: [{ changeIndex: 0, message: "documentChanges must be an array" }] };
+	}
+	for (const [changeIndex, change] of value.entries()) {
+		try {
+			parseDocumentChange({ change, changeIndex, workspaceRoot, target });
+		} catch (error) {
+			if (error instanceof WorkspaceEditValidationError) {
+				target.failures.push({ changeIndex, message: error.detail });
+				continue;
+			}
+			throw error;
+		}
+	}
+	return target;
+}
+
+function parseDocumentChange(input: DocumentChangeInput): void {
+	const { change, changeIndex, workspaceRoot, target } = input;
+	if (!isRecord(change)) throw new WorkspaceEditValidationError(changeIndex, "document change must be an object");
+	if ("annotationId" in change) {
+		throw new WorkspaceEditValidationError(changeIndex, "annotated resource operations are unsupported");
+	}
+	if (typeof change["kind"] === "string") {
+		parseResourceChange({ change, changeIndex, workspaceRoot, target });
+		return;
+	}
+	const identifier = change["textDocument"];
+	if (!isRecord(identifier) || typeof identifier["uri"] !== "string") {
+		throw new WorkspaceEditValidationError(changeIndex, "textDocument.uri is required");
+	}
+	const version = identifier["version"];
+	if (version !== null && (!Number.isInteger(version) || typeof version !== "number" || version < 0)) {
+		throw new WorkspaceEditValidationError(changeIndex, "document version must be null or a non-negative integer");
+	}
+	const resolvedPath = uriToCanonicalWorkspacePath(identifier["uri"], workspaceRoot);
+	if (!resolvedPath.success) {
+		target.failures.push({ changeIndex, message: resolvedPath.error });
+		return;
+	}
+	target.operations.push({
+		kind: "text",
+		changeIndex,
+		path: resolvedPath.path,
+		reportedPath: resolvedPath.requestedPath,
+		edits: parseTextEdits(change["edits"], changeIndex),
+		version,
+	});
+}

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,
+	});
+}