@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/lsp/edits.js

@@ -1,108 +1,378 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { uriToPath } from "./path-utils.js";
+import { URL } from "node:url";
+import { isUnderDir, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, uriToDiskPath, uriToPath, } from "./path-utils.js";
+import { convertCharacterOffset, lineTextAt, } from "./position-encoding.js";
+import { recordLspMutation, } from "../lsp-mutation.js";
+import { detectLineEnding, normalizeToLF, restoreLineEndings, } from "../host-edit-normalize.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function isPosition(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        typeof value.line === "number" &&
-        typeof value.character === "number");
+    return (isRecord(value) &&
+        Number.isFinite(value.line) &&
+        Number.isInteger(value.line) &&
+        value.line >= 0 &&
+        Number.isFinite(value.character) &&
+        Number.isInteger(value.character) &&
+        value.character >= 0);
+}
+function comparePosition(a, b) {
+    return a.line === b.line ? a.character - b.character : a.line - b.line;
 }
 function isRange(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        isPosition(value.start) &&
-        isPosition(value.end));
+    if (!isRecord(value) || !isPosition(value.start) || !isPosition(value.end)) {
+        return false;
+    }
+    return comparePosition(value.start, value.end) <= 0;
 }
 function isTextEdit(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        isRange(value.range) &&
-        typeof value.newText === "string");
-}
-function isTextDocumentEdit(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        typeof value.textDocument?.uri ===
-            "string" &&
-        Array.isArray(value.edits));
+    return isRecord(value) && isRange(value.range) && typeof value.newText === "string";
 }
