@openclaw/diffs 2026.8.1-beta.2 → 2026.8.1

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

@@ -1,10 +1,13 @@
 import { DEFAULT_CODE_VIEW_FILE_METRICS, DEFAULT_CODE_VIEW_LAYOUT, DEFAULT_SMOOTH_SCROLL_SETTINGS, DEFAULT_THEMES, DIFFS_DEVELOPMENT_BUILD, DIFFS_TAG_NAME } from "../constants.js";
 import { dequeueRender, queueRender } from "../managers/UniversalRenderingManager.js";
+import { areManagedSnapshotsEqual } from "../utils/areManagedSnapshotsEqual.js";
 import { areObjectsEqual } from "../utils/areObjectsEqual.js";
 import { areThemesEqual } from "../utils/areThemesEqual.js";
 import { areOptionsEqual } from "../utils/areOptionsEqual.js";
 import { areSelectionsEqual } from "../utils/areSelectionsEqual.js";
+import { createCodeViewHeaderFooterHostElement } from "../utils/createCodeViewHeaderFooterHostElement.js";
 import { createWindowFromScrollPosition } from "../utils/createWindowFromScrollPosition.js";
+import { finishEditSessionForDiff } from "../utils/editSessionHunks.js";
 import { isStyleNode } from "../utils/isStyleNode.js";
 import { prefersReducedMotion } from "../utils/prefersReducedMotion.js";
 import { roundToDevicePixel } from "../utils/roundToDevicePixel.js";
