@openclaw/diffs 2026.9.4 → 2026.9.6

package/node_modules/@pierre/diffs/dist/components/FileDiff.js

@@ -1,16 +1,15 @@
 import { CUSTOM_HEADER_SLOT_ID, DEFAULT_THEMES, EMPTY_RENDER_RANGE, HEADER_FILENAME_SUFFIX_SLOT_ID, HEADER_METADATA_SLOT_ID, HEADER_PREFIX_SLOT_ID } from "../constants.js";
+import { getThemes } from "../utils/getThemes.js";
+import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { dequeueRender, queueRender } from "../managers/UniversalRenderingManager.js";
 import { areThemesEqual } from "../utils/areThemesEqual.js";
-import { getHunkSideStartBoundary } from "../utils/getHunkSideBoundaries.js";
-import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
-import { getExpandedRegion, getHunkAdditionLineRange, getNearestRenderableAdditionLine, getTrailingExpandedRegion, isAdditionLineRenderable } from "../utils/virtualDiffLayout.js";
-import { captureExpansionAnchors, finishEditSessionForDiff, rebuildExpansionFromAnchors } from "../utils/editSessionHunks.js";
 import { isStyleNode } from "../utils/isStyleNode.js";
-import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { InteractionManager, pluckInteractionOptions } from "../managers/InteractionManager.js";
 import { ResizeManager } from "../managers/ResizeManager.js";
 import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