-function comparePosition(a, b) {
-    return a.line === b.line ? a.character - b.character : a.line - b.line;
+function parseTextEdits(value, context) {
+    if (!Array.isArray(value))
+        throw new Error(`${context}.edits must be an array`);
+    if (!value.every(isTextEdit))
+        throw new Error(`malformed text edit in ${context}`);
+    return value;
+}
+function parseVersion(value, context) {
+    if (value === undefined || value === null)
+        return value;
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${context}.version must be a nonnegative integer or null`);
+    }
+    return value;
+}
+function parseResourceOptions(value, kind) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value))
+        throw new Error(`${kind}.options must be an object`);
+    const allowed = new Set(kind === "delete"
+        ? ["ignoreIfNotExists", "recursive"]
+        : ["overwrite", "ignoreIfExists"]);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key) || typeof value[key] !== "boolean") {
+            throw new Error(`invalid ${kind}.options.${key}`);
+        }
+    }
+    if (value.overwrite === true && value.ignoreIfExists === true) {
+        throw new Error(`${kind} cannot set both overwrite and ignoreIfExists`);
+    }
+    if (kind !== "delete" && value.ignoreIfNotExists !== undefined) {
+        throw new Error(`${kind} does not support ignoreIfNotExists`);
+    }
+    if (kind === "delete" && value.overwrite !== undefined) {
+        throw new Error(`delete does not support overwrite`);
+    }
+    return value;
+}
+function parseTextDocumentEdit(value, context) {
+    if (!isRecord(value) || !isRecord(value.textDocument))
+        return null;
+    if (typeof value.textDocument.uri !== "string") {
+        throw new Error(`${context}.textDocument.uri must be a string`);
+    }
+    const version = parseVersion(value.textDocument.version, `${context}.textDocument`);
+    return {
+        textDocument: { uri: value.textDocument.uri, version },
+        edits: parseTextEdits(value.edits, context),
+    };
+}
+function parseWorkspaceEdit(edit) {
+    if (!isRecord(edit))
+        throw new Error("workspace edit must be an object");
+    if (edit.changes !== undefined) {
+        if (!isRecord(edit.changes))
+            throw new Error("workspace edit changes must be an object");
+        for (const [uri, edits] of Object.entries(edit.changes)) {
+            if (typeof uri !== "string")
+                throw new Error("workspace edit URI must be a string");
+            parseTextEdits(edits, `changes[${uri}]`);
+        }
+    }
+    if (edit.documentChanges !== undefined && !Array.isArray(edit.documentChanges)) {
+        throw new Error("workspace edit documentChanges must be an array");
+    }
+    for (const [index, change] of (edit.documentChanges ?? []).entries()) {
+        const text = parseTextDocumentEdit(change, `documentChanges[${index}]`);
+        if (text)
+            continue;
+        if (!isRecord(change) || typeof change.kind !== "string") {
+            throw new Error(`malformed documentChanges[${index}]`);
+        }
+        switch (change.kind) {
+            case "create":
+                if (typeof change.uri !== "string")
+                    throw new Error("create.uri must be a string");
+                parseResourceOptions(change.options, "create");
+                break;
+            case "rename":
+                if (typeof change.oldUri !== "string" || typeof change.newUri !== "string") {
+                    throw new Error("rename requires oldUri and newUri strings");
+                }
+                parseResourceOptions(change.options, "rename");
+                break;
+            case "delete":
+                if (typeof change.uri !== "string")
+                    throw new Error("delete.uri must be a string");
+                parseResourceOptions(change.options, "delete");
+                break;
+            default:
+                throw new Error(`unsupported workspace resource operation: ${change.kind}`);
+        }
+    }
 }
 function formatRange(range) {
     return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
 }
 export function rangesOverlap(a, b) {
-    return (comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0);
-}
-export function applyTextEditsToString(content, edits) {
-    const sortedEdits = [...edits].sort((a, b) => {
-        const lineDelta = b.range.start.line - a.range.start.line;
-        return lineDelta !== 0
-            ? lineDelta
-            : b.range.start.character - a.range.start.character;
-    });
-    for (let index = 0; index < sortedEdits.length - 1; index++) {
-        const later = sortedEdits[index]?.range;
-        const earlier = sortedEdits[index + 1]?.range;
+    return comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0;
+}
+function positionsEqual(a, b) {
+    return a.line === b.line && a.character === b.character;
+}
+function isEmptyRange(range) {
+    return positionsEqual(range.start, range.end);
+}
+/**
+ * Order edits for reverse-application to a string: latest position first, so an
+ * earlier splice never shifts a not-yet-applied edit's offsets. Ties break to
+ * match LSP insertion semantics:
+ *   - same start, larger END first → a replace anchored at position P applies
+ *     before a zero-width insert at P, so the insert lands at the (post-replace)
+ *     boundary instead of being clobbered — and the result no longer depends on
+ *     listing order (P3-1, insert-at-replace-boundary);
+ *   - same start AND end (e.g. several zero-width inserts at one point) → later
+ *     ARRAY index first, so applying in this reverse order reproduces the edits'
+ *     original array order (the #1066 same-position-insert invariant).
+ *
+ * This ordering is NOT idempotent for the same-range tie (re-sorting flips the
+ * array index), so it MUST be applied exactly once, at the string-write site,
+ * over array-order input. `normalizeTextEditsForContent` deliberately returns
+ * edits in array order (never pre-sorted) so this single sort is the only pass.
+ */
+function sortEditsForApplication(edits) {
+    return edits
+        .map((edit, index) => ({ edit, index }))
+        .sort((a, b) => {
+        const startDelta = comparePosition(b.edit.range.start, a.edit.range.start);
+        if (startDelta !== 0)
+            return startDelta;
+        const endDelta = comparePosition(b.edit.range.end, a.edit.range.end);
+        if (endDelta !== 0)
+            return endDelta;
+        return b.index - a.index;
+    })
+        .map(({ edit }) => edit);
+}
+/**
+ * Deduplicate exact non-empty duplicate edits and reject genuinely overlapping
+ * ranges, returning the survivors in their ORIGINAL ARRAY ORDER. Zero-width
+ * inserts are never deduplicated (their multiplicity is meaningful). Overlap is
+ * checked on a position-sorted copy so the check is order-independent, but the
+ * returned order is preserved for the single downstream application sort.
+ */
+function validateTextEdits(edits) {
+    const unique = [];
+    const seen = new Set();
+    for (const edit of edits) {
+        if (!isEmptyRange(edit.range)) {
+            const key = textEditKey("", edit);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+        }
+        unique.push(edit);
+    }
+    const ordered = sortEditsForApplication(unique);
+    for (let index = 0; index < ordered.length - 1; index++) {
+        const later = ordered[index]?.range;
+        const earlier = ordered[index + 1]?.range;
         if (later && earlier && comparePosition(earlier.end, later.start) > 0) {
             throw new Error(`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}`);
         }
     }
+    return unique;
+}
+function utf16Position(content, position, encoding) {
+    const line = lineTextAt(content, position.line);
+    const wireLength = convertCharacterOffset(encoding, line, line.length);
+    // `lineTextAt` splits on `\n` only and keeps a trailing `\r`, so the "real"
+    // (spec) end of line content is BEFORE that `\r`, not after it. Clamp to
+    // that boundary rather than `line.length`/`wireLength`, which include the
+    // `\r`. `\r` is exactly one code unit in every encoding, so the clamped
+    // wire length is always `wireLength - 1` when a `\r` is present.
+    const hasTrailingCR = line.endsWith("\r");
+    const clampedLength = hasTrailingCR ? line.length - 1 : line.length;
+    const clampedWireLength = hasTrailingCR ? wireLength - 1 : wireLength;
+    if (position.character > clampedWireLength) {
+        // LSP 3.17: a character past the end of the line defaults to the line
+        // length. Clamp to the UTF-16 line length rather than throwing (whole-line
+        // and whole-document sentinel ranges rely on this) — landing the position
+        // at the CRLF boundary, not between `\r` and `\n`. Otherwise the whole-line
+        // sentinel replace `(0,0)-(0,999)` would eat the `\r` and a char-past-EOL
+        // insert would land mid-CRLF (P2-1 corruption on Windows repos).
+        //
+        // This also covers a caller-supplied position that is NOT past the line's
+        // full (with-`\r`) length but still lands strictly between `\r` and `\n`
+        // (i.e. `position.character === wireLength` when a `\r` is present): that
+        // position is `> clampedWireLength` too, since `clampedWireLength ===
+        // wireLength - 1`, so it clamps to the same CRLF-safe boundary instead of
+        // slipping through as an "in-bounds" position (#1147 P3-5, general class
+        // beyond #1120's strict past-EOL clamp).
+        return { line: position.line, character: clampedLength };
+    }
+    if (encoding === "utf-16")
+        return position;
+    // Find the UTF-16 offset whose encoded prefix has exactly this length. This
+    // rejects offsets in the middle of a UTF-8 sequence or UTF-16 surrogate pair.
+    for (let offset = 0; offset <= line.length; offset++) {
+        // A UTF-32 position cannot split a UTF-16 surrogate pair.
+        if (encoding === "utf-32" && offset > 0 && offset < line.length) {
+            const previous = line.charCodeAt(offset - 1);
+            const current = line.charCodeAt(offset);
+            if (previous >= 0xd800 && previous <= 0xdbff && current >= 0xdc00 && current <= 0xdfff)
+                continue;
+        }
+        if (convertCharacterOffset(encoding, line, offset) === position.character) {
+            return { line: position.line, character: offset };
+        }
+    }
+    throw new Error(`text edit character ${position.character} is not a ${encoding} boundary`);
+}
+function normalizeTextEditsForContent(content, edits, encoding) {
     const lines = content.split("\n");
-    for (const edit of sortedEdits) {
+    const lastLine = Math.max(0, lines.length - 1);
+    // The target file's dominant EOL style, detected the same way the host edit
+    // tool does (first-occurrence-wins). Every `newText` is normalized to this
+    // style below so a server-supplied bare `\n` can never be spliced verbatim
+    // into a CRLF file and produce mixed line endings — the LSP workspace-edit
+    // apply path now shares the exact contract the host-edit path already
+    // enforces via `host-edit-normalize.ts` (#1147 P3-5, general class). A no-op
+    // for LF files: `restoreLineEndings` is the identity when `ending === "\n"`.
+    const ending = detectLineEnding(content);
+    const clamp = (position) => {
+        // LSP 3.17: a line past the end of the document defaults to the end of the
+        // document (last line, its length). Clamp rather than throw so a large
+        // sentinel end position — e.g. the (0,0)-(9999,0) whole-document replace
+        // idiom — resolves to a real range instead of failing.
+        if (position.line >= lines.length) {
+            return { line: lastLine, character: (lines[lastLine] ?? "").length };
+        }
+        return utf16Position(content, position, encoding);
+    };
+    const converted = edits.map((edit) => {
+        const start = clamp(edit.range.start);
+        const end = clamp(edit.range.end);
+        if (comparePosition(start, end) > 0)
+            throw new Error("text edit range is out of order");
+        return {
+            ...edit,
+            range: { start, end },
+            newText: restoreLineEndings(normalizeToLF(edit.newText), ending),
+        };
+    });
+    // Return array order (validated, deduped); the single application-ordering
+    // sort happens once at the string-write site in applyTextEditsToString.
+    return validateTextEdits(converted);
+}
+export function applyTextEditsToString(content, edits, positionEncoding = "utf-16") {
+    const lines = content.split("\n");
+    // normalizeTextEditsForContent returns array order; sort for reverse
+    // application exactly once, here, at the single string-write site.
+    const normalized = sortEditsForApplication(normalizeTextEditsForContent(content, edits, positionEncoding));
+    for (const edit of normalized) {
         const { start, end } = edit.range;
         if (start.line === end.line) {
             const line = lines[start.line] ?? "";
-            lines[start.line] =
-                line.slice(0, start.character) +
-                    edit.newText +
-                    line.slice(end.character);
+            lines[start.line] = line.slice(0, start.character) + edit.newText + line.slice(end.character);
             continue;
         }
         const startLine = lines[start.line] ?? "";
         const endLine = lines[end.line] ?? "";
-        const replacement = startLine.slice(0, start.character) +
-            edit.newText +
-            endLine.slice(end.character);
+        const replacement = startLine.slice(0, start.character) + edit.newText + endLine.slice(end.character);
         lines.splice(start.line, end.line - start.line + 1, ...replacement.split("\n"));
     }
     return lines.join("\n");
 }
+export async function normalizeWorkspaceEditToUtf16(edit, positionEncoding, cwd) {
+    parseWorkspaceEdit(edit);
+    if (positionEncoding === "utf-16")
+        return edit;
+    // Use the same ordered planner and virtual resource/content model as the
+    // eventual apply. This is important for edits such as rename(oldDir, newDir)
+    // followed by a text edit at newDir/file.ts: the destination is not on disk
+    // yet, but its content is available through the virtual move.
+    const planned = planWorkspaceEdit(edit, true);
+    const prepared = await preflightWorkspaceEdit(planned, cwd, { positionEncoding });
+    const normalizedByOrigin = new Map();
+    for (const op of planned) {
+        if (op.kind !== "text")
+            continue;
+        for (const origin of op.origins ?? []) {
+            normalizedByOrigin.set(textEditOriginKey(origin), prepared.textByOrigin.get(textEditOriginKey(origin)) ?? []);
+        }
+    }
+    const changes = {};
+    for (const uri of Object.keys(edit.changes ?? {})) {
+        changes[uri] = normalizedByOrigin.get(textEditOriginKey({ kind: "changes", uri, edits: [] })) ?? [];
+    }
+    const documentChanges = [];
+    for (const [index, change] of (edit.documentChanges ?? []).entries()) {
+        const text = parseTextDocumentEdit(change, `documentChanges[${index}]`);
+        if (!text) {
+            documentChanges.push(change);
+            continue;
+        }
+        documentChanges.push({
+            ...change,
+            edits: normalizedByOrigin.get(textEditOriginKey({ kind: "documentChanges", index, edits: [] })) ?? [],
+        });
+    }
+    return {
+        ...(edit.changes !== undefined ? { changes } : {}),
+        ...(edit.documentChanges !== undefined ? { documentChanges } : {}),
+    };
+}
 export function flattenWorkspaceTextEdits(edit) {
-    const out = new Map();
+    parseWorkspaceEdit(edit);
+    const buckets = new Map();
     const push = (uri, edits) => {
-        const textEdits = edits.filter(isTextEdit);
+        const textEdits = parseTextEdits(edits, uri);
         if (textEdits.length === 0)
             return;
-        const existing = out.get(uri);
+        const key = pathIndexKey(uri);
+        const existing = buckets.get(key);
         if (existing)
-            existing.push(...textEdits);
+            existing.edits.push(...textEdits);
         else
-            out.set(uri, [...textEdits]);
+            buckets.set(key, { uri, edits: [...textEdits] });
     };
-    for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
+    for (const [uri, edits] of Object.entries(edit.changes ?? {}))
         push(uri, edits);
-    }
     for (const change of edit.documentChanges ?? []) {
-        if (isTextDocumentEdit(change)) {
-            push(change.textDocument.uri, change.edits);
-        }
+        const text = parseTextDocumentEdit(change, "documentChanges");
+        if (text)
+            push(text.textDocument.uri, text.edits);
     }
-    return out;
+    return new Map([...buckets.values()].map(({ uri, edits }) => [uri, edits]));
 }
 function textEditKey(uri, edit) {
-    return [
-        uri,
-        edit.range.start.line,
-        edit.range.start.character,
-        edit.range.end.line,
-        edit.range.end.character,
-        edit.newText,
-    ].join(":");
+    return [pathIndexKey(uri), edit.range.start.line, edit.range.start.character, edit.range.end.line, edit.range.end.character, edit.newText].join(":");
 }
 export function mergeWorkspaceTextEditsByPriority(entries) {
     const merged = new Map();
+    // Exact-duplicate dedup is a CROSS-SERVER concern only: two servers proposing
+    // the identical non-empty replace should collapse to one. Zero-width inserts
+    // are never deduplicated here — same as `validateTextEdits` on the normal
+    // apply path — because their multiplicity is meaningful: a single server can
+    // legitimately emit several identical zero-width inserts at one position
+    // (e.g. `willRenameFiles` producing "QQ" twice for an "aQQbc" edit), and
+    // deduping on exact key alone would silently drop the duplicate within that
+    // one server's own edit, contradicting the invariant documented above
+    // `validateTextEdits`.
     const seenExact = new Set();
     let droppedConflicts = 0;
     let inputEditCount = 0;
@@ -112,117 +382,738 @@ export function mergeWorkspaceTextEditsByPriority(entries) {
         if (!entry.edit)
             continue;
         for (const [uri, edits] of flattenWorkspaceTextEdits(entry.edit)) {
-            const kept = merged.get(uri) ?? [];
+            const key = pathIndexKey(uri);
+            const bucket = merged.get(key) ?? { uri, edits: [] };
+            const kept = bucket.edits;
             for (const edit of edits) {
                 inputEditCount += 1;
-                const exactKey = textEditKey(uri, edit);
-                if (seenExact.has(exactKey))
+                const exactKey = isEmptyRange(edit.range) ? undefined : textEditKey(uri, edit);
+                if (exactKey !== undefined && seenExact.has(exactKey))
                     continue;
                 if (kept.some((existing) => rangesOverlap(existing.range, edit.range))) {
                     droppedConflicts += 1;
                     continue;
                 }
-                seenExact.add(exactKey);
+                if (exactKey !== undefined)
+                    seenExact.add(exactKey);
                 kept.push(edit);
             }
             if (kept.length > 0)
-                merged.set(uri, kept);
+                merged.set(key, bucket);
         }
     }
     const changes = {};
-    for (const [uri, edits] of merged) {
+    for (const { uri, edits } of merged.values())
         changes[uri] = edits;
-    }
     return { edit: { changes }, droppedConflicts, inputEditCount, serverIds };
 }