@@ -28,6 +31,7 @@ const CODE_VIEW_DIFF_OPTION_KEYS = [
 	"diffIndicators",
 	"disableBackground",
 	"expandUnchanged",
+	"loadDiffFiles",
 	"collapsedContextThreshold",
 	"lineDiffType",
 	"maxLineDiffLength",
@@ -64,6 +68,7 @@ const CODE_VIEW_FILE_OPTION_KEYS = [
 const CODE_VIEW_SHARED_CALLBACK_KEYS = [
 	"renderCustomHeader",
 	"renderHeaderPrefix",
+	"renderHeaderFilenameSuffix",
 	"renderHeaderMetadata",
 	"renderAnnotation",
 	"renderGutterUtility",
@@ -104,12 +109,16 @@ function defineItemOption(target, key, get) {
 	});
 }
 const DEFAULT_SCROLL_INTERACTION_RESTORE_DELAY_MS = 120;
+const SUB_PIXEL_TOLERANCE = 1;
 const SCROLLING_CODE_OVERFLOW_FIX_VARIABLE = "--diffs-overflow-override";
 const SCROLL_REBASE_CONTAINER_HEIGHT = 12e6;
 const SCROLL_REBASE_TRIGGER_TOP = 1e6;
 const SCROLL_REBASE_TARGET_TOP = 2e6;
 const SCROLL_REBASE_TARGET_BOTTOM = SCROLL_REBASE_CONTAINER_HEIGHT - SCROLL_REBASE_TARGET_TOP;
 const SCROLL_REBASE_THRESHOLD = SCROLL_REBASE_CONTAINER_HEIGHT - SCROLL_REBASE_TRIGGER_TOP;
+function assertEditorFactory(createEditor) {
+	if (createEditor == null) throw new Error("CodeView: createEditor is required for items with edit: true");
+}
 const MOBILE_SAFARI = (() => {
 	const { navigator } = globalThis;
 	const userAgent = navigator.userAgent;
@@ -129,6 +138,8 @@ var CodeView = class CodeView {
 	items = [];
 	idToItem = /* @__PURE__ */ new Map();
 	selectedLines = null;
+	itemEditors = /* @__PURE__ */ new Map();
+	attachedEditors = /* @__PURE__ */ new Set();
 	instanceToItem = /* @__PURE__ */ new Map();
 	layoutDirtyIndex;
 	pendingLayoutReset;
@@ -170,12 +181,23 @@ var CodeView = class CodeView {
 	container = document.createElement("div");
 	stickyContainer = document.createElement("div");
 	stickyOffset = document.createElement("div");
+	header = {
+		element: void 0,
+		render: void 0,
+		height: 0
+	};
+	footer = {
+		element: void 0,
+		render: void 0,
+		height: 0
+	};
 	elementPool = [];
 	elementPoolVersion = 0;
 	elementPoolTracker = /* @__PURE__ */ new WeakMap();
 	pendingElementPool = [];
 	options;
 	workerManager;
+	isReadySubscription;
 	isContainerManaged;
 	constructor(options = { theme: DEFAULT_THEMES }, workerManager, isContainerManaged = false) {
 		this.options = options;
@@ -195,6 +217,9 @@ var CodeView = class CodeView {
 	getLayout() {
 		return this.options.layout ?? DEFAULT_CODE_VIEW_LAYOUT;
 	}
+	getItemTopOffset() {
+		return this.getLayout().paddingTop + this.header.height;
+	}
 	computeMetricsCache(itemMetrics) {
 		this.itemMetricsCache = {
 			hunkLineCount: itemMetrics?.hunkLineCount ?? DEFAULT_CODE_VIEW_FILE_METRICS.hunkLineCount,
@@ -245,7 +270,7 @@ var CodeView = class CodeView {
 		const { firstIndex, lastIndex, stickyHeight, stickyTop, stickyBottom } = this.renderState;
 		if (firstIndex === -1 || lastIndex === -1) return;
 		const actualHeight = this.stickyContainer.getBoundingClientRect().height;
-		if (Math.abs(actualHeight - stickyHeight) < 1) return;
+		if (Math.abs(actualHeight - stickyHeight) < SUB_PIXEL_TOLERANCE) return;
 		console.error("CodeView: sticky container height does not match computed layout", {
 			computedStickyHeight: stickyHeight,
 			actualStickyHeight: actualHeight,
@@ -297,6 +322,43 @@ var CodeView = class CodeView {
 		this.container?.style.setProperty("margin-top", `${paddingTop}px`);
 		this.container?.style.setProperty("margin-bottom", `${paddingBottom}px`);
 	}
+	reconcileHeaderFooterHosts() {
+		const headerChanged = this.reconcileHost("header");
+		const footerChanged = this.reconcileHost("footer");
+		return headerChanged || footerChanged;
+	}
+	reconcileHost(type) {
+		const { root, container } = this;
+		if (root == null || container == null) return false;
+		const host = type === "header" ? this.header : this.footer;
+		const render = type === "header" ? this.options.renderCodeViewHeader : this.options.renderCodeViewFooter;
+		if (render == null) {
+			if (host.element == null) return false;
+			this.resizeObserver?.unobserve(host.element);
+			host.element.remove();
+			host.element = void 0;
+			host.render = void 0;
+			this.setHostHeight(host, 0);
+			return false;
+		}
+		if (host.element != null && render === host.render) return false;
+		const element = host.element ?? createCodeViewHeaderFooterHostElement(type, container, this.resizeObserver);
+		host.element = element;
+		const content = render();
+		if (content != null) element.replaceChildren(content);
+		else if (!this.isContainerManaged && element.children.length > 0) element.textContent = "";
+		host.render = render;
+		return true;
+	}
+	setHostHeight(host, height) {
+		if (host.height === height) return;
+		host.height = height;
+		this.scrollDirty = true;
+	}
+	measureMountedHosts() {
+		if (this.header.element != null) this.setHostHeight(this.header, this.header.element.getBoundingClientRect().height);
+		if (this.footer.element != null) this.setHostHeight(this.footer, this.footer.element.getBoundingClientRect().height);
+	}
 	setup(root) {
 		if (this.root != null) throw new Error("CodeView.setup: already setup");
 		this.workerManager?.subscribeToThemeChanges(this);
@@ -336,8 +398,13 @@ var CodeView = class CodeView {
 		};
 	}
 	reset() {
+		dequeueRender(this.computeRenderRangeAndEmit);
+		this.clearReadySubscription();
 		this.restoreScrollInteractions();
 		this.cleanAllRenderedItems();
+		for (const record of this.itemEditors.values()) record.editor.cleanUp();
+		this.itemEditors.clear();
+		this.attachedEditors.clear();
 		this.selectedLines = null;
 		this.items.length = 0;
 		this.idToItem.clear();
@@ -380,6 +447,14 @@ var CodeView = class CodeView {
 		this.stickyOffset.remove();
 		this.stickyContainer.remove();
 		this.stickyContainer.textContent = "";
+		this.header.element?.remove();
+		this.header.element = void 0;
+		this.header.render = void 0;
+		this.header.height = 0;
+		this.footer.element?.remove();
+		this.footer.element = void 0;
+		this.footer.render = void 0;
+		this.footer.height = 0;
 		this.root = void 0;
 		this.container = void 0;
 	}
@@ -414,6 +489,7 @@ var CodeView = class CodeView {
 		const { element } = item;
 		if (element != null && this.renderedItemOwnsFocus(element)) this.shouldFixContainerFocus = true;
 		item.instance.cleanUp(true);
+		this.attachedEditors.delete(item.item.id);
 		item.element = void 0;
 		if (element == null) return;
 		element.remove();
@@ -506,6 +582,14 @@ var CodeView = class CodeView {
 	getItem(itemId) {
 		return this.idToItem.get(itemId)?.item;
 	}
+	/**
+	* Get the live editor for an item currently in edit mode. Use this to drive
+	* editor APIs CodeView does not wrap (applyEdits, undo, setMarkers, …).
+	* Returns undefined once the item leaves edit mode.
+	*/
+	getEditor(itemId) {
+		return this.itemEditors.get(itemId)?.editor;
+	}
 	updateItem(input) {
 		const item = this.idToItem.get(input.id);
 		if (item == null) {
@@ -516,6 +600,7 @@ var CodeView = class CodeView {
 		this.markItemLayoutDirty(item);
 		this.scrollDirty = true;
 		this.render();
+		this.syncItemEditors();
 		this.syncSelection();
 		return true;
 	}
@@ -541,6 +626,13 @@ var CodeView = class CodeView {
 			};
 			this.options.onSelectedLinesChange?.(this.selectedLines);
 		}
+		const editorRecord = this.itemEditors.get(oldId);
+		if (editorRecord != null) {
+			editorRecord.state.id = newId;
+			this.itemEditors.delete(oldId);
+			this.itemEditors.set(newId, editorRecord);
+			if (this.attachedEditors.delete(oldId)) this.attachedEditors.add(newId);
+		}
 		this.renamePendingScrollTarget(oldId, newId);
 		this.renamePendingLayoutAnchor(oldId, newId);
 		this.render();
@@ -548,16 +640,28 @@ var CodeView = class CodeView {
 	}
 	addItem(input) {
 		this.addItems([input]);
-		this.syncSelection();
 	}
 	addItems(inputs) {
 		this.appendItemsInternal(inputs);
+		this.syncItemEditors();
 		this.syncSelection();
 	}
+	removeItem(itemId) {
+		const item = this.idToItem.get(itemId);
+		if (item == null) {
+			console.error(`CodeView.removeItem: unknown item id "${itemId}"`);
+			return false;
+		}
+		const nextItems = [];
+		for (const current of this.items) if (current !== item) nextItems.push(current.item);
+		this.setItems(nextItems);
+		return true;
+	}
 	setItems(items) {
-		if (items.length === 0) this.reset();
-		else if (this.items.length === 0) this.appendItemsInternal(items);
-		else if (!this.tryAppendItems(items)) this.reconcileItems(items);
+		let removedItemsById;
+		if (this.items.length === 0) this.appendItemsInternal(items);
+		else if (!this.tryAppendItems(items)) removedItemsById = this.reconcileItems(items);
+		this.syncItemEditors(removedItemsById);
 		this.syncSelection();
 	}
 	/**
@@ -620,11 +724,13 @@ var CodeView = class CodeView {
 			this.scrollDirty = true;
 		}
 		if (!areOptionsEqual(prevOptions, options)) this.renderOptionsRevision++;
-		if (!this.isContainerManaged && this.items.length > 0) this.render();
+		this.syncItemEditors();
+		const headerFooterChanged = prevOptions.renderCodeViewHeader !== options.renderCodeViewHeader || prevOptions.renderCodeViewFooter !== options.renderCodeViewFooter;
+		if (!this.isContainerManaged && (this.items.length > 0 || headerFooterChanged)) this.render();
 	}
-	capturePendingLayoutAnchor() {
+	capturePendingLayoutAnchor(nextItems = this.idToItem) {
 		if (this.root == null || this.items.length === 0 || this.pendingScrollTarget != null) return;
-		this.pendingLayoutAnchor = this.getScrollAnchor(this.getScrollTop());
+		this.pendingLayoutAnchor = this.getScrollAnchor(this.getScrollTop(), nextItems);
 	}
 	render(immediate = false) {
 		if (CodeView.__STOP) return;
@@ -633,6 +739,25 @@ var CodeView = class CodeView {
 			this.computeRenderRangeAndEmit();
 		} else queueRender(this.computeRenderRangeAndEmit);
 	}
+	isReady() {
+		const { workerManager } = this;
+		if (workerManager == null || workerManager.isInitialized() || workerManager.getStats().workersFailed) {
+			this.clearReadySubscription();
+			return true;
+		}
+		this.isReadySubscription ??= workerManager.subscribeToStatChanges((stats) => {
+			if (stats.managerState !== "initialized" && !stats.workersFailed) return;
+			this.clearReadySubscription();
+			this.render(true);
+		});
+		if (workerManager.getStats().managerState === "waiting") workerManager.initialize().catch(() => {});
+		return false;
+	}
+	clearReadySubscription() {
+		if (this.isReadySubscription == null) return;
+		this.isReadySubscription();
+		this.isReadySubscription = void 0;
+	}
 	instanceChanged(instance, layoutDirty) {
 		const item = this.instanceToItem.get(instance);
 		if (item == null) throw new Error("CodeView.instanceChanged: An instance has changed that is not registered");
@@ -645,6 +770,12 @@ var CodeView = class CodeView {
 	getContainerElement() {
 		return this.root;
 	}
+	getHeaderElement() {
+		return this.header.element;
+	}
+	getFooterElement() {
+		return this.footer.element;
+	}
 	getRenderedItems() {
 		const { firstIndex, lastIndex } = this.renderState;
 		if (firstIndex === -1 || lastIndex === -1 || lastIndex < firstIndex) return [];
@@ -678,7 +809,18 @@ var CodeView = class CodeView {
 		return true;
 	}
 	getSlotSnapshot(coordinator) {
-		return getSlotSnapshot(this.getRenderedItems(), coordinator);
+		return this.buildSlotSnapshot(coordinator);
+	}
+	buildSlotSnapshot(coordinator) {
+		const items = getSlotItems(this.getRenderedItems(), coordinator);
+		const { element: header } = this.header;
+		const { element: footer } = this.footer;
+		if (items == null && header == null && footer == null) return;
+		return {
+			items,
+			header,
+			footer
+		};
 	}
 	subscribeToScroll(listener) {
 		this.scrollListeners.add(listener);
@@ -694,7 +836,7 @@ var CodeView = class CodeView {
 	getTopForItem(id) {
 		const item = this.idToItem.get(id);
 		if (item == null) return;
-		return item.top + this.getLayout().paddingTop;
+		return item.top + this.getItemTopOffset();
 	}
 	createItem(input, index, top) {
 		const { itemMetricsCache: itemMetrics } = this;
@@ -737,10 +879,94 @@ var CodeView = class CodeView {
 		const item = this.idToItem.get(this.selectedLines.id);
 		if (item == null) {
 			this.selectedLines = null;
+			this.options.onSelectedLinesChange?.(null);
 			return;
 		}
 		item.instance.setSelectedLines(this.selectedLines.range, { notify: false });
 	}
+	isItemInEditMode(item) {
+		return item.item.edit === true && item.item.collapsed !== true;
+	}
+	/**
+	* Attach (or lazily create) the editor for a mounted edit-mode item. Called
+	* from the render loop so every mounted item passes through it: fresh
+	* mounts, remounts after virtualization released the item, and items whose
+	* edit flag was just turned on. Editors persist across unmounts, so a
+	* remounted item re-attaches its existing editor and resumes the retained
+	* document; the renderers keep the host's file/diff data in sync with the
+	* session so the remount paints the edited text.
+	*/
+	attachItemEditor(item) {
+		const { id } = item.item;
+		const { createEditor } = this.options;
+		if (item.element == null || this.attachedEditors.has(id) || !this.isItemInEditMode(item)) return;
+		let record = this.itemEditors.get(id);
+		let createdEditor = false;
+		try {
+			if (record == null) {
+				assertEditorFactory(createEditor);
+				const state = { id };
+				const editor = createEditor({ onChange: (file, lineAnnotations) => {
+					const latest = this.idToItem.get(state.id);
+					if (latest == null) return;
+					state.lastChange = {
+						item: latest.item,
+						file,
+						lineAnnotations
+					};
+					this.options.onItemEditChange?.(latest.item, file, lineAnnotations);
+				} });
+				if (editor == null) return;
+				record = {
+					editor,
+					state
+				};
+				this.itemEditors.set(id, record);
+				createdEditor = true;
+			}
+			record.editor.edit(item.instance);
+			this.attachedEditors.add(id);
+		} catch (error) {
+			if (createdEditor && record != null) {
+				this.itemEditors.delete(id);
+				record.editor.cleanUp();
+			}
+			this.releaseRenderedItem(item);
+			throw error;
+		}
+	}
+	/**
+	* Drop editors for items that can no longer be edited: removed, edit turned
+	* off, or collapsed. Attachment happens in the render loop via
+	* attachItemEditor, so this only reconciles editors CodeView is already
+	* holding.
+	*/
+	syncItemEditors(removedItems) {
+		if (this.itemEditors.size === 0) return;
+		const completions = [];
+		for (const [id, record] of this.itemEditors) {
+			const item = this.idToItem.get(id);
+			const removedItem = removedItems?.get(id);
+			if (removedItem == null && item != null && this.isItemInEditMode(item)) continue;
+			record.editor.cleanUp();
+			this.itemEditors.delete(id);
+			this.attachedEditors.delete(id);
+			const { lastChange } = record.state;
+			const itemSnapshot = removedItem == null ? item?.item ?? lastChange?.item : lastChange?.item ?? removedItem.item;
+			if (itemSnapshot?.type === "diff") {
+				if (removedItem == null && item != null && item.type === "diff" && item.instance.completeEditSession()) {
+					this.markItemLayoutDirty(item);
+					this.render();
+				}
+				finishEditSessionForDiff(itemSnapshot.fileDiff);
+			}
+			if (lastChange != null) completions.push(removedItem != null || item == null ? lastChange : {
+				...lastChange,
+				item: item.item
+			});
+		}
+		for (const { item, file, lineAnnotations } of completions) this.options.onItemEditComplete?.(item, file, lineAnnotations);
+	}
 	renamePendingScrollTarget(oldId, newId) {
 		const { pendingScrollTarget } = this;
 		if (pendingScrollTarget == null || pendingScrollTarget.type === "position" || pendingScrollTarget.id !== oldId) return;
@@ -756,7 +982,11 @@ var CodeView = class CodeView {
 		const prototype = {};
 		for (const key of CODE_VIEW_FILE_OPTION_KEYS) defineItemOption(prototype, key, () => this.options[key]);
 		defineItemOption(prototype, "stickyHeader", () => this.options.stickyHeaders);
-		defineItemOption(prototype, "collapsed", (receiver) => this.getItemOptions(getItemOptionsState(receiver), "file")?.item.collapsed === true);
+		defineItemOption(prototype, "collapsed", (receiver) => {
+			const state = getItemOptionsState(receiver);
+			if (state == null) return;
+			return this.getItemOptions(state, "file")?.item.collapsed;
+		});
 		for (const key of CODE_VIEW_SHARED_CALLBACK_KEYS) this.defineItemSharedCallback(prototype, "file", key);
 		for (const key of CODE_VIEW_SELECTION_CALLBACK_KEYS) this.defineItemSelectionCallback(prototype, "file", key);
 		return prototype;
@@ -766,7 +996,11 @@ var CodeView = class CodeView {
 		for (const key of CODE_VIEW_DIFF_OPTION_KEYS) defineItemOption(prototype, key, () => this.options[key]);
 		defineItemOption(prototype, "stickyHeader", () => this.options.stickyHeaders);
 		defineItemOption(prototype, "hunkSeparators", () => this.options.hunkSeparators);
-		defineItemOption(prototype, "collapsed", (receiver) => this.getItemOptions(getItemOptionsState(receiver), "diff")?.item.collapsed === true);
+		defineItemOption(prototype, "collapsed", (receiver) => {
+			const state = getItemOptionsState(receiver);
+			if (state == null) return;
+			return this.getItemOptions(state, "diff")?.item.collapsed;
+		});
 		for (const key of CODE_VIEW_SHARED_CALLBACK_KEYS) this.defineItemSharedCallback(prototype, "diff", key);
 		for (const key of CODE_VIEW_SELECTION_CALLBACK_KEYS) this.defineItemSelectionCallback(prototype, "diff", key);
 		return prototype;
@@ -782,7 +1016,9 @@ var CodeView = class CodeView {
 		return options;
 	}
 	updateItemOptionsId(options, id) {
-		getItemOptionsState(options).id = id;
+		const state = getItemOptionsState(options);
+		if (state == null) throw new Error(`CodeView.updateItemOptionsId: No valid state`);
+		state.id = id;
 	}
 	getItemOptions(state, mode) {
 		const item = this.idToItem.get(state.id);
@@ -793,6 +1029,7 @@ var CodeView = class CodeView {
 		defineItemOption(options, key, (receiver) => {
 			if (this.options[key] == null) return;
 			const state = getItemOptionsState(receiver);
+			if (state == null) return;
 			const callbackCache = state.callbackCache ??= {};
 			let wrapped = callbackCache[key];
 			if (wrapped == null) {
@@ -809,8 +1046,8 @@ var CodeView = class CodeView {
 	}
 	defineItemSelectionCallback(options, mode, key) {
 		defineItemOption(options, key, (receiver) => {
-			if (this.options.enableLineSelection !== true) return;
 			const state = getItemOptionsState(receiver);
+			if (state == null) return;
 			const callbackCache = state.callbackCache ??= {};
 			let wrapped = callbackCache[key];
 			if (wrapped == null) {
@@ -888,6 +1125,7 @@ var CodeView = class CodeView {
 		const nextItems = [];
 		const nextIdToItem = /* @__PURE__ */ new Map();
 		const nextInstanceToItem = /* @__PURE__ */ new Map();
+		const removedItemsById = /* @__PURE__ */ new Map();
 		let firstDirtyIndex;
 		for (let index = 0; index < items.length; index++) {
 			const input = items[index];
@@ -905,14 +1143,19 @@ var CodeView = class CodeView {
 			nextIdToItem.set(input.id, item);
 			nextInstanceToItem.set(item.instance, item);
 		}
+		if (firstDirtyIndex == null) {
+			if (removedItems.size === 0) return;
+			firstDirtyIndex = Math.max(nextItems.length - 1, 0);
+		}
+		this.capturePendingLayoutAnchor(nextIdToItem);
 		for (let index = 0; index < previousItems.length; index++) {
 			const removedItem = previousItems[index];
 			if (removedItem == null || !removedItems.has(removedItem)) continue;
+			removedItemsById.set(removedItem.item.id, removedItem);
 			this.releaseRenderedItem(removedItem);
 			const dirtyIndex = Math.max(nextItems.length - 1, 0);
 			firstDirtyIndex = Math.min(firstDirtyIndex ?? dirtyIndex, dirtyIndex);
 		}
-		if (firstDirtyIndex == null) return;
 		this.items = nextItems;
 		this.idToItem = nextIdToItem;
 		this.instanceToItem = nextInstanceToItem;
@@ -921,6 +1164,7 @@ var CodeView = class CodeView {
 		this.markLayoutDirtyFromIndex(firstDirtyIndex);
 		this.scrollDirty = true;
 		this.render();
+		return removedItemsById.size > 0 ? removedItemsById : void 0;
 	}
 	/**
 	* Update a reused record from the latest controlled item only when its item
@@ -938,7 +1182,7 @@ var CodeView = class CodeView {
 	}
 	getMaxScrollTopForHeight(scrollHeight) {
 		const { paddingBottom, paddingTop } = this.getLayout();
-		return Math.max(paddingTop + scrollHeight + paddingBottom - this.getHeight(), 0);
+		return Math.max(paddingTop + this.header.height + scrollHeight + this.footer.height + paddingBottom - this.getHeight(), 0);
 	}
 	getMaxScrollTop() {
 		return this.getMaxScrollTopForHeight(this.getScrollHeight());
@@ -1050,7 +1294,7 @@ var CodeView = class CodeView {
 		const rect = this.getScrollTargetRect(target);
 		if (rect == null) return;
 		const offset = target.offset ?? 0;
-		const targetTop = this.getLayout().paddingTop + rect.top;
+		const targetTop = this.getItemTopOffset() + rect.top;
 		const targetBottom = targetTop + rect.height;
 		const currentTop = this.getScrollTop();
 		const visibleTop = currentTop + (target.type === "line" || target.type === "range" ? this.getStickyHeaderOffset() : 0);
@@ -1102,7 +1346,7 @@ var CodeView = class CodeView {
 	* and stickyOffset if necessary
 	*/
 	resolveAlignedScrollPosition(targetTop, targetHeight, align, offset = 0, stickyOffset = 0) {
-		targetTop += this.getLayout().paddingTop;
+		targetTop += this.getItemTopOffset();
 		const viewportHeight = this.getHeight();
 		if (align === "center" && targetHeight + offset < viewportHeight) return targetTop - (viewportHeight - targetHeight) / 2 + offset;
 		if (align === "end") return targetTop - (viewportHeight - targetHeight) + offset;
@@ -1206,6 +1450,7 @@ var CodeView = class CodeView {
 	}
 	computeRenderRangeAndEmit = (timestamp = performance.now()) => {
 		if (CodeView.__STOP || this.container == null) return;
+		if (!this.isReady()) return;
 		const viewportHeight = this.getHeight();
 		const initialScrollTop = this.getScrollTop();
 		let scrollTopAfterLayout = initialScrollTop;
@@ -1233,7 +1478,7 @@ var CodeView = class CodeView {
 		const fitPerfectly = !computeScrollCorrection && (this.renderState.scrollTop === -1 || Math.abs(targetScrollTop - this.renderState.scrollTop) > viewportHeight + this.config.overscrollSize * 2);
 		if (fitPerfectly) scrollAnchor = void 0;
 		this.windowSpecs = createWindowFromScrollPosition({
-			scrollTop: targetScrollTop,
+			scrollTop: targetScrollTop - this.header.height,
 			height: viewportHeight,
 			scrollHeight: this.getScrollHeight(),
 			fitPerfectly,
@@ -1252,6 +1497,7 @@ var CodeView = class CodeView {
 			if (item == null) throw new Error(`CodeView.computeRenderRangeAndEmit: No item at index: ${index}`);
 			if (!(item.top > top - item.height && item.top <= bottom)) this.releaseRenderedItem(item);
 		}
+		const hostsChanged = this.reconcileHeaderFooterHosts();
 		let prevElement;
 		const updatedItems = /* @__PURE__ */ new Set();
 		const startingIndex = this.findFirstVisibleIndex(top);
@@ -1277,10 +1523,13 @@ var CodeView = class CodeView {
 				}
 				prevElement = item.element;
 			}
+			if (item.item.edit === true) this.attachItemEditor(item);
 		}
 		this.renderState.firstIndex = startingIndex <= lastRenderedIndex ? startingIndex : -1;
 		this.renderState.lastIndex = lastRenderedIndex;
 		this.flushSlotCoordinator();
+		this.flushManagers(updatedItems);
+		if (hostsChanged) this.measureMountedHosts();
 		this.reconcileRenderedItems(updatedItems);
 		this.syncContainerHeight();
 		this.updateStickyPositioning();
@@ -1305,7 +1554,7 @@ var CodeView = class CodeView {
 			this.scrollAnimation = void 0;
 		}
 		this.renderState.scrollTop = roundToDevicePixel(syncedScrollTop);
-		this.flushManagers(updatedItems);
+		this.updateStickyPositioning();
 		this.validateStickyContainerHeight();
 		this.fixContainerFocus();
 		if (fitPerfectly || this.scrollAnimation != null) this.render();
@@ -1384,7 +1633,10 @@ var CodeView = class CodeView {
 	}
 	updateStickyPositioning() {
 		const stickyBounds = this.getStickyBounds();
-		if (stickyBounds == null) return;
+		if (stickyBounds == null) {
+			if (this.renderState.firstIndex === -1) this.stickyOffset.style.height = "";
+			return;
+		}
 		const { stickyTop, stickyBottom } = stickyBounds;
 		if (stickyBottom - stickyTop === this.renderState.stickyHeight && stickyTop === this.renderState.stickyTop && stickyBottom === this.renderState.stickyBottom) return;
 		this.applyStickyPositioning(stickyBounds);
@@ -1402,8 +1654,10 @@ var CodeView = class CodeView {
 		this.scrollAnimation = void 0;
 	};
 	handleResize = (entries) => {
+		let shouldRender = false;
 		for (const entry of entries) if (entry.target === this.stickyContainer) {
-			if (entry.borderBoxSize[0].blockSize !== this.renderState.stickyHeight) {
+			const blockSize = entry.borderBoxSize[0].blockSize;
+			if (Math.abs(blockSize - this.renderState.stickyHeight) >= SUB_PIXEL_TOLERANCE) {
 				const currentScrollTop = this.getScrollTop();
 				const anchor = this.getScrollAnchor(currentScrollTop);
 				this.reconcileRenderedItems();
@@ -1418,12 +1672,33 @@ var CodeView = class CodeView {
 					this.pendingScrollTarget = void 0;
 					this.scrollAnimation = void 0;
 				}
+				shouldRender = true;
+			}
+		} else if (entry.target === this.header.element || entry.target === this.footer.element) {
+			const host = entry.target === this.header.element ? this.header : this.footer;
+			const blockSize = entry.borderBoxSize[0].blockSize;
+			if (blockSize !== host.height) {
+				const currentScrollTop = this.getScrollTop();
+				const anchor = this.getScrollAnchor(currentScrollTop);
+				this.setHostHeight(host, blockSize);
+				const anchoredScrollTop = anchor != null ? this.resolveAnchoredScrollTop(anchor) : void 0;
+				if (anchoredScrollTop != null) {
+					const resizeAnchorDelta = anchoredScrollTop - currentScrollTop;
+					this.applyScrollFix(anchoredScrollTop, currentScrollTop, this.windowSpecs);
+					if (this.scrollAnimation != null) this.scrollAnimation.position += resizeAnchorDelta;
+				}
+				if (this.pendingScrollTarget != null && this.isPendingTargetSettled(this.pendingScrollTarget)) {
+					this.pendingScrollTarget = void 0;
+					this.scrollAnimation = void 0;
+				}
+				shouldRender = true;
 			}
 		} else {
 			this.scrollDirty = true;
 			this.heightDirty = true;
-			this.render();
+			shouldRender = true;
 		}
+		if (shouldRender) this.render(true);
 	};
 	/**
 	* Figure out scrollTop accounting for sticky header if enabled and
@@ -1439,8 +1714,15 @@ var CodeView = class CodeView {
 	* A scroll anchor represents the first fully visible element (in other
 	* words, the first file or first line who's top is fully in the viewport).
 	*/
-	getScrollAnchor(scrollTop) {
-		if (this.pendingLayoutAnchor != null) return this.pendingLayoutAnchor;
+	getScrollAnchor(scrollTop, availableItems = this.idToItem) {
+		let skippedItem;
+		const { pendingLayoutAnchor } = this;
+		if (pendingLayoutAnchor != null) {
+			const pendingItem = this.idToItem.get(pendingLayoutAnchor.id);
+			if (pendingItem != null && availableItems.get(pendingLayoutAnchor.id) === pendingItem) return pendingLayoutAnchor;
+			if (pendingItem != null) skippedItem = pendingItem;
+		}
+		if (scrollTop <= 0) return;
 		const { firstIndex, lastIndex, stickyTop, stickyBottom } = this.renderState;
 		if (firstIndex === -1 || lastIndex === -1) return;
 		const viewportHeight = this.getHeight();
@@ -1448,9 +1730,13 @@ var CodeView = class CodeView {
 		for (let index = firstIndex; index <= lastIndex; index++) {
 			const item = this.items[index];
 			if (item == null) continue;
-			const absoluteItemTop = this.getLayout().paddingTop + item.top;
+			const absoluteItemTop = this.getItemTopOffset() + item.top;
 			if (absoluteItemTop + item.height <= scrollTop) continue;
 			if (absoluteItemTop >= scrollTop + viewportHeight) break;
+			if (!(availableItems.get(item.item.id) === item)) {
+				skippedItem ??= item;
+				continue;
+			}
 			if (absoluteItemTop >= scrollTop) return {
 				type: "item",
 				id: item.item.id,
@@ -1469,6 +1755,14 @@ var CodeView = class CodeView {
 				};
 			}
 		}
+		if (skippedItem != null) for (let index = skippedItem.index + 1; index < this.items.length; index++) {
+			const candidate = this.items[index];
+			if (candidate != null && availableItems.get(candidate.item.id) === candidate) return {
+				type: "item",
+				id: candidate.item.id,
+				viewportOffset: 0
+			};
+		}
 	}
 	/**
 	* Given a scroll anchor, attempt to resolve a newly updated (and clamped)
@@ -1480,14 +1774,14 @@ var CodeView = class CodeView {
 	resolveAnchoredScrollTop(anchor) {
 		const item = this.idToItem.get(anchor.id);
 		if (item == null) return;
-		const { paddingTop } = this.getLayout();
+		const itemTopOffset = this.getItemTopOffset();
 		if (anchor.type === "item") {
-			const absoluteItemTop = paddingTop + item.top;
+			const absoluteItemTop = itemTopOffset + item.top;
 			return this.clampScrollTop(absoluteItemTop - anchor.viewportOffset);
 		}
 		const linePosition = item.type === "diff" ? item.instance.getLinePosition(anchor.lineNumber, anchor.side) : item.instance.getLinePosition(anchor.lineNumber);
 		if (linePosition == null) return;
-		const absoluteLineTop = paddingTop + item.top + linePosition.top;
+		const absoluteLineTop = itemTopOffset + item.top + linePosition.top;
 		return this.clampScrollTop(absoluteLineTop - anchor.viewportOffset);
 	}
 	/**
@@ -1544,11 +1838,10 @@ var CodeView = class CodeView {
 	}
 	flushSlotCoordinator() {
 		if (this.slotCoordinator == null) return;
-		const { onSnapshotChange } = this.slotCoordinator;
-		const slotSnapshot = getSlotSnapshot(this.getRenderedItems(), this.slotCoordinator);
-		if (areSlotSnapshotsEqual(this.slotSnapshot, slotSnapshot)) return;
+		const slotSnapshot = this.buildSlotSnapshot(this.slotCoordinator);
+		if (areManagedSnapshotsEqual(this.slotSnapshot, slotSnapshot)) return;
 		this.slotSnapshot = slotSnapshot;
-		onSnapshotChange(slotSnapshot);
+		this.slotCoordinator.onSnapshotChange(slotSnapshot);
 	}
 	notifyScroll() {
 		if (this.scrollListeners.size === 0) return;
@@ -1617,8 +1910,11 @@ var CodeView = class CodeView {
 			const item = this.items[index];
 			if (item == null) throw new Error("CodeView.recomputeLayout: invalid item index");
 			item.top = runningTop;
-			if (item.type === "diff") item.height = item.instance.prepareCodeViewItem(item.item.fileDiff, runningTop, reset, item.item.annotations ?? []);
-			else item.height = item.instance.prepareCodeViewItem(item.item.file, runningTop, reset, item.item.annotations ?? []);
+			if (item.type === "diff") {
+				const fileDiff = item.instance.consumeCodeViewLayoutChanges(item.item.fileDiff);
+				if (fileDiff != null) Object.assign(item.item.fileDiff, fileDiff);
+				item.height = item.instance.prepareCodeViewItem(item.item.fileDiff, runningTop, reset, item.item.annotations ?? []);
+			} else item.height = item.instance.prepareCodeViewItem(item.item.file, runningTop, reset, item.item.annotations ?? []);
 			runningTop += item.height;
 			if (index < this.items.length - 1) runningTop += layout.gap;
 		}
@@ -1696,7 +1992,7 @@ function syncRenderedItemOrder(container, element, prevElement) {
 function hasAnnotations(item) {
 	return (item.annotations?.length ?? 0) > 0;
 }
-function getSlotSnapshot(renderedItems, { hasHeaderRenderers, hasAnnotationRenderer, hasGutterRenderer }) {
+function getSlotItems(renderedItems, { hasHeaderRenderers, hasAnnotationRenderer, hasGutterRenderer }) {
 	if (renderedItems.length === 0) return;
 	if (hasHeaderRenderers || hasGutterRenderer) return renderedItems;
 	if (!hasAnnotationRenderer) return;
@@ -1704,17 +2000,7 @@ function getSlotSnapshot(renderedItems, { hasHeaderRenderers, hasAnnotationRende
 	for (const renderedItem of renderedItems) if (hasAnnotations(renderedItem.item)) slotSnapshot.push(renderedItem);
 	return slotSnapshot.length > 0 ? slotSnapshot : void 0;
 }
-function areSlotSnapshotsEqual(previous, next) {
-	if (previous == null || next == null) return previous === next;
-	if (previous.length !== next.length) return false;
-	for (let index = 0; index < previous.length; index++) {
-		const previousItem = previous[index];
-		const nextItem = next[index];
-		if (previousItem == null || nextItem == null || previousItem.id !== nextItem.id || previousItem.type !== nextItem.type || previousItem.element !== nextItem.element || previousItem.version !== nextItem.version) return false;
-	}
-	return true;
-}
 //#endregion
-export { CodeView };
+export { CODE_VIEW_DIFF_OPTION_KEYS, CODE_VIEW_FILE_OPTION_KEYS, CodeView };
 
 //# sourceMappingURL=CodeView.js.map