@openclaw/diffs 2026.8.1-beta.2 → 2026.8.1

package/node_modules/@pierre/diffs/dist/renderers/DiffHunksRenderer.js

@@ -1,9 +1,14 @@
 import { DEFAULT_EXPANDED_REGION, DEFAULT_RENDER_RANGE, DEFAULT_THEMES, DEFAULT_TOKENIZE_MAX_LENGTH } from "../constants.js";
+import { cleanLastNewline } from "../utils/cleanLastNewline.js";
+import { getTrailingContextRangeSize } from "../utils/virtualDiffLayout.js";
+import { recomputeDiffHunksForEdit, recomputeEmptyDocumentDiff, recomputeTopAlignedAdditionDiff, shouldTopAlignAdditionRecompute, updateDiffHunks } from "../utils/updateDiffHunks.js";
+import { applySessionChangedLines, rebuildSessionHunks, remapExpandedHunksForRegionChange } from "../utils/editSessionHunks.js";
 import { getFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
 import { createGutterGap, createGutterItem, createGutterWrapper, createHastElement } from "../utils/hast_utils.js";
 import { areLanguagesAttached } from "../highlighter/languages/areLanguagesAttached.js";
 import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { areThemesAttached } from "../highlighter/themes/areThemesAttached.js";
+import { applyLineTextWithNewline } from "../utils/applyLineTextWithNewline.js";
 import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { createAnnotationElement } from "../utils/createAnnotationElement.js";
 import { createContentColumn } from "../utils/createContentColumn.js";
@@ -12,9 +17,7 @@ import { createPreElement } from "../utils/createPreElement.js";
 import { getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
 import { getHighlighterOptions } from "../utils/getHighlighterOptions.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
-import { shouldUseTokenTransformer } from "../utils/shouldUseTokenTransformer.js";
 import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
-import { getTrailingContextRangeSize } from "../utils/virtualDiffLayout.js";
 import { iterateOverDiff } from "../utils/iterateOverDiff.js";
 import { areDiffRenderOptionsEqual } from "../utils/areDiffRenderOptionsEqual.js";
 import { createEmptyRowBuffer } from "../utils/createEmptyRowBuffer.js";
@@ -40,6 +43,7 @@ var DiffHunksRenderer = class {
 	additionAnnotations = {};
 	computedLang = "text";
 	renderCache;
+	editSessionActive = false;
 	constructor(options = { theme: DEFAULT_THEMES }, onRenderUpdate, workerManager) {
 		this.options = options;
 		this.onRenderUpdate = onRenderUpdate;
@@ -59,9 +63,78 @@ var DiffHunksRenderer = class {
 		this.additionAnnotations = {};
 		this.deletionAnnotations = {};
 		this.workerManager?.cleanUpTasks(this);
+		this.endEditSession();
+	}
+	/**
+	* Enter edit-session mode: hunk updates preserve the current region
+	* skeleton instead of recomputing hunks, and rendering happens locally
+	* with the token transformer forced on (worker-pool requests/results are
+	* suspended for this renderer). An empty additions document gets one row so
+	* the editor has a line for its caret. Called on every editor attach,
+	* including a re-attach after recycle.
+	*/
+	beginEditSession() {
+		this.editSessionActive = true;
+		const diff = this.diffCache;
+		if (diff != null && !diff.isPartial && diff.additionLines.length === 0) {
+			Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+			this.markEditSessionPass(diff);
+			this.clearRenderCache();
+		}
+	}
+	/** Leave edit-session mode. The exit recompute is the host's concern. */
+	endEditSession() {
+		this.editSessionActive = false;
+	}
+	/**
+	* Ensures that the DOM is compatible with editor render updates
+	*/
+	editorRenderReady() {
+		return this.renderCache?.options.useTokenTransformer === true && this.renderCache.highlighted && this.renderCache.result != null;
+	}
+	/**
+	* Re-highlights the current diff in the background and swaps the fresh
+	* result in (with a re-render) once it completes. Needed after an edit
+	* session's exit recompute: session passes plain-fill shifted lines in the
+	* cached result, and the recompute mutates the diff in place (same object,
+	* same cacheKey), so identity/cacheKey checks would otherwise treat the
+	* stale highlight as current forever. The current result — content-correct,
+	* mostly highlighted — keeps rendering until the fresh one lands, so no
+	* interim paint drops highlighting.
+	*/
+	refreshHighlightedResult() {
+		const { renderCache } = this;
+		if (renderCache == null || isDiffPlainText(renderCache.diff) || isDiffMassive(renderCache.diff, this.getTokenizeMaxLength())) return Promise.resolve();
+		const { diff } = renderCache;
+		const { workerManager } = this;
+		if (!this.editSessionActive && workerManager?.isWorkingPool() === true && diff.cacheKey != null) {
+			workerManager.evictDiffFromCache(diff.cacheKey);
+			return workerManager.primeDiffHighlightCache(diff).then(() => {
+				this.applyRefreshedResult(diff, workerManager.getDiffResultCache(diff));
+			}).catch((error) => this.onHighlightError(error));
+		}
+		return this.asyncHighlight(diff).then((fresh) => this.applyRefreshedResult(diff, fresh)).catch((error) => this.onHighlightError(error));
+	}
+	applyRefreshedResult(diff, fresh) {
+		if (fresh == null || this.renderCache == null || this.renderCache.diff !== diff || this.editSessionActive) return;
+		const { options } = this.getRenderOptions(diff);
+		if (!areDiffRenderOptionsEqual(options, fresh.options)) return;
+		this.renderCache = {
+			diff,
+			options: fresh.options,
+			highlighted: true,
+			result: fresh.result,
+			renderRange: void 0
+		};
+		this.onRenderUpdate?.();
+	}
+	get diffCache() {
+		return this.renderCache?.diff ?? this.diff;
 	}
 	clearRenderCache() {
+		const renderCache = this.renderCache;
 		this.renderCache = void 0;
+		if (renderCache != null && renderCache.isDirty === true && renderCache.diff.cacheKey != null) this.workerManager?.evictDiffFromCache(renderCache.diff.cacheKey);
 	}
 	setOptions(options) {
 		this.options = options;
@@ -88,6 +161,10 @@ var DiffHunksRenderer = class {
 	getExpandedHunksMap() {
 		return this.expandedHunks;
 	}
+	/** Replace the whole expansion map (session-exit expansion remapping). */
+	setExpandedHunksMap(expandedHunks) {
+		this.expandedHunks = expandedHunks;
+	}
 	setLineAnnotations(lineAnnotations) {
 		this.additionAnnotations = {};
 		this.deletionAnnotations = {};
@@ -103,12 +180,134 @@ var DiffHunksRenderer = class {
 			arr.push(annotation);
 		}
 	}
+	/**
+	* Returns true when a session-mode pass changed the region skeleton itself
+	* (a gap edit synthesized or merged regions), which changes the rendered
+	* row set without a line-count change — the host must escalate to a full
+	* re-render instead of its cheap refresh path.
+	*/
+	updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight = false) {
+		if (this.renderCache == null) return false;
+		const { result, diff } = this.renderCache;
+		if (result == null) return false;
+		if (diff.isPartial) throw new Error("Could not update render cache for partial diff");
+		const hastLines = result.code.additionLines;
+		const changedAdditionLines = [];
+		const previousAdditionLines = /* @__PURE__ */ new Map();
+		for (const [line, tokens] of dirtyLines) {
+			const prevProps = hastLines[line]?.properties ?? {};
+			const lineText = tokens.map((a) => a[2]).join("");
+			const canSyncDiffLine = line < diff.additionLines.length;
+			const prevLine = canSyncDiffLine ? diff.additionLines[line] ?? "" : "";
+			const prevText = cleanLastNewline(prevLine);
+			if (canSyncDiffLine) {
+				diff.additionLines[line] = applyLineTextWithNewline(prevLine, lineText);
+				if (prevText !== lineText) {
+					changedAdditionLines.push(line);
+					previousAdditionLines.set(line, prevLine);
+				}
+			}
+			hastLines[line] = {
+				type: "element",
+				tagName: "div",
+				properties: {
+					"data-line": prevProps["data-line"] ?? line + 1,
+					"data-line-index": prevProps["data-line-index"] ?? line,
+					"data-line-type": prevProps["data-line-type"] ?? "context"
+				},
+				children: tokens.map(([char, fg, text]) => {
+					if (char === 0 && fg === "") {
+						if (text === "") return {
+							type: "element",
+							tagName: "br",
+							properties: {},
+							children: []
+						};
+						return {
+							type: "text",
+							value: text
+						};
+					}
+					return {
+						type: "element",
+						tagName: "span",
+						properties: {
+							"data-char": char,
+							style: `color:${fg};`
+						},
+						children: [{
+							type: "text",
+							value: text
+						}]
+					};
+				})
+			};
+		}
+		let regionsChanged = false;
+		if (changedAdditionLines.length > 0) if (this.editSessionActive && !diff.isPartial) {
+			if (!lineCountChangeInFlight) if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
+				Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+				this.markEditSessionPass(diff);
+				regionsChanged = true;
+			} else if (shouldTopAlignAdditionRecompute(diff, diff.additionLines)) {
+				Object.assign(diff, recomputeTopAlignedAdditionDiff(diff, diff.additionLines, this.options.parseDiffOptions));
+				this.markEditSessionPass(diff);
+				regionsChanged = true;
+			} else {
+				const change = applySessionChangedLines(diff, changedAdditionLines, this.options.parseDiffOptions, previousAdditionLines);
+				this.applyExpansionRemap(change);
+				regionsChanged = change != null;
+			}
+		} else Object.assign(diff, updateDiffHunks(diff, changedAdditionLines, this.options.parseDiffOptions));
+		result.baseThemeType = themeType;
+		this.renderCache.isDirty = true;
+		return regionsChanged;
+	}
+	applyExpansionRemap(change) {
+		if (change != null) this.expandedHunks = remapExpandedHunksForRegionChange(this.expandedHunks, change);
+	}
+	applyDocumentChange(textDocument) {
+		if (this.renderCache == null) return;
+		const { diff, result } = this.renderCache;
+		if (result == null) return;
+		if (diff.isPartial) throw new Error("Could not apply document change for partial diff");
+		const { additionLines: previousAdditionLines } = diff;
+		diff.additionLines = getEditorDocumentLines(textDocument, previousAdditionLines);
+		result.code.additionLines = realignAdditionHastLines(previousAdditionLines, diff.additionLines, result.code.additionLines, textDocument);
+		if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
+			Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+			result.code.additionLines[0] = createPlainAdditionLineElement(0, textDocument.getLineText(0));
+			this.markEditSessionPass(diff);
+		} else if (this.editSessionActive) this.applySessionDocumentChange(diff);
+		else Object.assign(diff, recomputeDiffHunksForEdit(diff, this.options.parseDiffOptions));
+		this.renderCache.isDirty = true;
+	}
+	applySessionDocumentChange(diff) {
+		const { parseDiffOptions } = this.options;
+		const rawLines = diff.additionLines;
+		if (shouldTopAlignAdditionRecompute(diff, rawLines)) {
+			Object.assign(diff, recomputeTopAlignedAdditionDiff(diff, rawLines, parseDiffOptions));
+			this.markEditSessionPass(diff);
+			return;
+		}
+		this.applyExpansionRemap(rebuildSessionHunks(diff, parseDiffOptions));
+	}
+	markEditSessionPass(diff) {
+		if (!this.editSessionActive) return;
+		diff.editSessionDirty = true;
+	}
 	getUnifiedLineDecoration({ lineType }) {
-		return { gutterLineType: lineType };
+		return {
+			gutterLineType: lineType,
+			contentProperties: { "data-line-type": lineType }
+		};
 	}
 	getSplitLineDecoration({ side, type }) {
-		if (type !== "change") return { gutterLineType: type };
-		return { gutterLineType: side === "deletions" ? "change-deletion" : "change-addition" };
+		const lineType = type === "change" ? side === "deletions" ? "change-deletion" : "change-addition" : type;
+		return {
+			gutterLineType: lineType,
+			contentProperties: { "data-line-type": lineType }
+		};
 	}
 	createAnnotationElement = (span) => {
 		return createAnnotationElement(span);
@@ -140,7 +339,10 @@ var DiffHunksRenderer = class {
 		};
 	}
 	async initializeHighlighter() {
-		this.highlighter = await getSharedHighlighter(getHighlighterOptions(this.computedLang, this.options));
+		this.highlighter = await getSharedHighlighter(getHighlighterOptions(this.computedLang, {
+			theme: this.getLocalHighlightTheme(),
+			preferredHighlighter: this.workerManager?.getPreferredHighlighter() ?? this.options.preferredHighlighter
+		}));
 		return this.highlighter;
 	}
 	hydrate(diff) {
@@ -157,20 +359,37 @@ var DiffHunksRenderer = class {
 			result: massiveDiff ? void 0 : cache?.result,
 			renderRange: void 0
 		};
-		if (this.workerManager?.isWorkingPool() === true) {
+		if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) {
 			if (this.renderCache.result == null && !massiveDiff) this.workerManager.highlightDiffAST(this, this.diff);
 		} else if (this.highlighter == null) {
 			this.computedLang = diff.lang ?? getFiletypeFromFileName(diff.name);
 			this.initializeHighlighter();
 		}
 	}
+	getLocalHighlightTheme() {
+		return this.workerManager?.getDiffRenderOptions().theme ?? this.options.theme ?? DEFAULT_THEMES;
+	}
+	getEffectiveCodeOptions() {
+		const poolOptions = this.workerManager?.isWorkingPool() === true ? this.workerManager.getDiffRenderOptions() : void 0;
+		return {
+			theme: this.getLocalHighlightTheme(),
+			tokenizeMaxLineLength: poolOptions?.tokenizeMaxLineLength ?? this.options.tokenizeMaxLineLength
+		};
+	}
 	getRenderOptions(diff) {
 		const options = (() => {
-			if (this.workerManager?.isWorkingPool() === true) return this.workerManager.getDiffRenderOptions();
+			if (this.workerManager?.isWorkingPool() === true) {
+				const poolOptions = this.workerManager.getDiffRenderOptions();
+				if (this.editSessionActive && poolOptions.useTokenTransformer !== true) return {
+					...poolOptions,
+					useTokenTransformer: true
+				};
+				return poolOptions;
+			}
 			const { theme, tokenizeMaxLineLength, lineDiffType, maxLineDiffLength } = this.getOptionsWithDefaults();
 			return {
 				theme,
-				useTokenTransformer: shouldUseTokenTransformer(this.options),
+				useTokenTransformer: this.editSessionActive || this.options.useTokenTransformer === true,
 				tokenizeMaxLineLength,
 				lineDiffType,
 				maxLineDiffLength
@@ -193,7 +412,7 @@ var DiffHunksRenderer = class {
 	}
 	renderDiff(diff = this.renderCache?.diff, renderRange = DEFAULT_RENDER_RANGE) {
 		if (diff == null) return;
-		const { expandUnchanged = false, collapsedContextThreshold } = this.getOptionsWithDefaults();
+		const { expandUnchanged, collapsedContextThreshold } = this.getOptionsWithDefaults();
 		let { options, forceHighlight } = this.getRenderOptions(diff);
 		const cache = this.getMatchingWorkerResultCache(diff, options);
 		if (cache != null && !this.hasHighlightedRenderCache(diff, options)) {
@@ -216,8 +435,10 @@ var DiffHunksRenderer = class {
 		const forcePlainText = !hasContent || isDiffPlainText(diff) || isDiffMassive(diff, this.getTokenizeMaxLength());
 		const newContent = !areDiffTargetsEqual(diff, this.renderCache.diff);
 		const newRenderRange = !areRenderRangesEqual(this.renderCache.renderRange, renderRange);
-		if (this.workerManager?.isWorkingPool() === true) {
-			if (forcePlainText || this.renderCache.result == null || !this.renderCache.highlighted && (newContent || newRenderRange)) {
+		if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) {
+			const highlightPending = this.renderCache.result == null && this.renderCache.highlighted && !forcePlainText && !newContent && isDefaultRenderRange(renderRange);
+			if (highlightPending) this.renderCache.highlightPending = true;
+			if (!highlightPending && (forcePlainText || this.renderCache.result == null || !this.renderCache.highlighted && (newContent || newRenderRange))) {
 				this.renderCache.diff = diff;
 				this.renderCache.options = options;
 				this.renderCache.highlighted = false;
@@ -242,7 +463,7 @@ var DiffHunksRenderer = class {
 			}
 			if (!hasThemes || !forcePlainText && !hasLangs) this.asyncHighlight(diff).then(({ result, options }) => {
 				if (this.renderCache != null) this.renderCache.highlighted = false;
-				this.onHighlightSuccess(diff, result, options, !forcePlainText);
+				this.applyHighlightResult(diff, result, options, !forcePlainText);
 			});
 		}
 		return this.renderCache.result != null ? this.processDiffResult(this.renderCache.diff, renderRange, this.renderCache.result) : void 0;
@@ -267,7 +488,7 @@ var DiffHunksRenderer = class {
 	async asyncHighlight(diff) {
 		const forcePlainText = isDiffMassive(diff, this.getTokenizeMaxLength());
 		this.computedLang = forcePlainText ? "text" : diff.lang ?? getFiletypeFromFileName(diff.name);
-		const hasThemes = this.highlighter != null && areThemesAttached(this.options.theme ?? DEFAULT_THEMES);
+		const hasThemes = this.highlighter != null && areThemesAttached(this.getLocalHighlightTheme());
 		const hasLangs = forcePlainText || this.highlighter != null && areLanguagesAttached(this.computedLang);
 		if (this.highlighter == null || !hasThemes || !hasLangs) this.highlighter = await this.initializeHighlighter();
 		return this.renderDiffWithHighlighter(diff, this.highlighter, forcePlainText);
@@ -275,18 +496,39 @@ var DiffHunksRenderer = class {
 	renderDiffWithHighlighter(diff, highlighter, forcePlainText = false) {
 		const { options } = this.getRenderOptions(diff);
 		const { collapsedContextThreshold } = this.getOptionsWithDefaults();
-		return {
-			result: renderDiffWithHighlighter(diff, highlighter, options, {
-				forcePlainText,
+		const result = renderDiffWithHighlighter(diff, highlighter, options, {
+			forcePlainText,
+			expandedHunks: forcePlainText ? true : void 0,
+			collapsedContextThreshold
+		});
+		if (this.editSessionActive && diff.additionLines.length === 1 && diff.additionLines[0] === "" && result.code.additionLines[0] == null) {
+			let fallbackLine;
+			iterateOverDiff({
+				diff,
+				diffStyle: "both",
 				expandedHunks: forcePlainText ? true : void 0,
-				collapsedContextThreshold
-			}),
+				collapsedContextThreshold,
+				callback: ({ additionLine }) => {
+					if (additionLine?.lineIndex !== 0) return;
+					fallbackLine = additionLine;
+					return true;
+				}
+			});
+			if (fallbackLine == null) throw new Error("DiffHunksRenderer: missing empty addition line");
+			result.code.additionLines[0] = createPlainAdditionLineElement(0, "", fallbackLine.unifiedLineIndex, fallbackLine.splitLineIndex);
+		}
+		return {
+			result,
 			options
 		};
 	}
 	onHighlightSuccess(diff, result, options, highlighted = true) {
+		if (this.editSessionActive) return;
+		this.applyHighlightResult(diff, result, options, highlighted);
+	}
+	applyHighlightResult(diff, result, options, highlighted = true) {
 		if (this.renderCache == null) return;
-		const triggerRenderUpdate = !this.renderCache.highlighted || !areDiffRenderOptionsEqual(this.renderCache.options, options) || !areDiffTargetsEqual(this.renderCache.diff, diff);
+		const triggerRenderUpdate = this.renderCache.highlightPending === true || !this.renderCache.highlighted || !areDiffRenderOptionsEqual(this.renderCache.options, options) || !areDiffTargetsEqual(this.renderCache.diff, diff);
 		this.renderCache = {
 			diff,
 			options,
@@ -297,6 +539,7 @@ var DiffHunksRenderer = class {
 		if (triggerRenderUpdate) this.onRenderUpdate?.();
 	}
 	getMatchingWorkerResultCache(diff, options) {
+		if (this.editSessionActive) return;
 		const cache = this.workerManager?.getDiffResultCache(diff);
 		if (cache == null || !areDiffRenderOptionsEqual(options, cache.options)) return;
 		return cache;
@@ -313,8 +556,11 @@ var DiffHunksRenderer = class {
 	}
 	processDiffResult(fileDiff, renderRange, { code, themeStyles, baseThemeType }) {
 		const { diffStyle, disableFileHeader, expandUnchanged, expansionLineCount, collapsedContextThreshold, hunkSeparators } = this.getOptionsWithDefaults();
+		const isRenderCacheDirty = this.renderCache?.isDirty ?? false;
 		this.diff = fileDiff;
 		const unified = diffStyle === "unified";
+		const canHydrateContext = canHydrateCollapsedContext(fileDiff, this.options.loadDiffFiles != null);
+		const isExpandableDiff = !fileDiff.isPartial || canHydrateContext;
 		let additionsContentAST = [];
 		let deletionsContentAST = [];
 		let unifiedContentAST = [];
@@ -406,7 +652,7 @@ var DiffHunksRenderer = class {
 					hunkSpecs: hunk?.hunkSpecs,
 					isFirstHunk: hunkIndex === 0,
 					isLastHunk: false,
-					isExpandable: !fileDiff.isPartial
+					isExpandable: isExpandableDiff
 				});
 				const lineIndex = diffStyle === "unified" ? unifiedLineIndex : splitLineIndex;
 				const renderedLineContext = {
@@ -436,8 +682,14 @@ var DiffHunksRenderer = class {
 						deletionLineIndex: deletionLine?.lineIndex
 					});
 					pushGutterLineNumber("unified", lineDecoration.gutterLineType, additionLine != null ? additionLine.lineNumber : deletionLine.lineNumber, `${unifiedLineIndex},${splitLineIndex}`, lineDecoration.gutterProperties);
-					if (additionLineContent != null) additionLineContent = withContentProperties(additionLineContent, lineDecoration.contentProperties);
-					else if (deletionLineContent != null) deletionLineContent = withContentProperties(deletionLineContent, lineDecoration.contentProperties);
+					if (additionLineContent != null) additionLineContent = withContentProperties(additionLineContent, lineDecoration.contentProperties, isRenderCacheDirty && additionLine != null ? {
+						"data-line": additionLine.lineNumber,
+						"data-line-index": `${unifiedLineIndex},${splitLineIndex}`
+					} : void 0);
+					else if (deletionLineContent != null) deletionLineContent = withContentProperties(deletionLineContent, lineDecoration.contentProperties, isRenderCacheDirty && deletionLine != null ? {
+						"data-line": deletionLine.lineNumber,
+						"data-line-index": `${unifiedLineIndex},${splitLineIndex}`
+					} : void 0);
 					pushLineWithAnnotation({
 						diffStyle: "unified",
 						type,
@@ -475,19 +727,25 @@ var DiffHunksRenderer = class {
 						}
 					})();
 					if (missingSide != null) {
-						if (pendingSplitContext.side != null && pendingSplitContext.side !== missingSide) throw new Error("DiffHunksRenderer.processDiffResult: iterateOverDiff, invalid pending splits");
+						if (pendingSplitContext.side != null && pendingSplitContext.side !== missingSide) pendingSplitContext.flush();
 						pendingSplitContext.side = missingSide;
 						pendingSplitContext.increment();
-					}
+					} else if (type === "change") pendingSplitContext.flush();
 					const annotationSpans = this.getAnnotations("split", deletionLine?.lineNumber, additionLine?.lineNumber, hunkIndex, lineIndex);
 					if (annotationSpans != null && pendingSplitContext.size > 0) pendingSplitContext.flush();
 					if (deletionLine != null) {
-						const deletionLineDecorated = withContentProperties(deletionLineContent, deletionLineDecoration.contentProperties);
+						const deletionLineDecorated = withContentProperties(deletionLineContent, deletionLineDecoration.contentProperties, isRenderCacheDirty ? {
+							"data-line": deletionLine.lineNumber,
+							"data-line-index": `${deletionLine.unifiedLineIndex},${splitLineIndex}`
+						} : void 0);
 						pushGutterLineNumber("deletions", deletionLineDecoration.gutterLineType, deletionLine.lineNumber, `${deletionLine.unifiedLineIndex},${splitLineIndex}`, deletionLineDecoration.gutterProperties);
 						if (deletionLineDecorated != null) deletionLineContent = deletionLineDecorated;
 					}
 					if (additionLine != null) {
-						const additionLineDecorated = withContentProperties(additionLineContent, additionLineDecoration.contentProperties);
+						const additionLineDecorated = withContentProperties(additionLineContent, additionLineDecoration.contentProperties, isRenderCacheDirty ? {
+							"data-line": additionLine.lineNumber,
+							"data-line-index": `${additionLine.unifiedLineIndex},${splitLineIndex}`
+						} : void 0);
 						pushGutterLineNumber("additions", additionLineDecoration.gutterLineType, additionLine.lineNumber, `${additionLine.unifiedLineIndex},${splitLineIndex}`, additionLineDecoration.gutterProperties);
 						if (additionLineDecorated != null) additionLineContent = additionLineDecorated;
 					}
@@ -503,6 +761,7 @@ var DiffHunksRenderer = class {
 					if (injectedRows?.after != null) pushSplitInjectedRows(injectedRows.after, context, pendingSplitContext);
 				}
 				const isFinalSplitHunkRow = diffStyle === "split" && hunk != null && splitLineIndex === hunk.splitLineStart + hunk.splitLineCount - 1;
+				const isFinalHunkRow = hunkIndex === fileDiff.hunks.length - 1 && hunk != null && (diffStyle === "split" ? splitLineIndex === hunk.splitLineStart + hunk.splitLineCount - 1 : unifiedLineIndex === hunk.unifiedLineStart + hunk.unifiedLineCount - 1);
 				const splitNoEOFCRDeletion = isFinalSplitHunkRow ? hunk.noEOFCRDeletions : false;
 				const splitNoEOFCRAddition = isFinalSplitHunkRow ? hunk.noEOFCRAdditions : false;
 				const noEOFCRDeletion = (deletionLine?.noEOFCR ?? false) || splitNoEOFCRDeletion;
@@ -539,14 +798,14 @@ var DiffHunksRenderer = class {
 					}
 					context.incrementRowCount(1);
 				}
-				if (collapsedAfter > 0 && hunkSeparators !== "simple") pushSeparators({
+				if (hunkSeparators !== "simple" && hunkSeparators !== "metadata" && (collapsedAfter > 0 || isFinalHunkRow && canHydrateContext)) pushSeparators({
 					hunkIndex: type === "context-expanded" ? hunkIndex : hunkIndex + 1,
-					collapsedLines: collapsedAfter,
+					collapsedLines: isFinalHunkRow && canHydrateContext ? "unknown" : collapsedAfter,
 					rangeSize: trailingRangeSize,
 					hunkSpecs: void 0,
 					isFirstHunk: false,
 					isLastHunk: true,
-					isExpandable: !fileDiff.isPartial
+					isExpandable: isExpandableDiff
 				});
 				context.incrementRowCount(1);
 			}
@@ -786,7 +1045,7 @@ function pushLineWithAnnotation({ diffStyle, type, deletionLine, additionLine, u
 	if (hasAnnotationRow) context.incrementRowCount(1);
 }
 function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs, isFirstHunk, isLastHunk, isExpandable }, context) {
-	if (collapsedLines <= 0) return;
+	if (typeof collapsedLines === "number" && collapsedLines <= 0) return;
 	const linesAST = type === "unified" ? context.unifiedContentAST : type === "deletions" ? context.deletionsContentAST : context.additionsContentAST;
 	if (context.hunkSeparators === "metadata") {
 		if (hunkSpecs != null) {
@@ -825,9 +1084,10 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	const slotName = getHunkSeparatorSlotName(type, hunkIndex);
 	const chunked = rangeSize > context.expansionLineCount;
 	const expandIndex = isExpandable ? hunkIndex : void 0;
+	const content = typeof collapsedLines === "number" ? getModifiedLinesString(collapsedLines) : "More unchanged context may be available";
 	context.pushToGutter(type, createSeparator({
 		type: context.hunkSeparators,
-		content: getModifiedLinesString(collapsedLines),
+		content,
 		expandIndex,
 		chunked,
 		slotName,
@@ -836,7 +1096,7 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	}));
 	linesAST.push(createSeparator({
 		type: context.hunkSeparators,
-		content: getModifiedLinesString(collapsedLines),
+		content,
 		expandIndex,
 		chunked,
 		slotName,
@@ -847,7 +1107,8 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	context.hunkData.push({
 		slotName,
 		hunkIndex,
-		lines: collapsedLines,
+		lines: typeof collapsedLines === "number" ? collapsedLines : 0,
+		lineCountKnown: typeof collapsedLines === "number",
 		type,
 		expandable: isExpandable ? {
 			up: !isFirstHunk,
@@ -856,19 +1117,82 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 		} : void 0
 	});
 }
-function withContentProperties(lineNode, contentProperties) {
-	if (lineNode == null || lineNode.type !== "element" || contentProperties == null) return lineNode;
+function withContentProperties(lineNode, contentProperties, extendProperties) {
+	if (lineNode == null || lineNode.type !== "element" || contentProperties == null && extendProperties == null) return lineNode;
 	return {
 		...lineNode,
 		properties: {
 			...lineNode.properties,
-			...contentProperties
+			...contentProperties,
+			...extendProperties
 		}
 	};
 }
+function contentLineCount(lines) {
+	return lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+}
+function realignAdditionHastLines(previousLines, nextLines, hastLines, textDocument) {
+	const previousContentLength = contentLineCount(previousLines);
+	const nextContentLength = contentLineCount(nextLines);
+	const maxShared = Math.min(previousContentLength, nextContentLength);
+	let prefix = 0;
+	while (prefix < maxShared && previousLines[prefix] === nextLines[prefix]) prefix++;
+	let suffix = 0;
+	while (suffix < maxShared - prefix && previousLines[previousContentLength - 1 - suffix] === nextLines[nextContentLength - 1 - suffix]) suffix++;
+	const realigned = new Array(nextLines.length);
+	for (let index = 0; index < prefix; index++) realigned[index] = hastLines[index];
+	for (let offset = 0; offset < suffix; offset++) realigned[nextContentLength - 1 - offset] = hastLines[previousContentLength - 1 - offset];
+	if (previousContentLength < previousLines.length && nextContentLength < nextLines.length) realigned[nextLines.length - 1] = hastLines[previousLines.length - 1];
+	for (let index = previousLines.length; index < nextLines.length; index++) realigned[index] ??= hastLines[index];
+	for (let index = prefix; index < nextLines.length; index++) realigned[index] ??= createPlainAdditionLineElement(index, textDocument.getLineText(index));
+	return realigned;
+}
+function createPlainAdditionLineElement(lineIndex, lineText, unifiedLineIndex = lineIndex, splitLineIndex = lineIndex) {
+	return {
+		type: "element",
+		tagName: "div",
+		properties: {
+			"data-line": lineIndex + 1,
+			"data-line-index": `${unifiedLineIndex},${splitLineIndex}`,
+			"data-line-type": "context"
+		},
+		children: [{
+			type: "element",
+			tagName: "span",
+			properties: { "data-char": 0 },
+			children: [{
+				type: "text",
+				value: lineText
+			}]
+		}]
+	};
+}
+function getEditorDocumentLines(textDocument, previousLines) {
+	const lines = [];
+	const fallbackLineBreak = getFallbackLineBreak(previousLines);
+	for (let line = 0; line < textDocument.lineCount; line++) {
+		const lineText = textDocument.getLineText(line, true);
+		lines.push(line < textDocument.lineCount - 1 && !hasLineBreakSuffix(lineText) ? lineText + fallbackLineBreak : lineText);
+	}
+	return lines;
+}
+function hasLineBreakSuffix(line) {
+	return line.endsWith("\n") || line.endsWith("\r");
+}
+function getFallbackLineBreak(lines) {
+	for (const line of lines) {
+		if (line.endsWith("\r\n")) return "\r\n";
+		if (line.endsWith("\n")) return "\n";
+		if (line.endsWith("\r")) return "\r";
+	}
+	return "\n";
+}
 function isDiffMassive(diff, tokenizeMaxLength) {
 	return Math.max(diff.additionLines.length, diff.deletionLines.length) > tokenizeMaxLength;
 }
+function canHydrateCollapsedContext(fileDiff, hasFileLoader) {
+	return fileDiff.isPartial && hasFileLoader && (fileDiff.type === "change" || fileDiff.type === "rename-changed");
+}
 //#endregion
 export { DiffHunksRenderer };