+function pathIndexKey(uri) {
+    // uriToPath already resolves the path through normalizeFilePath, including
+    // realpath canonicalization for existing files. Re-canonicalizing that
+    // result with normalizeMapKey made every planner lookup perform a second
+    // synchronous filesystem walk; this index is call-scoped, so the cheap fold
+    // is sufficient after the first canonicalization.
+    return normalizeEphemeralMapKey(uriToPath(uri));
+}
+function textEditOriginKey(origin) {
+    // This is an input-container identity, not a filesystem/resource key. Keep
+    // the original URI spelling so two equivalent `changes` keys cannot overwrite
+    // each other's normalized output while the planner still coalesces them.
+    return origin.kind === "changes"
+        ? `changes:${origin.uri}`
+        : `documentChanges:${origin.index}`;
+}
+function parseResource(change) {
+    const kind = change.kind;
+    if (kind === "create")
+        return { kind, uri: change.uri, options: parseResourceOptions(change.options, kind) };
+    if (kind === "rename")
+        return { kind, oldUri: change.oldUri, newUri: change.newUri, options: parseResourceOptions(change.options, kind) };
+    if (kind === "delete")
+        return { kind, uri: change.uri, options: parseResourceOptions(change.options, kind) };
+    throw new Error(`unsupported workspace resource operation: ${String(kind)}`);
+}
+function planWorkspaceEdit(edit, trackOrigins = false) {
+    parseWorkspaceEdit(edit);
+    const ops = [];
+    const pending = new Map();
+    const descendants = new Map();
+    const indexedAncestors = new Map();
+    const seenResources = new Set();
+    const pathKeys = new Map();
+    const indexKey = (uri) => {
+        const cached = pathKeys.get(uri);
+        if (cached !== undefined)
+            return cached;
+        const key = pathIndexKey(uri);
+        pathKeys.set(uri, key);
+        return key;
+    };
+    const addIndex = (key) => {
+        const ancestors = [];
+        let current = key;
+        // `key` is a normalized URI index key, not an on-disk directory. The
+        // index intentionally uses the key's own separator/root semantics, so
+        // walkUpDirs (which resolves through the host filesystem) is not suitable.
+        while (true) {
+            const set = descendants.get(current) ?? new Set();
+            set.add(key);
+            descendants.set(current, set);
+            ancestors.push(current);
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        indexedAncestors.set(key, ancestors);
+    };
+    const removeIndex = (key) => {
+        for (const ancestor of indexedAncestors.get(key) ?? [])
+            descendants.get(ancestor)?.delete(key);
+        indexedAncestors.delete(key);
+    };
+    const queue = (uri, edits, version, origin) => {
+        const key = indexKey(uri);
+        const existing = pending.get(key);
+        if (existing) {
+            // Per LSP 3.17, `version: null` means "don't check" — it is not itself a
+            // version to conflict against. Only two DIFFERENT numeric versions for the
+            // same URI are a genuine conflict; a numeric version is authoritative and
+            // adopted over a `null`/`undefined` counterpart from another edit container
+            // for the same document, so the later preflight version check (which only
+            // fires for numeric `op.version`) still validates it.
+            const existingNumeric = typeof existing.version === "number" ? existing.version : undefined;
+            const incomingNumeric = typeof version === "number" ? version : undefined;
+            if (existingNumeric !== undefined && incomingNumeric !== undefined && existingNumeric !== incomingNumeric) {
+                throw new Error(`conflicting text document versions for ${uri}`);
+            }
+            existing.edits.push(...edits);
+            if (origin)
+                (existing.origins ??= []).push(origin);
+            if (existingNumeric === undefined && incomingNumeric !== undefined)
+                existing.version = version;
+            return;
+        }
+        if (origin) {
+            pending.set(key, { uri, edits: [...edits], version, origins: [origin] });
+        }
+        else {
+            pending.set(key, { uri, edits: [...edits], version });
+        }
+        addIndex(key);
+    };
+    const flushUri = (uri) => {
+        const key = indexKey(uri);
+        const item = pending.get(key);
+        if (!item)
+            return;
+        pending.delete(key);
+        removeIndex(key);
+        if (item.origins) {
+            ops.push({
+                kind: "text",
+                uri: item.uri,
+                edits: item.edits,
+                version: item.version,
+                origins: item.origins,
+            });
+        }
+        else {
+            ops.push({ kind: "text", uri: item.uri, edits: item.edits, version: item.version });
+        }
+    };
+    const flushSubtree = (uri) => {
+        const key = indexKey(uri);
+        for (const candidate of [...(descendants.get(key) ?? [])]) {
+            const item = pending.get(candidate);
+            if (item)
+                flushUri(item.uri);
+        }
+    };
+    for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
+        const parsed = parseTextEdits(edits, `changes[${uri}]`);
+        queue(uri, parsed, undefined, trackOrigins ? { kind: "changes", uri, edits: parsed } : undefined);
+    }
+    for (const [index, change] of (edit.documentChanges ?? []).entries()) {
+        const text = parseTextDocumentEdit(change, `documentChanges[${index}]`);
+        if (text) {
+            queue(text.textDocument.uri, text.edits, text.textDocument.version, trackOrigins
+                ? {
+                    kind: "documentChanges",
+                    index,
+                    edits: text.edits,
+                }
+                : undefined);
+            continue;
+        }
+        const resource = parseResource(change);
+        const resourceKey = resource.kind === "rename"
+            ? `rename:${indexKey(resource.oldUri)}:${indexKey(resource.newUri)}`
+            : `${resource.kind}:${indexKey(resource.uri)}`;
+        if (seenResources.has(resourceKey))
+            throw new Error(`duplicate workspace resource operation: ${resourceKey}`);
+        seenResources.add(resourceKey);
+        if (resource.kind === "create")
+            flushUri(resource.uri);
+        else if (resource.kind === "rename") {
+            flushSubtree(resource.oldUri);
+            flushSubtree(resource.newUri);
+        }
+        else
+            flushSubtree(resource.uri);
+        ops.push(resource);
+    }
+    for (const item of [...pending.values()])
+        flushUri(item.uri);
+    return ops;
+}
+/** Test-only planning probe used by the scaled occupancy regression. */
+export function __planWorkspaceEditForTest(edit) {
+    return planWorkspaceEdit(edit).length;
+}
 function relativeToCwd(filePath, cwd) {
     const rel = path.relative(cwd, filePath) || path.basename(filePath);
     return rel.replace(/\\/g, "/");
 }
