@pierre/diffs 1.3.6 → 1.4.1

package/dist/components/VirtualizedFileDiff.js

@@ -1,23 +1,25 @@
 import "../constants.js";
 import { areObjectsEqual } from "../utils/areObjectsEqual.js";
 import { areOptionsEqual } from "../utils/areOptionsEqual.js";
-import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
 import { computeVirtualFileMetrics, getVirtualFileHeaderRegion, getVirtualFilePaddingBottom } from "../utils/computeVirtualFileMetrics.js";
-import { getExpandedRegion, getLeadingHunkSeparatorLayout, getTrailingExpandedRegion, getTrailingHunkSeparatorLayout, isAdditionLineRenderable } from "../utils/virtualDiffLayout.js";
-import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { FILE_ANNOTATION_DOM_KEY, includesFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
 import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
+import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { awaitWithTimeout } from "../utils/awaitWithTimeout.js";
+import { getExpandedRegion, getLeadingHunkSeparatorLayout, getTrailingExpandedRegion, getTrailingHunkSeparatorLayout, isAdditionLineRenderable } from "../utils/virtualDiffLayout.js";
 import { computeEstimatedDiffHeights } from "../utils/computeEstimatedDiffHeights.js";
 import { getDiffFileInput } from "../utils/getDiffFileInput.js";
 import { hydratePartialDiff } from "../utils/hydratePartialDiff.js";
 import { iterateOverDiff } from "../utils/iterateOverDiff.js";
+import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
 import { FileDiff } from "./FileDiff.js";
 //#region src/components/VirtualizedFileDiff.ts
 const VIRTUALIZED_FILE_DIFF_LAYOUT_CHECKPOINT_INTERVAL = 3e3;
+const NO_GHOST_TEXT_ROWS = /* @__PURE__ */ new Map();
 let instanceId = -1;
 var VirtualizedFileDiff = class extends FileDiff {
 	__id = `little-virtualized-file-diff:${++instanceId}`;
+	renderType = "virtualized";
 	top;
 	height = 0;
 	metrics;
@@ -28,7 +30,9 @@ var VirtualizedFileDiff = class extends FileDiff {
 		estimatedUnifiedHeight: void 0,
 		checkpoints: [],
 		totalLines: 0,
-		fileAnnotationHeight: 0
+		fileAnnotationHeight: 0,
+		ghostTextRows: NO_GHOST_TEXT_ROWS,
+		ghostTextRowsByIndex: /* @__PURE__ */ new Map()
 	};
 	isVisible = false;
 	isSetup = false;
@@ -36,9 +40,9 @@ var VirtualizedFileDiff = class extends FileDiff {
 	layoutDirty = true;
 	forceRenderOverride;
 	currentCollapsed;
-	currentExpandUnchanged;
 	pendingHydratedDiff;
 	pendingExpansions;
+	pendingRender;
 	constructor(options, virtualizer, metrics, workerManager, isContainerManaged = false) {
 		super(options, workerManager, isContainerManaged);
 		this.virtualizer = virtualizer;
@@ -54,10 +58,17 @@ var VirtualizedFileDiff = class extends FileDiff {
 		if (this.syncLineAnnotations(lineAnnotations)) this.resetLayoutCache({ includeEstimatedHeights: false });
 	}
 	syncLineAnnotations(lineAnnotations) {
-		if (lineAnnotations == null || lineAnnotations === this.lineAnnotations || lineAnnotations.length === 0 && this.lineAnnotations.length === 0) return false;
+		if (lineAnnotations == null || !this.isNewAnnotations(lineAnnotations) || lineAnnotations.length === 0 && this.getLatestAnnotations().length === 0) return false;
 		super.setLineAnnotations(lineAnnotations);
 		return true;
 	}
+	syncEditSessionAnnotationsFromEditor(lineAnnotations) {
+		if (super.syncEditSessionAnnotationsFromEditor(lineAnnotations)) {
+			this.resetLayoutCache({ includeEstimatedHeights: false });
+			return true;
+		}
+		return false;
+	}
 	setFileAnnotationHeight(nextHeight) {
 		const previousHeight = this.cache.fileAnnotationHeight;
 		if (nextHeight === previousHeight) return false;
@@ -65,9 +76,10 @@ var VirtualizedFileDiff = class extends FileDiff {
 		this.cache.measuredHeightDeltaTotal += nextHeight - previousHeight;
 		return true;
 	}
-	hasFileAnnotations(fileDiff = this.fileDiff) {
-		if (fileDiff == null || !includesFileAnnotations(this.lineAnnotations)) return false;
-		return this.lineAnnotations.some((annotation) => {
+	hasFileAnnotations(fileDiff) {
+		const lineAnnotations = this.getLatestAnnotations();
+		if (!includesFileAnnotations(lineAnnotations)) return false;
+		return lineAnnotations.some((annotation) => {
 			if (annotation.lineNumber !== 0) return false;
 			if (fileDiff.type === "new") return annotation.side === "additions";
 			if (fileDiff.type === "deleted") return annotation.side === "deletions";
@@ -102,8 +114,10 @@ var VirtualizedFileDiff = class extends FileDiff {
 	resetLayoutCache({ forceSimpleRecompute = false, includeEstimatedHeights = false, resetRenderRange = true } = {}) {
 		this.layoutDirty = true;
 		this.cache.fileAnnotationHeight = 0;
-		if (this.cache.heightDeltas.size > 0) this.cache.heightDeltas.clear();
-		if (this.cache.measuredHeightDeltaTotal !== 0) this.cache.measuredHeightDeltaTotal = 0;
+		this.cache.heightDeltas.clear();
+		this.cache.measuredHeightDeltaTotal = 0;
+		this.cache.ghostTextRows = NO_GHOST_TEXT_ROWS;
+		if (this.cache.ghostTextRowsByIndex.size > 0) this.cache.ghostTextRowsByIndex.clear();
 		this.invalidateDerivedLayoutCache(includeEstimatedHeights, resetRenderRange);
 		if (forceSimpleRecompute && this.isSimpleMode()) this.computeApproximateSize();
 	}
@@ -117,19 +131,49 @@ var VirtualizedFileDiff = class extends FileDiff {
 		}
 		if (this.renderRange != null && resetRenderRange) this.renderRange = void 0;
 	}
+	applyGhostTextRows(fileDiff, ghostTextRows) {
+		const { cache: { heightDeltas, ghostTextRows: folded, ghostTextRowsByIndex: previous }, metrics: { lineHeight } } = this;
+		if (folded === ghostTextRows) return false;
+		const diffStyle = this.getDiffStyle();
+		const next = /* @__PURE__ */ new Map();
+		for (const [line, rows] of ghostTextRows) {
+			const indexes = this.getLineIndexForDiff(fileDiff, line + 1, "additions");
+			if (indexes == null) continue;
+			next.set(diffStyle === "split" ? indexes[1] : indexes[0], rows);
+		}
+		let changed = false;
+		for (const rowIndex of /* @__PURE__ */ new Set([...previous.keys(), ...next.keys()])) {
+			const delta = ((next.get(rowIndex) ?? 0) - (previous.get(rowIndex) ?? 0)) * lineHeight;
+			if (delta === 0) continue;
+			const nextDelta = (heightDeltas.get(rowIndex) ?? 0) + delta;
+			if (nextDelta === 0) heightDeltas.delete(rowIndex);
+			else heightDeltas.set(rowIndex, nextDelta);
+			this.cache.measuredHeightDeltaTotal += delta;
+			changed = true;
+		}
+		this.cache.ghostTextRows = ghostTextRows;
+		this.cache.ghostTextRowsByIndex = next;
+		return changed;
+	}
 	reconcileHeights() {
 		let hasHeightChange = false;
-		const { overflow = "scroll" } = this.options;
-		if (this.fileContainer == null || this.fileDiff == null) {
+		const { options: { overflow = "scroll" }, cache: { ghostTextRowsByIndex }, metrics: { lineHeight } } = this;
+		const fileDiff = this.getRenderedDiff();
+		if (this.fileContainer == null || fileDiff == null) {
 			if (this.height !== 0) hasHeightChange = true;
 			this.height = 0;
 			return hasHeightChange;
 		}
 		this.top = this.getVirtualizedTop();
-		if (overflow === "scroll" && this.lineAnnotations.length === 0 && !this.isResizeDebuggingEnabled()) return hasHeightChange;
+		hasHeightChange = this.applyGhostTextRows(fileDiff, this.editor?.__getGhostTextRows() ?? NO_GHOST_TEXT_ROWS);
+		const lineAnnotations = this.getLatestAnnotations();
+		if (overflow === "scroll" && lineAnnotations.length === 0 && !this.isResizeDebuggingEnabled()) {
+			if (hasHeightChange) this.computeApproximateSize(true);
+			return hasHeightChange;
+		}
 		const diffStyle = this.getDiffStyle();
 		const codeGroups = diffStyle === "split" ? [this.codeDeletions, this.codeAdditions] : [this.codeUnified];
-		const hasFileAnnotations = this.hasFileAnnotations(this.fileDiff);
+		const hasFileAnnotations = this.hasFileAnnotations(fileDiff);
 		if (this.renderRange != null && hasFileAnnotations && shouldRenderFileAnnotations(this.renderRange)) {
 			const nextFileAnnotationHeight = measureFileAnnotationHeight(codeGroups) ?? 0;
 			if (this.setFileAnnotationHeight(nextFileAnnotationHeight)) hasHeightChange = true;
@@ -138,12 +182,15 @@ var VirtualizedFileDiff = class extends FileDiff {
 			if (codeGroup == null) continue;
 			const content = codeGroup.children[1];
 			if (!(content instanceof HTMLElement)) continue;
+			const skipsGhostRows = diffStyle === "split" && codeGroup === this.codeDeletions;
 			for (const line of content.children) {
 				if (!(line instanceof HTMLElement)) continue;
 				const lineIndexAttr = line.dataset.lineIndex;
 				if (lineIndexAttr == null) continue;
 				const lineIndex = parseLineIndex(lineIndexAttr, diffStyle);
-				let measuredHeight = line.getBoundingClientRect().height;
+				const ghostRows = ghostTextRowsByIndex.get(lineIndex) ?? 0;
+				if (skipsGhostRows && ghostRows > 0) continue;
+				let measuredHeight = line.getBoundingClientRect().height + ghostRows * lineHeight;
 				let hasMetadata = false;
 				if (line.nextElementSibling instanceof HTMLElement && ("lineAnnotation" in line.nextElementSibling.dataset || "noNewline" in line.nextElementSibling.dataset)) {
 					if ("noNewline" in line.nextElementSibling.dataset) hasMetadata = true;
@@ -171,41 +218,59 @@ var VirtualizedFileDiff = class extends FileDiff {
 		super.flushManagers();
 		if (this.lineStateRefreshPending) this.flushDeferredLineState();
 	}
-	prepareCodeViewItem(fileDiff, top, reset, lineAnnotations) {
-		const targetChanged = !areDiffTargetsEqual(this.fileDiff, fileDiff);
-		const annotationsChanged = this.syncLineAnnotations(lineAnnotations);
-		let shouldResetLayoutCache = reset?.resetDiffLayoutCache === true || targetChanged || annotationsChanged;
-		let includeEstimatedHeights = targetChanged || reset?.resetDiffLayoutCache === true && reset.includeEstimatedDiffHeights;
+	updateCodeViewLayout(fileDiff, top, reset, lineAnnotations) {
+		let resetLayoutCache = false;
+		let resetEstimatedHeights = false;
+		const { pendingExpansions, pendingHydratedDiff, options: { collapsed = false } } = this;
+		if (pendingHydratedDiff != null) {
+			this.pendingHydratedDiff = void 0;
+			if (pendingHydratedDiff.expectedDiff === fileDiff) {
+				Object.assign(fileDiff, pendingHydratedDiff.nextDiff);
+				this.setHydratedState(pendingHydratedDiff.files);
+				this.startHydratedEditSession(fileDiff);
+				this.forceRenderOverride = true;
+				resetLayoutCache = true;
+				resetEstimatedHeights = true;
+			}
+		}
+		if (pendingExpansions != null) {
+			this.pendingExpansions = void 0;
+			for (const { hunkIndex, direction, expansionLineCountOverride } of pendingExpansions) {
+				this.hunksRenderer.expandHunk(hunkIndex, direction, expansionLineCountOverride);
+				this.forceRenderOverride = true;
+				resetEstimatedHeights = true;
+			}
+		}
+		const diffChanged = this.updateExternalDiff(fileDiff, lineAnnotations);
+		const { pendingRenderDiff, layoutDiffChanged, renderedDiffChanged, annotationsChanged } = this.updatePendingRender(fileDiff, lineAnnotations);
+		if (!this.forceRenderOverride && (diffChanged || renderedDiffChanged || annotationsChanged)) this.forceRenderOverride = true;
+		if (reset?.resetDiffLayoutCache === true || layoutDiffChanged || annotationsChanged) resetLayoutCache = true;
+		if (layoutDiffChanged || reset?.resetDiffLayoutCache === true && reset.includeEstimatedDiffHeights) resetEstimatedHeights = true;
 		if (reset?.metrics != null) {
 			this.metrics = computeVirtualFileMetrics(reset.metrics);
-			shouldResetLayoutCache = true;
-			includeEstimatedHeights = true;
+			resetLayoutCache = true;
+			resetEstimatedHeights = true;
 		}
-		const { collapsed = false, expandUnchanged = false } = this.options;
 		if (this.currentCollapsed !== collapsed) {
 			this.currentCollapsed = collapsed;
-			shouldResetLayoutCache = true;
-		}
-		if (this.currentExpandUnchanged !== expandUnchanged) {
-			this.currentExpandUnchanged = expandUnchanged;
-			shouldResetLayoutCache = true;
-			includeEstimatedHeights = true;
+			resetLayoutCache = true;
 		}
-		if (shouldResetLayoutCache) this.resetLayoutCache({ includeEstimatedHeights });
-		this.fileDiff = fileDiff;
+		if (resetLayoutCache) this.resetLayoutCache({ includeEstimatedHeights: resetEstimatedHeights });
+		else if (resetEstimatedHeights) this.invalidateDerivedLayoutCache(true);
 		this.top = top;
-		this.computeApproximateSize();
+		this.computeApproximateSize(false, pendingRenderDiff);
 		return this.height;
 	}
 	getLinePosition(lineNumber, side = "additions") {
-		if (this.fileDiff == null || lineNumber < 1) return;
-		const targetLineIndexes = this.getLineIndex(lineNumber, side);
+		const fileDiff = this.getLayoutDiff();
+		if (fileDiff == null || lineNumber < 1) return;
+		const targetLineIndexes = this.getLineIndexForDiff(fileDiff, lineNumber, side);
 		if (targetLineIndexes == null) return;
 		const { disableFileHeader = false, expandUnchanged = false, collapsed = false, collapsedContextThreshold = 1 } = this.options;
 		const diffStyle = this.getDiffStyle();
 		const hunkSeparators = this.getHunkSeparatorType();
 		const targetLineIndex = diffStyle === "split" ? targetLineIndexes[1] : targetLineIndexes[0];
-		this.approximateLayoutCheckpoints();
+		this.approximateLayoutCheckpoints(fileDiff);
 		const headerRegion = getVirtualFileHeaderRegion(this.metrics, disableFileHeader);
 		const checkpoint = this.getLayoutCheckpointBeforeLineIndex(targetLineIndex);
 		let top = checkpoint?.top ?? headerRegion + this.cache.fileAnnotationHeight;
@@ -215,7 +280,7 @@ var VirtualizedFileDiff = class extends FileDiff {
 		};
 		let position;
 		iterateOverDiff({
-			diff: this.fileDiff,
+			diff: fileDiff,
 			diffStyle,
 			startingLine: checkpoint?.renderedLineIndex ?? 0,
 			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
@@ -276,17 +341,18 @@ var VirtualizedFileDiff = class extends FileDiff {
 		return this.virtualizer.type === "simple" ? this.virtualizer.getRoot() : this.virtualizer.getContainerElement();
 	}
 	getNumericScrollAnchor(localViewportTop) {
-		if (this.fileDiff == null) return;
+		const fileDiff = this.getLayoutDiff();
+		if (fileDiff == null) return;
 		const { disableFileHeader = false, expandUnchanged = false, collapsed = false, collapsedContextThreshold = 1 } = this.options;
 		if (collapsed) return;
 		const diffStyle = this.getDiffStyle();
 		const hunkSeparators = this.getHunkSeparatorType();
-		this.approximateLayoutCheckpoints();
+		this.approximateLayoutCheckpoints(fileDiff);
 		const checkpoint = this.getLayoutCheckpointBeforeTop(localViewportTop);
 		let top = checkpoint?.top ?? getVirtualFileHeaderRegion(this.metrics, disableFileHeader) + this.cache.fileAnnotationHeight;
 		let anchor;
 		iterateOverDiff({
-			diff: this.fileDiff,
+			diff: fileDiff,
 			diffStyle,
 			startingLine: checkpoint?.renderedLineIndex ?? 0,
 			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
@@ -334,12 +400,13 @@ var VirtualizedFileDiff = class extends FileDiff {
 		return this.height;
 	}
 	getAdvancedStickySpecs(windowSpecs) {
-		if (this.top == null || this.fileDiff == null) return;
+		const fileDiff = this.getLayoutDiff();
+		if (this.top == null || fileDiff == null) return;
 		if (this.options.collapsed === true) return {
 			topOffset: this.top,
 			height: this.height
 		};
-		const renderRange = windowSpecs != null ? this.computeRenderRangeFromWindow(this.fileDiff, this.top, windowSpecs) : this.renderRange;
+		const renderRange = windowSpecs != null ? this.computeRenderRangeFromWindow(fileDiff, this.top, windowSpecs) : this.renderRange;
 		if (renderRange == null) return;
 		const { bufferBefore, bufferAfter, totalLines } = renderRange;
 		let headerOnlyOffset = 0;
@@ -353,14 +420,19 @@ var VirtualizedFileDiff = class extends FileDiff {
 		};
 	}
 	cleanUp(recycle = false) {
+		const hadGhostTextRows = this.cache.ghostTextRows.size > 0;
+		if (hadGhostTextRows) this.layoutDirty = true;
+		const shouldRecomputeLayout = recycle && this.isAdvancedMode() && this.fileContainer != null && (hadGhostTextRows || !areDiffTargetsEqual(this.getRenderedDiff(), this.getLatestDiff()));
 		if (this.fileContainer != null && this.isSimpleMode()) this.getSimpleVirtualizer()?.disconnect(this.fileContainer);
 		if (!recycle) {
 			this.resetLayoutCache({ includeEstimatedHeights: true });
 			this.pendingExpansions = void 0;
 			this.pendingHydratedDiff = void 0;
 		}
+		this.pendingRender = void 0;
 		this.isSetup = false;
 		super.cleanUp(recycle);
+		if (shouldRecomputeLayout) this.virtualizer.instanceChanged(this, true);
 	}
 	expandHunk = (hunkIndex, direction, expansionLineCountOverride) => {
 		if (this.fileDiff == null) return;
@@ -394,41 +466,16 @@ var VirtualizedFileDiff = class extends FileDiff {
 		} else {
 			hydratePartialDiff("merge", expectedDiff, files);
 			this.setHydratedState(files);
-			await awaitWithTimeout(() => this.primeHighlightCache(expectedDiff));
-			if (!this.enabled || this.fileDiff !== expectedDiff) return;
+			if (!this.startHydratedEditSession(expectedDiff)) {
+				await awaitWithTimeout(() => this.primeHighlightCache(expectedDiff));
+				if (!this.enabled || this.fileDiff !== expectedDiff) return;
+			}
 			this.resetLayoutCache({ includeEstimatedHeights: true });
 			this.computeApproximateSize();
 		}
 		this.forceRenderOverride = true;
 		this.virtualizer.instanceChanged(this, true);
 	}
-	consumeCodeViewLayoutChanges(expectedFileDiff) {
-		let hasLayoutChange = false;
-		let nextDiff;
-		const { pendingExpansions, pendingHydratedDiff } = this;
-		if (pendingExpansions != null) {
-			this.pendingExpansions = void 0;
-			for (const pendingExpansion of pendingExpansions) {
-				this.hunksRenderer.expandHunk(pendingExpansion.hunkIndex, pendingExpansion.direction, pendingExpansion.expansionLineCountOverride);
-				hasLayoutChange = true;
-			}
-		}
-		if (pendingHydratedDiff != null) {
-			this.pendingHydratedDiff = void 0;
-			if (pendingHydratedDiff.expectedDiff === expectedFileDiff) {
-				this.setHydratedState(pendingHydratedDiff.files);
-				nextDiff = pendingHydratedDiff.nextDiff;
-			}
-		}
-		if (nextDiff != null) {
-			this.forceRenderOverride = true;
-			this.resetLayoutCache({ includeEstimatedHeights: true });
-		} else if (hasLayoutChange) {
-			this.forceRenderOverride = true;
-			this.invalidateDerivedLayoutCache(true);
-		}
-		return nextDiff;
-	}
 	loadFilesIfNecessary() {
 		if (this.pendingHydratedDiff != null) {
 			if (this.pendingHydratedDiff.expectedDiff === this.fileDiff) return;
@@ -439,7 +486,7 @@ var VirtualizedFileDiff = class extends FileDiff {
 	isLineRenderable(lineNumber) {
 		if (super.isLineRenderable(lineNumber)) return true;
 		const { pendingExpansions } = this;
-		const fileDiff = this.fileDiffCache;
+		const fileDiff = this.getRenderedDiff();
 		if (pendingExpansions == null || pendingExpansions.length === 0 || fileDiff == null) return false;
 		const { expansionLineCount = 100, collapsedContextThreshold = 1 } = this.options;
 		const staged = new Map(this.hunksRenderer.getExpandedHunksMap());
@@ -500,8 +547,19 @@ var VirtualizedFileDiff = class extends FileDiff {
 	}
 	rerender() {
 		if (!this.enabled || this.fileDiff == null && this.additionFile == null && this.deletionFile == null) return;
+		const latestDiff = this.getLatestDiff();
+		const nextRenderDiff = latestDiff == null ? void 0 : this.hunksRenderer.getDiffForNextRender(latestDiff);
+		if (this.isSimpleMode()) this.pendingRender = void 0;
 		this.forceRenderOverride = true;
-		this.virtualizer.instanceChanged(this, false);
+		this.virtualizer.instanceChanged(this, !areDiffTargetsEqual(this.getRenderedDiff(), nextRenderDiff));
+	}
+	syncGhostTextRows() {
+		const codeView = this.getAdvancedVirtualizer();
+		if (codeView != null) {
+			codeView.capturePendingLayoutAnchor();
+			this.layoutDirty = true;
+			codeView.instanceChanged(this, true);
+		} else this.getSimpleVirtualizer()?.requestHeightReconcile(this);
 	}
 	applyDocumentChange(textDocument, newLineAnnotations, shouldUpdateBuffer = false) {
 		const { renderRange: previousRenderRange } = this;
@@ -513,16 +571,17 @@ var VirtualizedFileDiff = class extends FileDiff {
 			includeEstimatedHeights: true,
 			resetRenderRange: false
 		});
+		const fileDiff = this.getRenderedDiff();
 		if (!this.isSimpleMode()) this.computeApproximateSize(true);
-		else if (shouldUpdateBuffer && previousRenderRange !== void 0 && this.fileDiff !== void 0) {
+		else if (shouldUpdateBuffer && previousRenderRange != null && fileDiff != null) {
 			const windowSpecs = this.virtualizer.getWindowSpecs();
-			const renderRange = this.computeRenderRangeFromWindow(this.fileDiff, this.top ?? 0, windowSpecs);
+			const renderRange = this.computeRenderRangeFromWindow(fileDiff, this.top ?? 0, windowSpecs);
 			if (renderRange.bufferAfter !== previousRenderRange.bufferAfter) this.updateBuffers(renderRange);
 		}
 		this.forceRenderOverride = true;
 		this.virtualizer.instanceChanged(this, true);
 	}
-	computeApproximateSize(force = false, fileDiff = this.fileDiff) {
+	computeApproximateSize(force = false, fileDiff = this.getLayoutDiff()) {
 		const shouldValidateSize = this.isResizeDebuggingEnabled();
 		if (!force && !this.layoutDirty && !shouldValidateSize) return;
 		const isFirstCompute = this.height === 0;
@@ -533,6 +592,7 @@ var VirtualizedFileDiff = class extends FileDiff {
 			this.layoutDirty = false;
 			return;
 		}
+		this.applyGhostTextRows(fileDiff, this.editor?.__getGhostTextRows() ?? NO_GHOST_TEXT_ROWS);
 		const { disableFileHeader = false, collapsed = false } = this.options;
 		const headerRegion = getVirtualFileHeaderRegion(this.metrics, disableFileHeader);
 		this.height += headerRegion;
@@ -544,13 +604,16 @@ var VirtualizedFileDiff = class extends FileDiff {
 		if (shouldValidateSize && !isFirstCompute) this.validateComputedHeight(fileDiff);
 		this.layoutDirty = false;
 	}
-	getActiveEstimatedHeight(fileDiff = this.fileDiff) {
+	getLayoutDiff() {
+		return this.pendingRender?.diff ?? this.getRenderedDiff();
+	}
+	getActiveEstimatedHeight(fileDiff = this.getLayoutDiff()) {
 		this.ensureEstimatedDiffHeights(fileDiff);
 		const estimatedHeight = this.getDiffStyle() === "split" ? this.cache.estimatedSplitHeight : this.cache.estimatedUnifiedHeight;
 		if (estimatedHeight == null) throw new Error("VirtualizedFileDiff.getActiveEstimatedHeight: missing estimated height");
 		return estimatedHeight;
 	}
-	ensureEstimatedDiffHeights(fileDiff = this.fileDiff) {
+	ensureEstimatedDiffHeights(fileDiff = this.getLayoutDiff()) {
 		if (fileDiff == null) {
 			this.cache.estimatedSplitHeight = void 0;
 			this.cache.estimatedUnifiedHeight = void 0;
@@ -571,7 +634,7 @@ var VirtualizedFileDiff = class extends FileDiff {
 		this.cache.estimatedSplitHeight = splitHeight;
 		this.cache.estimatedUnifiedHeight = unifiedHeight;
 	}
-	validateComputedHeight(fileDiff = this.fileDiff) {
+	validateComputedHeight(fileDiff = this.getLayoutDiff()) {
 		if (this.fileContainer == null || fileDiff == null) return;
 		const rect = this.fileContainer.getBoundingClientRect();
 		if (rect.height !== this.height) console.log("VirtualizedFileDiff.computeApproximateSize: computed height doesnt match", {
@@ -591,19 +654,26 @@ var VirtualizedFileDiff = class extends FileDiff {
 		if (fileDiff == null && hasFileInput && (filesDidChange || this.fileDiff == null)) nextFileDiff = parseDiffFromFile(fileInput.oldFile, fileInput.newFile, this.options.parseDiffOptions);
 		const { forceRenderOverride, isSetup } = this;
 		this.forceRenderOverride = void 0;
-		const annotationsChanged = this.syncLineAnnotations(lineAnnotations);
-		if (annotationsChanged) this.resetLayoutCache({ includeEstimatedHeights: false });
-		const diffInputChanged = fileDiff != null && fileDiff !== this.fileDiff;
 		const targetChanged = nextFileDiff != null && !areDiffTargetsEqual(this.fileDiff, nextFileDiff);
-		const dataChanged = diffInputChanged || filesDidChange;
-		if (targetChanged) this.resetLayoutCache({ includeEstimatedHeights: true });
+		const dataChanged = targetChanged || filesDidChange;
 		fileContainer = this.getOrCreateFileContainer(fileContainer);
 		if (nextFileDiff == null) {
 			console.error("VirtualizedFileDiff.render: attempting to virtually render when we dont have the correct data");
 			return false;
 		}
+		if (targetChanged) this.updateExternalDiff(nextFileDiff, lineAnnotations);
+		const { pendingRenderDiff, layoutDiffChanged, renderedDiffChanged, annotationsChanged } = (() => {
+			if (this.pendingRender != null && this.pendingRender.latestDiff === (this.getLatestDiff(nextFileDiff) ?? nextFileDiff)) return {
+				pendingRenderDiff: this.pendingRender.diff,
+				layoutDiffChanged: false,
+				renderedDiffChanged: false,
+				annotationsChanged: false
+			};
+			return this.updatePendingRender(nextFileDiff, lineAnnotations);
+		})();
+		if (annotationsChanged || layoutDiffChanged) this.resetLayoutCache({ includeEstimatedHeights: layoutDiffChanged });
 		if (!isSetup) {
-			this.computeApproximateSize(false, nextFileDiff);
+			this.computeApproximateSize(false, pendingRenderDiff);
 			const virtualizer = this.getSimpleVirtualizer();
 			this.top ??= this.getVirtualizedTop();
 			if (this.isAdvancedMode()) this.isVisible = true;
@@ -615,34 +685,54 @@ var VirtualizedFileDiff = class extends FileDiff {
 			this.isSetup = true;
 		} else {
 			this.top ??= this.getVirtualizedTop();
-			if (targetChanged) {
+			if (layoutDiffChanged) {
 				this.getSimpleVirtualizer()?.markDOMDirty();
-				this.computeApproximateSize(false, nextFileDiff);
+				this.computeApproximateSize(false, pendingRenderDiff);
 			}
 		}
 		if (!this.isVisible && this.isSimpleMode() && (!dataChanged || !isSetup)) {
-			this.fileDiff = nextFileDiff;
 			if (fileInput != null) {
 				this.deletionFile = oldFile;
 				this.additionFile = newFile;
 			}
-			if (targetChanged) this.cachedHeaderHTML = void 0;
+			if (targetChanged) this.clearReusableHeader();
+			this.pendingRender = void 0;
 			return this.renderPlaceholder(this.height);
 		}
 		const windowSpecs = this.virtualizer.getWindowSpecs();
 		const fileTop = this.top ?? 0;
-		const renderRange = this.computeRenderRangeFromWindow(nextFileDiff, fileTop, windowSpecs);
-		const rendered = super.render({
+		const renderRange = this.computeRenderRangeFromWindow(pendingRenderDiff, fileTop, windowSpecs);
+		return super.render({
 			fileDiff: nextFileDiff,
 			fileContainer,
 			renderRange,
 			lineAnnotations,
-			forceRender: (forceRenderOverride ?? forceRender) || annotationsChanged || targetChanged,
+			forceRender: (forceRenderOverride ?? forceRender) || annotationsChanged || renderedDiffChanged || targetChanged,
 			...fileInput,
 			...fileInputProps
 		});
-		if (this.isSimpleMode() && rendered) this.getSimpleVirtualizer()?.requestHeightReconcile(this);
-		return rendered;
+	}
+	finalizeRender() {
+		if (this.getRenderedDiff() !== this.pendingRender?.diff) throw new Error("VirtualizedFileDiff.render: rendered a different diff than its prepared layout");
+		this.pendingRender = void 0;
+		if (this.isSimpleMode()) this.getSimpleVirtualizer()?.requestHeightReconcile(this);
+	}
+	updatePendingRender(nextFileDiff, lineAnnotations) {
+		const latestDiff = this.getLatestDiff(nextFileDiff) ?? nextFileDiff;
+		const previousRenderedDiff = this.getRenderedDiff();
+		const { pendingRender } = this;
+		const previousLayoutDiff = pendingRender?.diff ?? previousRenderedDiff;
+		const pendingRenderDiff = this.hunksRenderer.getDiffForNextRender(latestDiff);
+		this.pendingRender = {
+			latestDiff,
+			diff: pendingRenderDiff
+		};
+		return {
+			pendingRenderDiff,
+			annotationsChanged: this.syncLineAnnotations(lineAnnotations),
+			layoutDiffChanged: !areDiffTargetsEqual(previousLayoutDiff, pendingRenderDiff),
+			renderedDiffChanged: !areDiffTargetsEqual(previousRenderedDiff, pendingRenderDiff)
+		};
 	}
 	syncVirtualizedTop() {
 		this.top = this.getVirtualizedTop();
@@ -678,8 +768,8 @@ var VirtualizedFileDiff = class extends FileDiff {
 	getHunkSeparatorType() {
 		return getOptionHunkSeparatorType(this.options.hunkSeparators);
 	}
-	approximateLayoutCheckpoints(fileDiff = this.fileDiff) {
-		if (!this.layoutDirty && this.cache.checkpoints.length > 0 || fileDiff == null || fileDiff.hunks.length === 0 || this.options.collapsed === true) return;
+	approximateLayoutCheckpoints(fileDiff) {
+		if (!this.layoutDirty && this.cache.checkpoints.length > 0 || fileDiff.hunks.length === 0 || this.options.collapsed === true) return;
 		const { disableFileHeader = false, expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
 		const finalHunkIndex = fileDiff.hunks.length - 1;
 		const canHydratePartialDiff = canHydrateCollapsedContext(fileDiff, this.options.loadDiffFiles != null);