+import { getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
+import { isDefaultRenderRange } from "../utils/isDefaultRenderRange.js";
 import { SVGSpriteSheet } from "../sprite.js";
 import { arePrePropertiesEqual } from "../utils/arePrePropertiesEqual.js";
 import { createAnnotationWrapperNode } from "../utils/createAnnotationWrapperNode.js";
@@ -18,6 +17,7 @@ import { createGutterUtilityContentNode } from "../utils/createGutterUtilityCont
 import { createUnsafeCSSStyleNode } from "../utils/createUnsafeCSSStyleNode.js";
 import { getMeasuredScrollbarGutter } from "../utils/scrollbarGutter.js";
 import { patchScrollbarGutterSize, wrapThemeCSS, wrapUnsafeCSS } from "../utils/cssWrappers.js";
+import { adoptEditSessionAnnotations, resolveEditSessionSlotName, writeEditSessionAnnotations } from "../utils/editSessionAnnotations.js";
 import { getOrCreateCodeNode } from "../utils/getOrCreateCodeNode.js";
 import { guardWebKitScrollDuringRebuild } from "../utils/guardWebKitScrollDuringRebuild.js";
 import { upsertHostThemeStyle } from "../utils/hostTheme.js";
@@ -25,12 +25,20 @@ import { isSafari } from "../utils/platform.js";
 import { prerenderHTMLIfNecessary } from "../utils/prerenderHTMLIfNecessary.js";
 import { setPreNodeProperties } from "../utils/setWrapperNodeProps.js";
 import "./web-components.js";
+import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
+import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { awaitWithTimeout } from "../utils/awaitWithTimeout.js";
+import { getHunkSideStartBoundary } from "../utils/getHunkSideBoundaries.js";
+import { getExpandedRegion, getHunkAdditionLineRange, getNearestRenderableAdditionLine, getTrailingExpandedRegion, isAdditionLineRenderable } from "../utils/virtualDiffLayout.js";
 import { getDiffFileInput } from "../utils/getDiffFileInput.js";
+import { cloneFileDiffMetadata, cloneHunks } from "../utils/cloneFileDiffMetadata.js";
+import { splitFileContents } from "../utils/splitFileContents.js";
 import { hydratePartialDiff } from "../utils/hydratePartialDiff.js";
 import { iterateOverDiff } from "../utils/iterateOverDiff.js";
+import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
 import { ScrollSyncManager } from "../managers/ScrollSyncManager.js";
-import { isDefaultRenderRange } from "../utils/isDefaultRenderRange.js";
+import { recomputeDiffRenderLineCounts } from "../utils/updateDiffHunks.js";
+import { captureExpansionAnchors, finishEditSessionForDiff, rebuildExpansionFromAnchors } from "../utils/editSessionHunks.js";
 import { isDiffPlainText } from "../utils/isDiffPlainText.js";
 import { DiffHunksRenderer } from "../renderers/DiffHunksRenderer.js";
 import { areDiffLineAnnotationsEqual } from "../utils/areDiffLineAnnotationsEqual.js";
@@ -41,6 +49,28 @@ import { toHtml } from "hast-util-to-html";
 function canHydrateDiff(fileDiff) {
 	return fileDiff.isPartial && (fileDiff.type === "change" || fileDiff.type === "rename-changed" || fileDiff.type === "rename-pure");
 }
+function createEditSessionDiff(fileDiff) {
+	const editSessionDiff = { ...fileDiff };
+	delete editSessionDiff.cacheKey;
+	return editSessionDiff;
+}
+function shouldResetUndoState(prevDiff, nextDiff) {
+	if (prevDiff.isPartial || nextDiff.isPartial) throw new Error("FileDiff.shouldResetEditorForExternalDiff: diffs must be fully hydrated");
+	const prevLanguage = prevDiff.lang ?? getFiletypeFromFileName(prevDiff.name);
+	const nextLanguage = nextDiff.lang ?? getFiletypeFromFileName(nextDiff.name);
+	const prevHasOldFile = prevDiff.type !== "new";
+	const nextHasOldFile = nextDiff.type !== "new";
+	if (prevDiff.name !== nextDiff.name || prevLanguage !== nextLanguage || prevHasOldFile !== nextHasOldFile || prevDiff.deletionLines.length !== nextDiff.deletionLines.length) return true;
+	return prevDiff.deletionLines.some((line, index) => line !== nextDiff.deletionLines[index]);
+}
+function areLinesEqual(first, second) {
+	return first.length === second.length && first.every((line, index) => line === second[index]);
+}
+function canRestoreDiffSession(snapshot, externalDiff) {
+	const { oldFile } = snapshot;
+	if (oldFile == null) return externalDiff.type === "new";
+	return externalDiff.type !== "new" && oldFile.name === (externalDiff.prevName ?? externalDiff.name) && areLinesEqual(oldFile.lines, externalDiff.deletionLines);
+}
 let instanceId = -1;
 var FileDiff = class {
 	options;
@@ -81,11 +111,16 @@ var FileDiff = class {
 	deletionFile;
 	additionFile;
 	fileDiff;
+	editSession;
+	renderedDiff;
 	renderRange;
 	pendingFiles;
 	appliedPreAttributes;
-	lastRenderedHeaderHTML;
-	cachedHeaderHTML;
+	headerCache = {
+		lastRenderedHTML: void 0,
+		html: void 0,
+		fileDiff: void 0
+	};
 	lastRowCount;
 	mounted = false;
 	enabled = true;
@@ -108,14 +143,22 @@ var FileDiff = class {
 	handleHighlightRender = () => {
 		this.rerender();
 	};
+	getTheme() {
+		return this.workerManager?.getDiffRenderOptions().theme ?? this.options.theme ?? DEFAULT_THEMES;
+	}
 	getHunksRendererOptions(options) {
 		return getDiffHunksRendererOptions(options);
 	}
 	createHunksRenderer(options) {
-		return new DiffHunksRenderer(this.getHunksRendererOptions(options), this.handleHighlightRender, this.workerManager);
+		return new DiffHunksRenderer(this.getHunksRendererOptions(options), this.getAnnotationSlotName, this.handleHighlightRender, this.workerManager);
 	}
 	getLineIndex = (lineNumber, side = "additions") => {
-		const fileDiff = this.fileDiffCache;
+		return this.getLineIndexForDiff(this.getDiffForLineIndex(), lineNumber, side);
+	};
+	getDiffForLineIndex() {
+		return this.getRenderedDiff();
+	}
+	getLineIndexForDiff(fileDiff, lineNumber, side) {
 		if (fileDiff == null) return;
 		const lastHunk = fileDiff.hunks.at(-1);
 		let targetUnifiedIndex;
@@ -141,17 +184,18 @@ var FileDiff = class {
 				}
 				continue;
 			}
-			for (const content of hunk.hunkContent) if (content.type === "context") if (lineNumber < currentLineNumber + content.lines) {
-				const difference = lineNumber - currentLineNumber;
-				targetSplitIndex = splitIndex + difference;
-				targetUnifiedIndex = unifiedIndex + difference;
-				break hunkIterator;
+			for (const content of hunk.hunkContent) if (content.type === "context") {
+				if (lineNumber < currentLineNumber + content.lines) {
+					const difference = lineNumber - currentLineNumber;
+					targetSplitIndex = splitIndex + difference;
+					targetUnifiedIndex = unifiedIndex + difference;
+					break hunkIterator;
+				} else {
+					currentLineNumber += content.lines;
+					splitIndex += content.lines;
+					unifiedIndex += content.lines;
+				}
 			} else {
-				currentLineNumber += content.lines;
-				splitIndex += content.lines;
-				unifiedIndex += content.lines;
-			}
-			else {
 				const sideCount = side === "deletions" ? content.deletions : content.additions;
 				if (lineNumber < currentLineNumber + sideCount) {
 					const indexDifference = lineNumber - currentLineNumber;
@@ -168,11 +212,11 @@ var FileDiff = class {
 		}
 		if (targetUnifiedIndex == null || targetSplitIndex == null) return;
 		return [targetUnifiedIndex, targetSplitIndex];
-	};
+	}
 	setOptions(options) {
 		if (options == null) return;
 		this.options = options;
-		this.cachedHeaderHTML = void 0;
+		this.clearReusableHeader();
 		this.hunksRenderer.setOptions(this.getHunksRendererOptions(options));
 		this.syncInteractionOptions();
 	}
@@ -198,13 +242,39 @@ var FileDiff = class {
 		return true;
 	}
 	hasThemeChanged() {
-		return this.appliedThemeCSS != null && !areThemesEqual(this.appliedThemeCSS.theme, this.options.theme ?? DEFAULT_THEMES);
+		return this.appliedThemeCSS != null && !areThemesEqual(this.appliedThemeCSS.theme, this.getTheme());
 	}
 	getHoveredLine = () => {
 		return this.interactionManager.getHoveredLine();
 	};
+	getAnnotationSlotName = (annotation) => {
+		return resolveEditSessionSlotName(this.editSession?.annotations, annotation, getLineAnnotationName);
+	};
+	getLatestAnnotations() {
+		return this.editSession?.annotations?.current ?? this.lineAnnotations;
+	}
+	isNewAnnotations(lineAnnotations) {
+		const session = this.editSession?.annotations;
+		if (lineAnnotations === this.lineAnnotations) return false;
+		return session == null || lineAnnotations !== session.provided && lineAnnotations !== session.current;
+	}
 	setLineAnnotations(lineAnnotations) {
+		const sessionAnnotations = this.editSession?.annotations;
+		if (sessionAnnotations == null) {
+			this.lineAnnotations = lineAnnotations;
+			return;
+		}
+		if (!this.isNewAnnotations(lineAnnotations)) return;
 		this.lineAnnotations = lineAnnotations;
+		writeEditSessionAnnotations(sessionAnnotations, lineAnnotations, getLineAnnotationName);
+	}
+	syncEditSessionAnnotationsFromEditor(lineAnnotations) {
+		const session = this.editSession?.annotations;
+		if (session == null || lineAnnotations === session.current) return false;
+		session.current = lineAnnotations;
+		this.hunksRenderer.setLineAnnotations(lineAnnotations);
+		this.renderAnnotations();
+		return true;
 	}
 	canPartiallyRender(forceRender, annotationsChanged, didContentChange) {
 		if (forceRender || annotationsChanged || didContentChange || typeof this.options.hunkSeparators === "function") return false;
@@ -246,7 +316,7 @@ var FileDiff = class {
 	}
 	shouldApplyColumnVariables(overflow) {
 		if (typeof this.options.hunkSeparators === "function") return true;
-		return overflow === "scroll" && (this.lineAnnotations.length > 0 || this.pre?.hasAttribute("data-has-merge-conflict") === true);
+		return overflow === "scroll" && (this.getLatestAnnotations().length > 0 || this.pre?.hasAttribute("data-has-merge-conflict") === true);
 	}
 	getCodeScrollLeft() {
 		return Math.max(this.codeUnified?.scrollLeft ?? 0, this.codeDeletions?.scrollLeft ?? 0, this.codeAdditions?.scrollLeft ?? 0);
@@ -263,17 +333,18 @@ var FileDiff = class {
 		};
 	}
 	cleanUp(recycle = false) {
+		const { editor } = this;
 		dequeueRender(this.handleEditSessionRender);
 		this.emitPostRender(true);
-		this.editor?.cleanUp(recycle);
-		this.editor = void 0;
+		editor?.cleanUp(recycle ? "recycle" : "discard");
+		if (!recycle) this.editor = void 0;
 		this.resizeManager.cleanUp();
 		this.interactionManager.cleanUp();
 		this.scrollSyncManager.cleanUp();
 		this.managersDirty = false;
 		this.workerManager?.unsubscribeToThemeChanges(this);
 		this.renderRange = void 0;
-		this.pendingFiles = void 0;
+		if (!recycle) this.pendingFiles = void 0;
 		if (!this.isContainerManaged) this.fileContainer?.remove();
 		this.fileContainer = void 0;
 		this.mounted = false;
@@ -296,8 +367,8 @@ var FileDiff = class {
 		this.headerCustom = void 0;
 		this.placeHolder?.remove();
 		this.placeHolder = void 0;
-		this.lastRenderedHeaderHTML = void 0;
-		if (!recycle) this.cachedHeaderHTML = void 0;
+		this.headerCache.lastRenderedHTML = void 0;
+		if (!recycle) this.clearReusableHeader();
 		this.errorWrapper?.remove();
 		this.errorWrapper = void 0;
 		this.spriteSVG = void 0;
@@ -312,6 +383,8 @@ var FileDiff = class {
 			this.hunksRenderer.cleanUp();
 			this.workerManager = void 0;
 			this.fileDiff = void 0;
+			this.editSession = void 0;
+			this.renderedDiff = void 0;
 			this.deletionFile = void 0;
 			this.additionFile = void 0;
 		}
@@ -335,7 +408,8 @@ var FileDiff = class {
 		const oldFile = fileInput?.oldFile;
 		const newFile = fileInput?.newFile;
 		this.hydrateElements(fileContainer, prerenderedHTML);
-		if (shouldRenderCode(this.pre, hasDiffContent({
+		const forceEditorRender = this.editor != null;
+		if (forceEditorRender || shouldRenderCode(this.pre, hasDiffContent({
 			fileDiff,
 			oldFile,
 			newFile
@@ -348,6 +422,7 @@ var FileDiff = class {
 			fileContainer,
 			lineAnnotations,
 			fileDiff,
+			forceRender: forceEditorRender || fileInputProps.forceRender,
 			preventEmit: true
 		});
 		else this.hydrationSetup({
@@ -405,6 +480,7 @@ var FileDiff = class {
 		if (this.pre == null) return;
 		this.syncInteractionOptions();
 		this.hunksRenderer.hydrate(this.fileDiff);
+		this.renderedDiff = this.fileDiff;
 		this.renderAnnotations();
 		this.renderGutterUtility();
 		this.injectUnsafeCSS();
@@ -433,10 +509,15 @@ var FileDiff = class {
 	loadFilesIfNecessary() {
 		const { fileDiff, options: { loadDiffFiles } } = this;
 		if (fileDiff == null || loadDiffFiles == null || !canHydrateDiff(fileDiff) || this.pendingFiles?.fileDiff === fileDiff) return;
-		this.pendingFiles = {
+		const promise = this.loadFilesForDiff(fileDiff, loadDiffFiles);
+		const pendingFiles = this.pendingFiles = {
 			fileDiff,
-			promise: this.loadFilesForDiff(fileDiff, loadDiffFiles)
+			promise
+		};
+		const clearPendingFiles = () => {
+			if (this.pendingFiles === pendingFiles) this.pendingFiles = void 0;
 		};
+		pendingFiles.promise = promise.finally(clearPendingFiles);
 	}
 	async loadFilesForDiff(fileDiff, loadDiffFiles) {
 		try {
@@ -446,18 +527,76 @@ var FileDiff = class {
 		} catch (error) {
 			if (this.options.disableErrorHandling === true) throw error;
 			console.error(error);
-		} finally {
-			if (this.pendingFiles?.fileDiff === fileDiff) this.pendingFiles = void 0;
 		}
 	}
 	async handleFilesLoaded(expectedDiff, files) {
 		if (this.fileDiff !== expectedDiff || !expectedDiff.isPartial) return;
 		hydratePartialDiff("merge", expectedDiff, files);
 		this.setHydratedState(files);
+		if (this.startHydratedEditSession(expectedDiff)) {
+			this.rerender();
+			return;
+		}
 		await awaitWithTimeout(() => this.primeHighlightCache(expectedDiff));
 		if (!this.enabled || this.fileDiff !== expectedDiff) return;
 		this.rerender();
 	}
+	startHydratedEditSession(expectedDiff) {
+		if (expectedDiff.isPartial) throw new Error("FileDiff.startHydratedEditSession: diffs cannot be partial for editing");
+		if (this.fileDiff !== expectedDiff) return false;
+		const { editor } = this;
+		if (this.editSession?.outgoingDiff != null) {
+			this.installEditSession(expectedDiff);
+			return true;
+		}
+		if (editor == null || this.editSession != null) return false;
+		this.installEditSession(expectedDiff, editor.__getDocumentContents(getAdditionFile(expectedDiff)), editor.__getDocumentSessionState());
+		return true;
+	}
+	updateExternalDiff(incomingExternalDiff, lineAnnotations) {
+		if (areDiffTargetsEqual(this.fileDiff, incomingExternalDiff)) return false;
+		const outgoingDiff = this.editSession?.outgoingDiff ?? this.editSession?.diff;
+		this.fileDiff = incomingExternalDiff;
+		if (outgoingDiff != null) {
+			if (incomingExternalDiff.isPartial) this.loadFilesIfNecessary();
+			else this.installEditSession(incomingExternalDiff);
+			if (this.editSession != null) this.editSession.outgoingDiff = outgoingDiff;
+		} else if (this.editor != null) {
+			if (incomingExternalDiff.isPartial) this.loadFilesIfNecessary();
+			else this.installEditSession(incomingExternalDiff, this.editor.__getDocumentContents(getAdditionFile(incomingExternalDiff)), this.editor.__getDocumentSessionState());
+		}
+		if (this.editSession?.annotations != null && lineAnnotations != null) {
+			this.lineAnnotations = lineAnnotations;
+			this.editSession.annotations = adoptEditSessionAnnotations(lineAnnotations, getLineAnnotationName, this.editSession.annotations);
+		}
+		return true;
+	}
+	installEditSession(externalDiff, retainedDocument, retainedSession) {
+		const externalContents = externalDiff.additionLines.join("");
+		const retainedLines = retainedDocument != null ? splitFileContents(retainedDocument.contents) : void 0;
+		const restoreRetainedSession = retainedSession != null && canRestoreDiffSession(retainedSession, externalDiff);
+		if (retainedSession != null && !restoreRetainedSession) throw new Error("FileDiff: retained session cannot resume against a different old file");
+		if (retainedDocument != null && retainedDocument.contents !== externalContents && !restoreRetainedSession) throw new Error("FileDiff: retained edits are missing their diff session state");
+		const usesExternalDocument = retainedDocument == null || retainedDocument.name === externalDiff.name && retainedDocument.lang === externalDiff.lang && retainedDocument.contents === externalContents;
+		const sessionDiff = createEditSessionDiff(externalDiff);
+		if (retainedDocument != null && retainedLines != null && !usesExternalDocument) {
+			sessionDiff.name = retainedDocument.name;
+			sessionDiff.lang = retainedDocument.lang;
+		}
+		if (restoreRetainedSession && retainedSession != null && retainedLines != null) {
+			sessionDiff.additionLines = retainedLines;
+			sessionDiff.type = retainedSession.type;
+			sessionDiff.hunks = retainedSession.hunks;
+			sessionDiff.editSessionDirty = true;
+			recomputeDiffRenderLineCounts(sessionDiff);
+		}
+		this.editSession = {
+			diff: sessionDiff,
+			annotations: this.editSession?.annotations ?? adoptEditSessionAnnotations(this.lineAnnotations, getLineAnnotationName),
+			outgoingDiff: this.editSession?.outgoingDiff
+		};
+		this.hunksRenderer.beginEditSession(sessionDiff, usesExternalDocument && !restoreRetainedSession ? externalDiff : void 0);
+	}
 	setHydratedState(files) {
 		this.deletionFile = files.oldFile;
 		this.additionFile = files.newFile;
@@ -465,20 +604,23 @@ var FileDiff = class {
 		this.hunksRenderer.clearRenderCache();
 	}
 	render({ fileDiff, deferManagers = false, forceRender = false, preventEmit = false, lineAnnotations, fileContainer, containerWrapper, renderRange, ...fileInputProps }) {
+		if (!this.enabled) throw new Error("FileDiff.render: attempting to call render after cleaned up");
 		const fileInput = getDiffFileInput(fileInputProps, "FileDiff.render");
 		const oldFile = fileInput?.oldFile;
 		const newFile = fileInput?.newFile;
-		if (!this.enabled) throw new Error("FileDiff.render: attempting to call render after cleaned up");
-		if (fileDiff != null && fileDiff.cacheKey === void 0) fileDiff.cacheKey = fileDiff.prevName != null ? fileDiff.prevName + ":" + fileDiff.name : fileDiff.name;
 		this.editor?.__postponeBgTokenizeToNextFrame();
 		const { collapsed = false, themeType = "system", expandUnchanged = false } = this.options;
 		const nextRenderRange = collapsed ? void 0 : renderRange;
 		const themeChanged = this.hasThemeChanged();
 		const hasFileInput = fileInput != null;
 		const filesDidChange = hasFileInput && (!areOptionalFilesEqual(oldFile, this.deletionFile) || !areOptionalFilesEqual(newFile, this.additionFile));
-		let diffDidChange = fileDiff != null && fileDiff !== this.fileDiff;
-		const annotationsChanged = lineAnnotations != null && (lineAnnotations.length > 0 || this.lineAnnotations.length > 0) ? lineAnnotations !== this.lineAnnotations : false;
-		if (!collapsed && areRenderRangesEqual(nextRenderRange, this.renderRange) && !forceRender && !annotationsChanged && !themeChanged && (fileDiff != null && fileDiff === this.fileDiff || fileDiff == null && !filesDidChange)) return this.applyCachedThemeState(themeType);
+		let diffDidChange = fileDiff != null && !areDiffTargetsEqual(fileDiff, this.fileDiff);
+		const annotationsChanged = lineAnnotations != null && (lineAnnotations.length > 0 || this.getLatestAnnotations().length > 0) ? this.isNewAnnotations(lineAnnotations) : false;
+		if (!collapsed && areRenderRangesEqual(nextRenderRange, this.renderRange) && !forceRender && !annotationsChanged && !themeChanged && (fileDiff != null && !diffDidChange || fileDiff == null && !filesDidChange)) {
+			const rendered = this.applyCachedThemeState(themeType);
+			if (rendered) this.finalizeRender();
+			return rendered;
+		}
 		let nextParsedFileDiff;
 		if (fileDiff == null && hasFileInput && (filesDidChange || this.fileDiff == null)) nextParsedFileDiff = parseDiffFromFile(fileInput.oldFile, fileInput.newFile, this.options.parseDiffOptions);
 		const { renderRange: previousRenderRange } = this;
@@ -490,28 +632,29 @@ var FileDiff = class {
 			this.deletionFile = void 0;
 			this.additionFile = void 0;
 		}
-		if (fileDiff != null) this.fileDiff = fileDiff;
+		if (fileDiff != null && diffDidChange) this.updateExternalDiff(fileDiff, lineAnnotations);
 		else if (nextParsedFileDiff != null) {
 			diffDidChange = true;
-			this.fileDiff = nextParsedFileDiff;
+			this.updateExternalDiff(nextParsedFileDiff, lineAnnotations);
 		}
-		if (diffDidChange) this.cachedHeaderHTML = void 0;
+		if (diffDidChange) this.clearReusableHeader();
 		if (lineAnnotations != null) this.setLineAnnotations(lineAnnotations);
-		if (this.fileDiff == null) return false;
-		if (this.fileDiff.editSessionDirty === true && this.shouldSelfHealEditSession()) {
-			finishEditSessionForDiff(this.fileDiff, this.options.parseDiffOptions);
+		const latestDiff = this.getLatestDiff();
+		if (latestDiff == null) return false;
+		if (latestDiff.editSessionDirty === true && this.shouldSelfHealEditSession()) {
+			finishEditSessionForDiff(latestDiff, this.options.parseDiffOptions);
 			this.hunksRenderer.refreshHighlightedResult();
 		}
 		if (expandUnchanged) this.loadFilesIfNecessary();
 		this.hunksRenderer.setOptions(this.getHunksRendererOptions(this.options));
 		this.syncInteractionOptions();
-		this.hunksRenderer.setLineAnnotations(this.lineAnnotations);
+		this.hunksRenderer.setLineAnnotations(this.getLatestAnnotations());
 		const { disableErrorHandling = false, disableFileHeader = false } = this.options;
 		if (disableFileHeader) {
 			if (this.headerElement != null) {
 				this.headerElement.remove();
 				this.headerElement = void 0;
-				this.lastRenderedHeaderHTML = void 0;
+				this.headerCache.lastRenderedHTML = void 0;
 			}
 			this.clearHeaderSlots();
 		}
@@ -521,38 +664,42 @@ var FileDiff = class {
 			this.removeRenderedCode();
 			this.clearAuxiliaryNodes();
 			try {
-				const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, EMPTY_RENDER_RANGE);
+				const hunksResult = this.hunksRenderer.renderDiff(latestDiff, EMPTY_RENDER_RANGE);
 				if (hunksResult != null) this.applyThemeState(fileContainer, hunksResult.themeStyles, themeType, hunksResult.baseThemeType);
-				if (hunksResult?.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer);
+				if (hunksResult?.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer, hunksResult.fileDiff);
 				this.renderSeparators([]);
+				this.renderedDiff = hunksResult?.fileDiff ?? latestDiff;
 				this.injectUnsafeCSS();
 			} catch (error) {
 				if (disableErrorHandling) throw error;
 				console.error(error);
 				if (error instanceof Error) this.applyErrorToDOM(error, fileContainer);
 			}
+			this.finalizeRender();
 			if (!preventEmit) this.emitPostRender();
 			return true;
 		}
 		try {
 			const pre = this.getOrCreatePreNode(fileContainer);
-			if (!(this.canPartiallyRender(forceRender, annotationsChanged, filesDidChange || diffDidChange || themeChanged) && this.applyPartialRender({
+			if (!(this.canPartiallyRender(forceRender, annotationsChanged, filesDidChange || diffDidChange || themeChanged || !areDiffTargetsEqual(this.renderedDiff, latestDiff)) && this.applyPartialRender({
+				fileDiff: latestDiff,
 				previousRenderRange,
 				renderRange: nextRenderRange
 			}))) {
-				const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, nextRenderRange);
+				const hunksResult = this.hunksRenderer.renderDiff(latestDiff, nextRenderRange);
 				if (hunksResult == null) {
-					if (this.workerManager?.isInitialized() === false) this.workerManager.initialize().then(() => this.rerender());
+					if (this.workerManager?.isInitialized() === false && this.workerManager.isWorkingPool()) this.workerManager.initialize().catch(() => {}).then(() => this.rerender());
 					return false;
 				}
 				this.applyThemeState(fileContainer, hunksResult.themeStyles, themeType, hunksResult.baseThemeType);
-				if (hunksResult.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer);
+				if (hunksResult.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer, hunksResult.fileDiff);
 				if (hunksResult.additionsContentAST != null || hunksResult.deletionsContentAST != null || hunksResult.unifiedContentAST != null) this.applyHunksToDOM(pre, hunksResult);
 				else if (this.pre != null) {
 					this.pre.remove();
 					this.pre = void 0;
 				}
 				this.renderSeparators(hunksResult.hunkData);
+				this.renderedDiff = hunksResult.fileDiff;
 			}
 			this.applyBuffers(pre, nextRenderRange);
 			this.injectUnsafeCSS();
@@ -560,6 +707,7 @@ var FileDiff = class {
 			this.renderGutterUtility();
 			this.managersDirty = true;
 			if (!deferManagers) this.flushManagers();
+			this.finalizeRender();
 			if (this.editor != null) this.syncRenderViewToEditor();
 		} catch (error) {
 			if (disableErrorHandling) throw error;
@@ -569,6 +717,7 @@ var FileDiff = class {
 		if (!preventEmit) this.emitPostRender();
 		return true;
 	}
+	finalizeRender() {}
 	emitPostRender(unmount = false) {
 		const { fileContainer, options: { onPostRender } } = this;
 		if (unmount) {
@@ -583,22 +732,49 @@ var FileDiff = class {
 		this.mounted = true;
 		onPostRender?.(fileContainer, this, phase);
 	}
-	get fileDiffCache() {
-		return this.hunksRenderer.diffCache ?? this.fileDiff;
+	getLatestDiff(fileDiff = this.fileDiff) {
+		return this.editSession?.diff ?? fileDiff;
+	}
+	getRenderedDiff() {
+		return this.renderedDiff;
 	}
 	syncRenderViewToEditor() {
-		const editor = this.editor;
-		const fileContainer = this.fileContainer;
-		const fileDiff = this.fileDiffCache;
-		const lineAnnotations = this.lineAnnotations;
+		const { editor, fileContainer } = this;
+		const lineAnnotations = this.getLatestAnnotations();
 		const renderRange = this.computeEditorRenderRange(this.renderRange);
-		if (editor != null && fileContainer != null && fileDiff != null && !fileDiff.isPartial) this.hunksRenderer.initializeHighlighter().then((highlighter) => {
-			if (!this.enabled || this.editor !== editor || this.fileContainer !== fileContainer || this.fileDiffCache !== fileDiff) return;
-			editor.__syncRenderView(highlighter, fileContainer, fileDiff, lineAnnotations, renderRange);
+		const fileDiff = this.getLatestDiff();
+		if (editor == null || fileContainer == null || fileDiff == null || fileDiff.isPartial) return;
+		const sync = (highlighter) => {
+			if (!this.enabled || this.editor !== editor || this.fileContainer !== fileContainer || this.getLatestDiff() !== fileDiff) return;
+			const replacement = this.editSession?.outgoingDiff;
+			const externalDiff = this.fileDiff;
+			const externalDocument = replacement != null && externalDiff != null && replacement !== fileDiff;
+			const resetHistory = externalDocument ? shouldResetUndoState(replacement, externalDiff) : false;
+			editor.__syncRenderView({
+				highlighter,
+				fileContainer,
+				fileDiff,
+				lineAnnotations,
+				renderRange,
+				externalDocument,
+				resetHistory
+			});
+		};
+		const theme = this.getTheme();
+		const lang = fileDiff.lang ?? getFiletypeFromFileName(fileDiff.name);
+		const highlighter = getHighlighterIfLoaded({
+			theme,
+			lang
 		});
+		if (highlighter != null) sync(highlighter);
+		else getSharedHighlighter({
+			themes: getThemes(theme),
+			langs: ["text", lang],
+			preferredHighlighter: this.workerManager?.getPreferredHighlighter() ?? this.options.preferredHighlighter
+		}).then(sync);
 	}
 	computeEditorRenderRange(renderRange) {
-		const fileDiff = this.fileDiffCache;
+		const fileDiff = this.getLatestDiff();
 		if (renderRange == null || fileDiff == null || isDefaultRenderRange(renderRange)) return renderRange;
 		const { diffStyle = "split", expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
 		let firstLineNumber;
@@ -628,37 +804,172 @@ var FileDiff = class {
 			totalLines: lastLineNumber - firstLineNumber + 1
 		};
 	}
-	attachEditor(editor) {
-		if (this.type !== "file-diff") throw new Error(`FileDiff.attachEditor: cannot attach an editor to a "${this.type}" diff`);
-		this.editor?.cleanUp();
-		this.editor = editor;
-		this.hunksRenderer.beginEditSession();
-		if (this.fileDiff?.isPartial === true) this.loadFilesIfNecessary();
-		if (this.hunksRenderer.editorRenderReady()) this.syncRenderViewToEditor();
-		else this.rerender();
-		return (recycle) => {
+	/** @internal The editor applied or edited past the pending external replacement. */
+	__acknowledgeDocumentUpdate() {
+		if (this.editSession != null) this.editSession.outgoingDiff = void 0;
+	}
+	/** @internal Settle annotations locally. */
+	__acceptEditorChange(event) {
+		const { lineAnnotations } = event;
+		if (lineAnnotations != null) this.syncEditSessionAnnotationsFromEditor(lineAnnotations);
+	}
+	emitEditChange(event) {
+		const { onEditChange } = this.options;
+		onEditChange?.(event);
+	}
+	/**
+	* @internal Capture the current diff session, or return `undefined` when no
+	* complete compatible session exists.
+	*
+	* When `clone` is true, the returned lines and hunks are copied.
+	*/
+	__captureDocumentSessionState(clone = true) {
+		let { fileDiff, editSession: { diff: sessionDiff, outgoingDiff } = {} } = this;
+		if (outgoingDiff != null && fileDiff != null) {
+			if (!fileDiff.isPartial && shouldResetUndoState(outgoingDiff, fileDiff)) return;
+			sessionDiff = outgoingDiff;
+		}
+		if (sessionDiff == null || sessionDiff.isPartial) return;
+		return {
+			diffSession: {
+				oldFile: sessionDiff.type !== "new" ? {
+					name: sessionDiff.prevName ?? sessionDiff.name,
+					lines: clone ? [...sessionDiff.deletionLines] : sessionDiff.deletionLines
+				} : null,
+				type: sessionDiff.type,
+				hunks: clone ? cloneHunks(sessionDiff.hunks) : sessionDiff.hunks
+			},
+			hasChanges: sessionDiff.editSessionDirty === true
+		};
+	}
+	/** @internal Associate this component with its editor for a render lifecycle. */
+	__attachEditor(editor) {
+		if (this.type !== "file-diff") throw new Error(`FileDiff.__attachEditor: cannot attach an editor to a "${this.type}" diff`);
+		if (this.editor != null) throw new Error("FileDiff.__attachEditor: an editor is already attached");
+		const detach = () => {
 			this.editor = void 0;
-			if (recycle !== true) this.finishEditSession();
+			this.finishEditSession();
 		};
+		try {
+			this.resumeEditorRendering(editor);
+			return detach;
+		} catch (error) {
+			detach();
+			throw error;
+		}
+	}
+	/** @internal Resume rendering for the editor already associated with this component. */
+	__resumeEditor(editor) {
+		if (this.editor !== editor) throw new Error("FileDiff.__resumeEditor: editor association changed");
+		this.resumeEditorRendering(editor);
+	}
+	resumeEditorRendering(editor) {
+		const { fileDiff: externalDiff } = this;
+		const pendingReplacement = this.editSession?.outgoingDiff;
+		if (pendingReplacement != null && externalDiff != null && !externalDiff.isPartial && this.editSession?.diff === pendingReplacement) this.installEditSession(externalDiff);
+		const initialExternalDiff = this.editSession == null && externalDiff != null && !externalDiff.isPartial ? externalDiff : void 0;
+		if (initialExternalDiff != null) this.installEditSession(initialExternalDiff, editor.__getDocumentContents(getAdditionFile(initialExternalDiff)), editor.__getDocumentSessionState());
+		else if (this.editSession != null) this.hunksRenderer.beginEditSession(this.editSession.diff);
+		this.editor = editor;
+		if (this.fileDiff?.isPartial === true) this.loadFilesIfNecessary();
+		const editSessionDiff = this.editSession?.diff;
+		if (this.hunksRenderer.editorRenderReady()) {
+			if (editSessionDiff != null && this.hunksRenderer.diffCache === editSessionDiff) this.renderedDiff = editSessionDiff;
+			this.syncRenderViewToEditor();
+		} else this.rerender();
 	}
 	finishEditSession() {
 		this.hunksRenderer.endEditSession();
-		this.completeEditSession();
+		this.finalizeEditSessionHunks();
 	}
 	/**
-	* Run the genuine session-end recompute: restore recompute-shaped hunks (a
+	* @internal
+	*
+	* Ends the edit session and settles which diff this component renders.
+	* Requires the editor to be detached first. Does nothing when no session
+	* exists, so callers can invoke it again safely after it has settled.
+	*
+	* `onEditComplete` receives the completed diff, current external diff,
+	* complete file pair, and both annotation collections even when the final
+	* text is unchanged. In `install` mode, accepting installs the completed diff
+	* and its annotations; rejecting or having no handler restores the external
+	* values. `discard` mode always restores the external values. An accepted
+	* diff cannot reuse the replaced diff's `cacheKey`.
+	*/
+	__completeEditSession(editor, mode) {
+		this.settleEditSession(mode === "install", editor);
+	}
+	settleEditSession(installResult, editor) {
+		const { editSession, fileDiff: externalDiff, lineAnnotations: externalAnnotations } = this;
+		if (editSession == null || externalDiff == null) return;
+		const { diff: editSessionDiff, annotations: editSessionAnnotations } = editSession;
+		if (this.editor != null) throw new Error("FileDiff.__completeEditSession: detach the editor before completing the session");
+		this.hunksRenderer.endEditSession();
+		this.finalizeEditSessionHunks();
+		const sessionAnnotationsCurrent = editSessionAnnotations?.current;
+		let acceptedDiff;
+		let acceptedOldFile = null;
+		let acceptedNewFile = null;
+		let failed = false;
+		let failure;
+		if (editor == null) throw new Error("FileDiff.__completeEditSession: editor is required for completion");
+		const completedDiff = cloneFileDiffMetadata(editSessionDiff);
+		const newFile = {
+			name: completedDiff.name,
+			contents: completedDiff.additionLines.join("")
+		};
+		if (completedDiff.lang != null) newFile.lang = completedDiff.lang;
+		const event = {
+			fileDiff: completedDiff,
+			editor,
+			originalFileDiff: externalDiff,
+			oldFile: completedDiff.type === "new" ? null : {
+				name: completedDiff.prevName ?? completedDiff.name,
+				contents: completedDiff.deletionLines.join("")
+			},
+			newFile,
+			lineAnnotations: sessionAnnotationsCurrent,
+			originalLineAnnotations: externalAnnotations
+		};
+		Object.freeze(event);
+		try {
+			editor.__emitEditComplete(event);
+			if (this.options.onEditComplete?.(event) === "accept") {
+				if (completedDiff.cacheKey != null && completedDiff.cacheKey === externalDiff.cacheKey) throw new Error("FileDiff.__completeEditSession: an accepted diff must not reuse the replaced diff cacheKey");
+				acceptedDiff = completedDiff;
+				acceptedOldFile = event.oldFile;
+				acceptedNewFile = event.newFile;
+			}
+		} catch (error) {
+			failed = true;
+			failure = error;
+		}
+		if (installResult && acceptedDiff != null) {
+			this.fileDiff = acceptedDiff;
+			if (this.additionFile != null) {
+				this.deletionFile = acceptedOldFile;
+				this.additionFile = acceptedNewFile;
+			}
+			if (sessionAnnotationsCurrent != null) this.lineAnnotations = sessionAnnotationsCurrent;
+		}
+		this.editSession = void 0;
+		if (installResult && this.fileContainer != null) this.rerender();
+		if (failed) throw failure;
+	}
+	/**
+	* Run the session-end recompute: restore recompute-shaped hunks (a
 	* context-only region collapses away, boundaries re-derive), preserve
 	* expansion state best-effort via old-side anchors, and repaint through
 	* the session render path — which also invalidates virtualized layout,
 	* since nothing else does at exit now that editing does not flip
 	* expandUnchanged. Marker-guarded and idempotent; CodeView also calls this
-	* when reaping a session whose detach closure was consumed by a recycle.
+	* when ending a session whose detach closure was consumed by a recycle.
 	* Safe on a cleaned-up instance: the recompute is pure metadata work and
 	* the deferred rerender is enabled-guarded. Returns true when a recompute
 	* ran.
 	*/
-	completeEditSession() {
-		const fileDiff = this.fileDiffCache;
+	finalizeEditSessionHunks() {
+		const fileDiff = this.getLatestDiff();
 		if (fileDiff == null || fileDiff.editSessionDirty !== true) return false;
 		const { collapsedContextThreshold = 1 } = this.options;
 		const anchors = captureExpansionAnchors(fileDiff, this.hunksRenderer.getExpandedHunksMap(), collapsedContextThreshold);
@@ -669,22 +980,20 @@ var FileDiff = class {
 		return true;
 	}
 	applyDocumentChange(textDocument, newLineAnnotations) {
+		const editSessionDiff = this.editSession?.diff;
+		if (editSessionDiff == null) throw new Error("FileDiff.applyDocumentChange: requires an active edit session");
+		this.detachAdditionLines();
+		this.hunksRenderer.beginEditSession(editSessionDiff);
 		this.hunksRenderer.applyDocumentChange(textDocument);
-		const fileDiff = this.hunksRenderer.diffCache;
-		if (fileDiff != null) {
-			const cacheKey = this.fileDiff?.cacheKey;
-			if (cacheKey != null && fileDiff.cacheKey == null) fileDiff.cacheKey = cacheKey;
-			this.fileDiff = fileDiff;
-		}
-		if (newLineAnnotations !== void 0 && newLineAnnotations !== this.lineAnnotations) {
-			this.setLineAnnotations(newLineAnnotations);
-			this.hunksRenderer.setLineAnnotations(this.lineAnnotations);
-			this.renderAnnotations();
-		}
+		if (newLineAnnotations != null) this.syncEditSessionAnnotationsFromEditor(newLineAnnotations);
 		this.rerender();
 		this.interactionManager.setSelectionDirty();
 	}
 	updateRenderCache(dirtyLines, themeType, options = {}) {
+		const editSessionDiff = this.editSession?.diff;
+		if (editSessionDiff == null) throw new Error("FileDiff.updateRenderCache: requires an active edit session");
+		this.detachAdditionLines();
+		this.hunksRenderer.beginEditSession(editSessionDiff);
 		const { shouldRefreshDiffsView, lineCountChangeInFlight } = options;
 		if (this.hunksRenderer.updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight)) {
 			if (this.refreshViewTimeout != null) {
@@ -706,8 +1015,13 @@ var FileDiff = class {
 			}, 150);
 		}
 	}
+	detachAdditionLines() {
+		const editSessionDiff = this.editSession?.diff;
+		const { fileDiff } = this;
+		if (editSessionDiff != null && (editSessionDiff.additionLines === fileDiff?.additionLines || editSessionDiff.additionLines === editSessionDiff.deletionLines)) editSessionDiff.additionLines = [...editSessionDiff.additionLines];
+	}
 	isLineRenderable(lineNumber) {
-		const fileDiff = this.fileDiffCache;
+		const fileDiff = this.getRenderedDiff();
 		if (fileDiff == null) return true;
 		const { expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
 		return isAdditionLineRenderable({
@@ -718,7 +1032,7 @@ var FileDiff = class {
 		});
 	}
 	getNearestRenderableLine(lineNumber, direction) {
-		const fileDiff = this.fileDiffCache;
+		const fileDiff = this.getRenderedDiff();
 		if (fileDiff == null) return lineNumber;
 		const { expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
 		return getNearestRenderableAdditionLine({
@@ -730,7 +1044,7 @@ var FileDiff = class {
 		});
 	}
 	revealLine(lineNumber) {
-		const fileDiff = this.fileDiffCache;
+		const fileDiff = this.getRenderedDiff();
 		const { expandUnchanged = false, collapsedContextThreshold = 1, expansionLineCount = 100 } = this.options;
 		if (fileDiff == null || fileDiff.isPartial || expandUnchanged) return false;
 		const expandedHunks = this.hunksRenderer.getExpandedHunksMap();
@@ -865,7 +1179,7 @@ var FileDiff = class {
 		this.hasAdoptedThemeCSS = false;
 		this.unsafeCSSStyle = void 0;
 		this.appliedUnsafeCSS = void 0;
-		this.lastRenderedHeaderHTML = void 0;
+		this.headerCache.lastRenderedHTML = void 0;
 		this.lastRowCount = void 0;
 		this.mounted = false;
 	}
@@ -909,15 +1223,17 @@ var FileDiff = class {
 		}
 		const staleAnnotations = new Map(this.annotationCache);
 		const { renderAnnotation } = this.options;
-		if (renderAnnotation != null && this.lineAnnotations.length > 0) for (const [index, annotation] of this.lineAnnotations.entries()) {
-			const id = `${index}-${getLineAnnotationName(annotation)}`;
+		const lineAnnotations = this.getLatestAnnotations();
+		if (renderAnnotation != null && lineAnnotations.length > 0) for (const [index, annotation] of lineAnnotations.entries()) {
+			const name = this.getAnnotationSlotName(annotation);
+			const id = `${index}-${name}`;
 			let cache = this.annotationCache.get(id);
 			if (cache == null || !areDiffLineAnnotationsEqual(annotation, cache.annotation)) {
 				cache?.element.remove();
 				const content = renderAnnotation(annotation);
 				if (content == null) continue;
 				cache = {
-					element: createAnnotationWrapperNode(getLineAnnotationName(annotation)),
+					element: createAnnotationWrapperNode(name),
 					annotation
 				};
 				cache.element.appendChild(content);
@@ -958,7 +1274,7 @@ var FileDiff = class {
 		if (containerChanged) this.emitPostRender(true);
 		this.fileContainer = nextContainer;
 		if (previousContainer != null && containerChanged) {
-			this.lastRenderedHeaderHTML = void 0;
+			this.headerCache.lastRenderedHTML = void 0;
 			this.headerElement = void 0;
 		}
 		if (parentNode != null && this.fileContainer.parentNode !== parentNode) parentNode.appendChild(this.fileContainer);
@@ -1017,14 +1333,15 @@ var FileDiff = class {
 			else if (child.hasAttribute("data-additions")) this.codeAdditions = child;
 		}
 	}
-	applyHeaderToDOM(headerAST, container) {
+	applyHeaderToDOM(headerAST, container, fileDiff) {
 		this.cleanupErrorWrapper();
 		this.placeHolder?.remove();
 		this.placeHolder = void 0;
-		const { fileDiff } = this;
-		const headerHTML = this.cachedHeaderHTML ?? toHtml(headerAST);
-		this.cachedHeaderHTML = headerHTML;
-		if (headerHTML !== this.lastRenderedHeaderHTML) {
+		const { headerCache: { fileDiff: cachedHeaderDiff, html: cachedHeaderHTML, lastRenderedHTML } } = this;
+		const headerHTML = (fileDiff !== this.editSession?.diff && areDiffTargetsEqual(cachedHeaderDiff, fileDiff) ? cachedHeaderHTML : void 0) ?? toHtml(headerAST);
+		this.headerCache.html = headerHTML;
+		this.headerCache.fileDiff = fileDiff;
+		if (headerHTML !== lastRenderedHTML) {
 			const tempDiv = document.createElement("div");
 			tempDiv.innerHTML = headerHTML;
 			const newHeader = tempDiv.firstElementChild;
@@ -1032,9 +1349,9 @@ var FileDiff = class {
 			if (this.headerElement != null) container.shadowRoot?.replaceChild(newHeader, this.headerElement);
 			else container.shadowRoot?.prepend(newHeader);
 			this.headerElement = newHeader;
-			this.lastRenderedHeaderHTML = headerHTML;
+			this.headerCache.lastRenderedHTML = headerHTML;
 		}
-		if (this.isContainerManaged || fileDiff == null) return;
+		if (this.isContainerManaged) return;
 		const { renderCustomHeader, renderHeaderPrefix, renderHeaderFilenameSuffix, renderHeaderMetadata } = this.options;
 		if (renderCustomHeader != null) {
 			const content = renderCustomHeader(fileDiff) ?? void 0;
@@ -1056,6 +1373,10 @@ var FileDiff = class {
 		this.headerCustom?.remove();
 		this.headerCustom = void 0;
 	}
+	clearReusableHeader() {
+		this.headerCache.html = void 0;
+		this.headerCache.fileDiff = void 0;
+	}
 	clearHeaderSlots() {
 		this.headerPrefix?.remove();
 		this.headerFilenameSuffix?.remove();
@@ -1107,7 +1428,7 @@ var FileDiff = class {
 	applyThemeState(container, themeStyles, themeType, baseThemeType) {
 		const shadowRoot = container.shadowRoot ?? container.attachShadow({ mode: "open" });
 		const effectiveThemeType = baseThemeType ?? themeType;
-		const currentTheme = this.options.theme ?? DEFAULT_THEMES;
+		const currentTheme = this.getTheme();
 		const theme = typeof currentTheme === "string" ? currentTheme : { ...currentTheme };
 		const scrollbarGutter = getMeasuredScrollbarGutter(shadowRoot);
 		if (this.themeCSSStyle?.parentNode === shadowRoot && this.appliedThemeCSS?.themeStyles === themeStyles && this.appliedThemeCSS.themeType === effectiveThemeType && this.appliedThemeCSS.scrollbarGutter === scrollbarGutter) {
@@ -1235,7 +1556,7 @@ var FileDiff = class {
 		else if (shouldReplace) pre.replaceChildren(...codeElements);
 		this.lastRowCount = result.rowCount;
 	}
-	applyPartialRender({ previousRenderRange, renderRange }) {
+	applyPartialRender({ fileDiff, previousRenderRange, renderRange }) {
 		const { pre, codeUnified, codeAdditions, codeDeletions, options: { diffStyle = "split" } } = this;
 		if (pre == null || previousRenderRange == null || renderRange == null || !Number.isFinite(previousRenderRange.totalLines) || !Number.isFinite(renderRange.totalLines) || this.lastRowCount == null) return false;
 		const codeElements = this.getCodeColumns(diffStyle, codeUnified, codeDeletions, codeAdditions);
@@ -1262,8 +1583,8 @@ var FileDiff = class {
 		if (this.lastRowCount < trimResult) throw new Error("FileDiff.applyPartialRender: trimmed beyond DOM row count");
 		let rowCount = this.lastRowCount - trimResult;
 		const renderChunk = (startingLine, totalLines) => {
-			if (totalLines <= 0 || this.fileDiff == null) return;
-			return this.hunksRenderer.renderDiff(this.fileDiff, {
+			if (totalLines <= 0) return;
+			return this.hunksRenderer.renderDiff(fileDiff, {
 				startingLine,
 				totalLines,
 				bufferBefore: 0,
@@ -1280,6 +1601,7 @@ var FileDiff = class {
 			else if (diffStyle === "split" && Array.isArray(codeElements)) this.insertPartialHTML(diffStyle, codeElements, result, insertPosition);
 			else throw new Error("FileDiff.applyPartialRender.applyChunk: invalid chunk application");
 			rowCount += result.rowCount;
+			this.renderedDiff = result.fileDiff;
 		};
 		this.cleanupErrorWrapper();
 		applyChunk(prependResult, "afterbegin");
@@ -1302,8 +1624,9 @@ var FileDiff = class {
 		} else throw new Error("FileDiff.insertPartialHTML: Invalid argument composition");
 	}
 	refreshSplitDiffView() {
-		if (this.options.diffStyle !== "split") return;
-		const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, this.renderRange);
+		const fileDiff = this.getLatestDiff();
+		if (this.options.diffStyle !== "split" || fileDiff == null) return;
+		const hunksResult = this.hunksRenderer.renderDiff(fileDiff, this.renderRange);
 		if (hunksResult == null) return;
 		const columns = this.getCodeColumns("split", this.codeUnified, this.codeDeletions, this.codeAdditions);
 		if (!Array.isArray(columns)) return;
@@ -1320,10 +1643,12 @@ var FileDiff = class {
 		};
 		applyLineType("deletions", columns[0]);
 		applyLineType("additions", columns[1]);
+		this.renderedDiff = hunksResult.fileDiff;
 	}
 	refreshUnifiedDiffView() {
-		if (this.options.diffStyle !== "unified") return;
-		const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, this.renderRange);
+		const fileDiff = this.getLatestDiff();
+		if (this.options.diffStyle !== "unified" || fileDiff == null) return;
+		const hunksResult = this.hunksRenderer.renderDiff(fileDiff, this.renderRange);
 		if (hunksResult == null) return;
 		const columns = this.getCodeColumns("unified", this.codeUnified, this.codeDeletions, this.codeAdditions);
 		if (columns == null || Array.isArray(columns)) return;
@@ -1336,6 +1661,7 @@ var FileDiff = class {
 				this.applyRowSpan("unified", columns, hunksResult.rowCount);
 				this.lastRowCount = hunksResult.rowCount;
 			}
+			this.renderedDiff = hunksResult.fileDiff;
 		};
 		if (this.shouldGuardRebuildScroll()) guardWebKitScrollDuringRebuild(this.pre, applyColumns);
 		else applyColumns();
@@ -1626,6 +1952,13 @@ var FileDiff = class {
 		this.errorWrapper = void 0;
 	}
 };
+function getAdditionFile(fileDiff) {
+	return {
+		name: fileDiff.name,
+		lang: fileDiff.lang,
+		contents: fileDiff.additionLines.join("")
+	};
+}
 function areOptionalFilesEqual(fileA, fileB) {
 	if (fileA == null || fileB == null) return fileA == null && fileB == null;
 	return areFilesEqual(fileA, fileB);