+// Matches an import declaration or a re-export-from declaration — the two
+// statement shapes that actually change a module's dependency edges. Also
+// matches a bare `from "..."` continuation line WITHOUT a leading `import`/
+// `export`, so a formatter-wrapped multiline import
+//   import {
+//     foo,
+//   } from "./old";
+// still flags its specifier line as import-relevant even though line 1
+// ("import {") doesn't itself contain the module path. Fail-safe direction:
+// this can over-match a non-import line that happens to contain `from "..."`
+// (e.g. a string literal), but that only risks over-reporting `importsChanged`
+// (the safe direction — master's prior /^import\s/m heuristic over-invalidated
+// too), never under-reporting a real specifier change.
+const IMPORT_RELEVANT_LINE = /^\s*import\b|^\s*export\s[^;]*\bfrom\s|\bfrom\s+['"]/;
+/**
+ * A stable signature of the import/re-export-from lines in `text`, order-
+ * preserved. Used to detect whether a text edit actually changed the file's
+ * import graph (P3-6) rather than merely landing in a file that HAS imports —
+ * `fileDetails[].importsChanged` gates expensive downstream dependency-graph
+ * re-checks (see `cache-manager.ts`'s `importsChanged` filter and
+ * `lsp-mutation.ts`'s `addModifiedRange`), so over-reporting "changed" on
+ * every edit to an already-import-bearing file defeats that gate. This is a
+ * LINE-signature heuristic, not a parse: a multiline import whose specifier
+ * ("from" line) is untouched but whose bound-name list changes on an
+ * interior line (e.g. renaming one of several named imports without
+ * touching the `import {`/`} from "..."` lines) is not detected — narrower
+ * than a full import-statement diff, but still strictly safer than the prior
+ * "file merely contains any import" heuristic. Known pre-existing gaps
+ * (unaddressed here, same as before): dynamic `import(...)` calls and
+ * `require(...)` are not import-relevant lines by this heuristic.
+ */
+function importsSignature(text) {
+    return text
+        .split("\n")
+        .filter((line) => IMPORT_RELEVANT_LINE.test(line))
+        .join("\n");
+}
 export function summarizeWorkspaceEdit(edit, cwd) {
     const lines = [];
-    const textEditsByUri = flattenWorkspaceTextEdits(edit);
-    for (const [uri, edits] of textEditsByUri) {
+    for (const [uri, edits] of flattenWorkspaceTextEdits(edit))
         lines.push(`Apply ${edits.length} edit(s) to ${relativeToCwd(uriToPath(uri), cwd)}`);
-    }
     for (const change of edit.documentChanges ?? []) {
-        if (typeof change !== "object" || change === null || !("kind" in change))
+        if (!isRecord(change) || typeof change.kind !== "string")
             continue;
-        const kind = change.kind;
-        if (kind === "create" && typeof change.uri === "string") {
+        if (change.kind === "create" && typeof change.uri === "string")
             lines.push(`Create ${relativeToCwd(uriToPath(change.uri), cwd)}`);
-        }
-        else if (kind === "rename" &&
-            typeof change.oldUri === "string" &&
-            typeof change.newUri === "string") {
+        else if (change.kind === "rename" && typeof change.oldUri === "string" && typeof change.newUri === "string")
             lines.push(`Rename ${relativeToCwd(uriToPath(change.oldUri), cwd)} → ${relativeToCwd(uriToPath(change.newUri), cwd)}`);
-        }
-        else if (kind === "delete" &&
-            typeof change.uri === "string") {
+        else if (change.kind === "delete" && typeof change.uri === "string")
             lines.push(`Delete ${relativeToCwd(uriToPath(change.uri), cwd)}`);
-        }
     }
     return lines;
 }
-export async function applyWorkspaceEdit(edit, cwd) {
+async function lstatOrMissing(filePath) {
+    try {
+        return await fs.lstat(filePath);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+}
+/**
+ * True when two `lstat` results denote the SAME on-disk entry. Requires a
+ * matching `dev` AND a matching, NONZERO `ino`. The nonzero guard is
+ * load-bearing: ino-less filesystems (FAT32/exFAT, some SMB redirectors,
+ * VirtualBox shared folders) report `ino: 0` for every entry via libuv, so
+ * without it two DISTINCT files would compare `(dev, 0) === (dev, 0)` and a
+ * rename would be misclassified as a case-only alias and silently clobber the
+ * destination. Comparing the BigInt fields (from `lstat({ bigint: true })`)
+ * also avoids the double-precision loss on NTFS 64-bit file IDs >= 2^53 that a
+ * `number` `ino` would suffer (which could false-equal distinct files).
+ * Anything that is not a confident same-entry match returns false → the caller
+ * falls back to the destination-exists check (fail-closed). Exported for direct
+ * unit coverage of the ino-0 guard.
+ */
+export function isSameFsIdentity(a, b) {
+    return a.dev === b.dev && a.ino !== 0n && b.ino !== 0n && a.ino === b.ino;
+}
+async function bigintLstatOrMissing(filePath) {
+    try {
+        return await fs.lstat(filePath, { bigint: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+}
+/**
+ * True when two paths name the SAME on-disk entry — how a case-only rename on a
+ * case-insensitive FS is told apart from a genuine destination conflict without
+ * branching on `process.platform`. `lstat` (not `stat`) so a symlink is compared
+ * as itself, consistent with the rest of the preflight's symlink policy. See
+ * `isSameFsIdentity` for the dev/ino identity rules (and the ino-0 fail-closed
+ * guard for ino-less filesystems).
+ */
+async function isSameFsEntry(a, b) {
+    const [statA, statB] = await Promise.all([
+        bigintLstatOrMissing(a),
+        bigintLstatOrMissing(b),
+    ]);
+    return Boolean(statA && statB && isSameFsIdentity(statA, statB));
+}
+async function assertParentIsUsable(filePath, stateFor) {
+    let current = path.dirname(filePath);
+    while (true) {
+        const known = await stateFor(current);
+        if (known.exists) {
+            if (!known.directory)
+                throw new Error(`resource parent is not a directory: ${current}`);
+            return;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            throw new Error(`resource parent does not exist: ${filePath}`);
+        current = parent;
+    }
+}
+async function resolveExistingAncestor(filePath) {
+    let current = path.resolve(filePath);
+    const tail = [];
+    while (true) {
+        try {
+            const resolved = await fs.realpath(current);
+            return path.join(resolved, ...tail.reverse());
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+                throw err;
+            const parent = path.dirname(current);
+            if (parent === current)
+                throw err;
+            tail.push(path.basename(current));
+            current = parent;
+        }
+    }
+}
+async function createWorkspaceUriConfiner(cwd) {
+    const root = await resolveExistingAncestor(cwd);
+    return async (uri) => {
+        let filePath = "";
+        try {
+            const parsed = new URL(uri);
+            if (parsed.protocol !== "file:" || (parsed.host !== "" && parsed.hostname !== "localhost"))
+                throw new Error("URI must be a local file URI");
+            filePath = uriToPath(uri);
+        }
+        catch (err) {
+            throw new Error(`invalid workspace edit URI ${uri}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!path.isAbsolute(filePath))
+            throw new Error(`workspace edit path escapes workspace: ${uri}`);
+        const resolved = await resolveExistingAncestor(filePath);
+        if (!isUnderDir(resolved, root))
+            throw new Error(`workspace edit path escapes workspace: ${uri}`);
+        return filePath;
+    };
+}
+/** Validate a resource-only workspace edit without applying any mutation. */
+export async function validateWorkspaceEdit(edit, cwd) {
+    const planned = planWorkspaceEdit(edit);
+    await preflightWorkspaceEdit(planned, cwd, {});
+}
+async function preflightWorkspaceEdit(planned, cwd, options) {
+    const confine = await createWorkspaceUriConfiner(cwd);
+    const virtual = new Map();
+    // State for a path that `resolveVirtualPath` cannot resolve to a physical
+    // address — i.e. a path CURRENTLY vacated by an earlier rename in this same
+    // edit (its "from" address, still shadowed by an active virtual move) — but
+    // which a later `create` op in the same ordered edit re-establishes at that
+    // exact address. Keyed on the raw (unresolved) query path because there is
+    // no physical path to key `virtual` on. Consulted only when `resolveVirtualPath`
+    // returns undefined, so it never shadows a real physical/virtual-move address.
+    const virtualOverrides = new Map();
+    const virtualMoves = [];
+    const virtualTombstones = [];
+    const text = new Map();
+    const textByOrigin = new Map();
+    const ignored = new Set();
+    const resolveVirtualPath = (filePath) => {
+        let resolved = filePath;
+        for (let index = virtualMoves.length - 1; index >= 0; index--) {
+            const move = virtualMoves[index];
+            if (isUnderDir(resolved, move.to) &&
+                (move.directory || pathsEqual(resolved, move.to))) {
+                const suffix = path.relative(move.to, resolved);
+                resolved = suffix ? path.join(move.from, suffix) : move.from;
+                continue;
+            }
+            if (isUnderDir(resolved, move.from) &&
+                (move.directory || pathsEqual(resolved, move.from))) {
+                return undefined;
+            }
+        }
+        return resolved;
+    };
+    const isTombstoned = (filePath) => virtualTombstones.some((tombstone) => pathsEqual(filePath, tombstone.path) ||
+        (tombstone.directory && isUnderDir(filePath, tombstone.path)));
+    const clearTombstonesUnder = (filePath) => {
+        for (let index = virtualTombstones.length - 1; index >= 0; index--) {
+            const tombstone = virtualTombstones[index];
+            if (pathsEqual(tombstone.path, filePath) || isUnderDir(tombstone.path, filePath)) {
+                virtualTombstones.splice(index, 1);
+            }
+        }
+    };
+    const stateFor = async (filePath) => {
+        if (isTombstoned(filePath))
+            return { exists: false, directory: false };
+        const physicalPath = resolveVirtualPath(filePath);
+        if (!physicalPath) {
+            return virtualOverrides.get(normalizeMapKey(filePath)) ?? { exists: false, directory: false };
+        }
+        const key = normalizeMapKey(physicalPath);
+        const known = virtual.get(key);
+        if (known)
+            return known;
+        const stat = await lstatOrMissing(physicalPath);
+        const value = { exists: Boolean(stat), directory: stat?.isDirectory() ?? false };
+        virtual.set(key, value);
+        return value;
+    };
+    const contentFor = async (filePath, state) => {
+        if (!state.exists || state.directory)
+            throw new Error(`text edit target is not a file: ${filePath}`);
+        if (state.content !== undefined)
+            return state.content;
+        const physicalPath = resolveVirtualPath(filePath);
+        if (!physicalPath)
+            throw new Error(`text edit target does not exist: ${filePath}`);
+        const content = await fs.readFile(physicalPath, "utf-8");
+        state.content = content;
+        return content;
+    };
+    for (const op of planned) {
+        if (op.kind === "text") {
+            const filePath = await confine(op.uri);
+            const state = await stateFor(filePath);
+            if (op.version !== undefined && op.version !== null) {
+                const current = options.documentVersions?.get(normalizeMapKey(filePath));
+                if (current === undefined || current !== op.version)
+                    throw new Error(`stale text document version for ${filePath}: expected ${op.version}, current ${current ?? "unknown"}`);
+            }
+            const content = await contentFor(filePath, state);
+            const encoding = options.positionEncoding ?? "utf-16";
+            const normalized = normalizeTextEditsForContent(content, op.edits, encoding);
+            text.set(op, normalized);
+            // Keep the normalized edits attached to their original LSP containers.
+            // A planner operation can combine `changes` with a documentChanges text
+            // edit for the same URI, so the combined validation above remains the
+            // authority while this assignment preserves version/resource ordering.
+            for (const origin of op.origins ?? []) {
+                // Origins are already validated together above, but must retain
+                // multiplicity: identical zero-width insertions are meaningful and
+                // must not be deduplicated while restoring the original containers.
+                textByOrigin.set(textEditOriginKey(origin), normalizeTextEditsForContent(content, origin.edits, encoding));
+            }
+            state.content = applyTextEditsToString(content, normalized);
+            continue;
+        }
+        if (op.kind === "create") {
+            const filePath = await confine(op.uri);
+            const state = await stateFor(filePath);
+            await assertParentIsUsable(filePath, stateFor);
+            if (state.exists) {
+                if (op.options?.ignoreIfExists) {
+                    ignored.add(op);
+                    continue;
+                }
+                if (!op.options?.overwrite || state.directory)
+                    throw new Error(`create target already exists: ${filePath}`);
+                state.content = "";
+            }
+            else {
+                clearTombstonesUnder(filePath);
+                state.exists = true;
+                state.directory = false;
+                state.content = "";
+                const physicalPath = resolveVirtualPath(filePath);
+                if (physicalPath)
+                    virtual.set(normalizeMapKey(physicalPath), state);
+                // `resolveVirtualPath` returns undefined for a path currently shadowed
+                // by an earlier rename's vacated "from" address in this same ordered
+                // edit (P3-3): the created state has nowhere physical to live, so it
+                // must be recorded in the override overlay keyed on the raw query path
+                // instead — otherwise a later op addressing this exact path (e.g. a
+                // text edit) would see it as still-vacated/nonexistent.
+                else
+                    virtualOverrides.set(normalizeMapKey(filePath), state);
+            }
+            continue;
+        }
+        if (op.kind === "rename") {
+            const oldPath = await confine(op.oldUri);
+            const newPath = await confine(op.newUri);
+            // "Must differ" is a property of the on-disk target, not the case-folded
+            // map key. A case-only rename (foo.txt → Foo.txt) is a legitimate refactor
+            // whose decoded paths differ even though they collapse to a single key on a
+            // case-insensitive filesystem — so compare the decoded disk paths here, and
+            // treat a same-key-different-case pair as a real rename below.
+            const oldDisk = uriToDiskPath(op.oldUri);
+            const newDisk = uriToDiskPath(op.newUri);
+            if (path.resolve(oldDisk).replace(/\\/g, "/") === path.resolve(newDisk).replace(/\\/g, "/")) {
+                throw new Error("rename source and destination must differ");
+            }
+            const source = await stateFor(oldPath);
+            if (!source.exists)
+                throw new Error(`rename source does not exist: ${oldPath}`);
+            // Captured BEFORE this rename's own `virtualMoves`/override mutations
+            // below, so it reflects how `source` was actually resolved: `true` when
+            // `oldPath` is itself shadowed by an earlier rename in this edit and the
+            // state came from the `virtualOverrides` overlay (P3-3) rather than a
+            // physically-addressable entry.
+            const sourceFromOverride = resolveVirtualPath(oldPath) === undefined;
+            await assertParentIsUsable(newPath, stateFor);
+            const destination = await stateFor(newPath);
+            if (destination.exists) {
+                // Decide "already exists" by on-disk IDENTITY, not a platform-keyed path
+                // fold. A case-only (or otherwise-aliased) rename whose destination
+                // resolves to the SAME FS entry as the source is a legitimate refactor,
+                // not a conflict — detected here on ANY case-insensitive FS (win32, macOS
+                // APFS/HFS+), per the #1024 "probe the FS, don't branch on platform"
+                // lesson. Conversely, on a case-SENSITIVE FS where both spellings are
+                // distinct real files, this stays a genuine conflict (closing the inverse
+                // silent-clobber edge that a win32-only fold left open).
+                //
+                // P3-8: when the source exists only VIRTUALLY (e.g. created earlier in
+                // this same ordered edit and never yet written to disk), `isSameFsEntry`
+                // lstats disk and finds nothing there, so it can never recognize a
+                // case-only alias for a not-yet-physical file. `stateFor` keys the
+                // `virtual`/override maps on the SAME case-folded identity used for
+                // physical aliasing, so if `destination` and `source` resolved to the
+                // identical cached VirtualFile object, they are — by construction of
+                // that keying — the same virtual entry (a case-insensitive-FS alias);
+                // checked as a fast, disk-free first branch before falling back to the
+                // physical probe (which remains untouched for genuinely-physical paths).
+                const aliasesSource = destination === source || (await isSameFsEntry(oldDisk, newDisk));
+                if (!aliasesSource) {
+                    if (op.options?.ignoreIfExists) {
+                        ignored.add(op);
+                        continue;
+                    }
+                    if (!op.options?.overwrite)
+                        throw new Error(`rename destination already exists: ${newPath}`);
+                }
+            }
+            clearTombstonesUnder(newPath);
+            if (!source.directory)
+                await contentFor(oldPath, source);
+            if (sourceFromOverride) {
+                // P3 (round-2 review): a purely virtual entry (created earlier in this
+                // same edit at a path vacated by an even earlier rename) has no
+                // physical address for a `virtualMoves` shadow to resolve against —
+                // `resolveVirtualPath` walks that list by PHYSICAL path chasing, which
+                // cannot represent "this virtual entry moved again." Pushing a move
+                // here would leave the stale `virtualOverrides[oldPath]` entry
+                // claiming `exists: true` forever (a later `create(oldPath)` would be
+                // falsely rejected, and reads of the new address wouldn't reliably
+                // find it either). Instead, migrate the state object directly: drop
+                // the stale key and re-key it under the destination, placing it back
+                // in `virtual` (physically addressable) or `virtualOverrides` (still
+                // shadowed) depending on whether the destination itself currently
+                // resolves to a physical path.
+                virtualOverrides.delete(normalizeMapKey(oldPath));
+                const destinationPhysicalPath = resolveVirtualPath(newPath);
+                if (destinationPhysicalPath)
+                    virtual.set(normalizeMapKey(destinationPhysicalPath), source);
+                else
+                    virtualOverrides.set(normalizeMapKey(newPath), source);
+            }
+            else {
+                // Keep descendants lazy: a later text edit under a renamed directory
+                // resolves through this virtual move to the original physical path.
+                // This preserves ordered workspace-edit semantics without walking the
+                // entire subtree during preflight.
+                virtualMoves.push({ from: oldPath, to: newPath, directory: source.directory });
+            }
+            continue;
+        }
+        const filePath = await confine(op.uri);
+        const state = await stateFor(filePath);
+        if (!state.exists) {
+            if (op.options?.ignoreIfNotExists)
+                ignored.add(op);
+            else
+                throw new Error(`delete target does not exist: ${filePath}`);
+        }
+        else {
+            if (state.directory && !op.options?.recursive)
+                throw new Error(`delete directory requires recursive: ${filePath}`);
+            state.exists = false;
+            state.content = undefined;
+            virtualTombstones.push({ path: filePath, directory: state.directory });
+        }
+    }
+    return { text, textByOrigin, ignored };
+}
+/**
+ * Applies a workspace edit. All URI, shape, version, resource-precondition and
+ * text-bound checks happen in preflight before the first write. Once preflight
+ * succeeds, an unexpected filesystem failure may still leave earlier mutations
+ * applied; this is intentionally the existing no-rollback boundary.
+ */
+export async function applyWorkspaceEdit(edit, cwd, options = {}) {
     const descriptions = [];
     const touchedFiles = new Set();
-    const textEditsByUri = flattenWorkspaceTextEdits(edit);
+    const fileDetails = [];
+    const appliedOperationIndexes = [];
+    let appliedOperationTotal = 0;
+    let operationIndex = 0;
+    const operationCounts = { textEdits: 0, create: 0, rename: 0, delete: 0 };
+    const planned = planWorkspaceEdit(edit);
+    let operationTotal = 0;
+    let prepared;
+    const operationSize = (op) => op.kind === "text" ? (prepared.text.get(op)?.length ?? 0) : 1;
+    const markApplied = (op) => {
+        const count = operationSize(op);
+        for (let index = 0; index < count; index++) {
+            if (appliedOperationIndexes.length < 100) {
+                appliedOperationIndexes.push(operationIndex + index);
+            }
+        }
+        appliedOperationTotal += count;
+        operationIndex += count;
+    };
+    const skipOperation = (op) => {
+        operationIndex += operationSize(op);
+    };
+    const makeResult = () => ({
+        descriptions,
+        files: [...touchedFiles],
+        operationTotal,
+        appliedOperationTotal,
+        appliedOperationIndexes,
+        operationCounts,
+        fileDetails,
+    });
     try {
-        for (const [uri, edits] of textEditsByUri) {
-            const filePath = uriToPath(uri);
-            const content = await fs.readFile(filePath, "utf-8");
-            const updated = applyTextEditsToString(content, edits);
-            await fs.writeFile(filePath, updated, "utf-8");
-            touchedFiles.add(filePath);
-            descriptions.push(`Applied ${edits.length} edit(s) to ${relativeToCwd(filePath, cwd)}`);
-        }
-        for (const change of edit.documentChanges ?? []) {
-            if (typeof change !== "object" || change === null || !("kind" in change))
+        prepared = await preflightWorkspaceEdit(planned, cwd, options);
+        for (const op of planned) {
+            const size = operationSize(op);
+            if (op.kind === "text")
+                operationCounts.textEdits += size;
+            else
+                operationCounts[op.kind]++;
+            operationTotal += size;
+        }
+        for (const op of planned) {
+            if (prepared.ignored.has(op)) {
+                skipOperation(op);
                 continue;
-            const kind = change.kind;
-            if (kind === "create" &&
-                typeof change.uri === "string") {
-                const filePath = uriToPath(change.uri);
-                await fs.mkdir(path.dirname(filePath), { recursive: true });
-                await fs
-                    .writeFile(filePath, "", { flag: "wx" })
-                    .catch(async (err) => {
-                    if (err.code !== "EEXIST")
-                        throw err;
-                });
+            }
+            if (op.kind === "text") {
+                // Report/key on the normalized path (forward-slash, realpath-canonical),
+                // but read/write the decoded on-disk path so the URI's casing is honored
+                // on win32 (see uriToDiskPath).
+                const filePath = uriToPath(op.uri);
+                const diskPath = uriToDiskPath(op.uri);
+                const edits = prepared.text.get(op) ?? [];
+                if (edits.length === 0) {
+                    skipOperation(op);
+                    continue;
+                }
+                const content = await fs.readFile(diskPath, "utf-8");
+                const updated = applyTextEditsToString(content, edits, "utf-16");
+                await fs.writeFile(diskPath, updated, "utf-8");
+                const start = Math.min(...edits.map((item) => item.range.start.line + 1));
+                const end = Math.max(...edits.map((item) => item.range.end.line + 1));
+                touchedFiles.add(filePath);
+                fileDetails.push({ filePath, range: { start, end }, importsChanged: importsSignature(content) !== importsSignature(updated) });
+                markApplied(op);
+                descriptions.push(`Applied ${edits.length} edit(s) to ${relativeToCwd(filePath, cwd)}`);
+            }
+            else if (op.kind === "create") {
+                // Create on the decoded path so `NewFile.txt` is not lowercased on win32;
+                // report/key on the normalized path.
+                const filePath = uriToPath(op.uri);
+                const diskPath = uriToDiskPath(op.uri);
+                await fs.mkdir(path.dirname(diskPath), { recursive: true });
+                if (op.options?.overwrite)
+                    await fs.writeFile(diskPath, "", "utf-8");
+                else
+                    await fs.writeFile(diskPath, "", { flag: "wx" });
                 touchedFiles.add(filePath);
+                fileDetails.push({ filePath, range: { start: 1, end: 1 }, importsChanged: false });
+                markApplied(op);
                 descriptions.push(`Created ${relativeToCwd(filePath, cwd)}`);
             }
-            else if (kind === "rename" &&
-                typeof change.oldUri === "string" &&
-                typeof change.newUri === "string") {
-                const oldPath = uriToPath(change.oldUri);
-                const newPath = uriToPath(change.newUri);
-                await fs.mkdir(path.dirname(newPath), { recursive: true });
-                await fs.rename(oldPath, newPath);
+            else if (op.kind === "rename") {
+                // Rename on the decoded paths so the destination casing is honored (and a
+                // case-only rename actually changes the name); report on normalized paths.
+                const oldPath = uriToPath(op.oldUri);
+                const newPath = uriToPath(op.newUri);
+                const oldDisk = uriToDiskPath(op.oldUri);
+                const newDisk = uriToDiskPath(op.newUri);
+                await fs.mkdir(path.dirname(newDisk), { recursive: true });
+                if (op.options?.overwrite)
+                    await fs.rm(newDisk, { recursive: true, force: true });
+                await fs.rename(oldDisk, newDisk);
                 touchedFiles.add(oldPath);
                 touchedFiles.add(newPath);
+                fileDetails.push({ filePath: oldPath, range: { start: 1, end: 1 }, importsChanged: true }, { filePath: newPath, range: { start: 1, end: 1 }, importsChanged: true });
+                markApplied(op);
                 descriptions.push(`Renamed ${relativeToCwd(oldPath, cwd)} → ${relativeToCwd(newPath, cwd)}`);
             }
-            else if (kind === "delete" &&
-                typeof change.uri === "string") {
-                const filePath = uriToPath(change.uri);
-                await fs.rm(filePath, { recursive: true, force: true });
+            else {
+                const filePath = uriToPath(op.uri);
+                const diskPath = uriToDiskPath(op.uri);
+                await fs.rm(diskPath, { recursive: op.options?.recursive === true, force: false });
                 touchedFiles.add(filePath);
+                fileDetails.push({ filePath, range: { start: 1, end: 1 }, importsChanged: true });
+                markApplied(op);
                 descriptions.push(`Deleted ${relativeToCwd(filePath, cwd)}`);
             }
         }
     }
     catch (err) {
+        const partial = makeResult();
+        if (options.mutationContext && options.observe !== false) {
+            recordLspMutation(options.mutationContext, { results: [partial], status: "failed" });
+        }
         const already = [...touchedFiles];
         if (already.length > 0) {
-            const alreadyList = already
-                .map((f) => `  • ${relativeToCwd(f, cwd)}`)
-                .join("\n");
-            throw new Error(`Workspace edit failed mid-application — ${already.length} file(s) already written, no rollback performed:\n${alreadyList}\nCause: ${err instanceof Error ? err.message : String(err)}`);
+            const alreadyList = already.map((f) => `  • ${relativeToCwd(f, cwd)}`).join("\n");
+            const failure = new Error(`Workspace edit failed mid-application — ${already.length} file(s) already written, no rollback performed:\n${alreadyList}\nCause: ${err instanceof Error ? err.message : String(err)}`);
+            failure.appliedWorkspaceEdit = partial;
+            throw failure;
         }
         throw err;
     }
-    return { descriptions, files: [...touchedFiles] };
+    const applied = makeResult();
+    if (options.mutationContext && options.observe !== false) {
+        recordLspMutation(options.mutationContext, {
+            results: [applied],
+            status: appliedOperationTotal > 0 ? "success" : "skipped",
+        });
+    }
+    return applied;
 }