chat-layout 1.2.0-7 → 1.2.0-9

package/index.mjs

@@ -2041,6 +2041,154 @@ function createRichSourceItems(spans, defaultFont) {
 	}));
 }
 //#endregion
+//#region src/text/justify.ts
+let _justifySupported;
+function isJustifySupported(ctx) {
+	if (_justifySupported !== void 0) return _justifySupported;
+	_justifySupported = typeof ctx.wordSpacing === "string" && typeof ctx.letterSpacing === "string";
+	return _justifySupported;
+}
+function resolveJustifyMode(justify) {
+	if (justify === true) return "inter-word";
+	if (justify === "inter-word" || justify === "inter-character") return justify;
+	return null;
+}
+const HYBRID_WORD_SHARE_CANDIDATES = [
+	.15,
+	.2,
+	.25,
+	.3,
+	.35,
+	.4,
+	.45,
+	.5,
+	.55,
+	.6,
+	.65,
+	.7,
+	.75,
+	.8,
+	.85,
+	1,
+	0
+];
+const PUNCTUATION_OR_SYMBOL_PATTERN = /^[\p{P}\p{S}]$/u;
+const JUSTIFY_SCORE_EPSILON = 1e-9;
+function analyzeLineForJustify(prepared, line) {
+	let wordGapCount = 0;
+	let wordCount = 0;
+	let renderAtomCount = 0;
+	let spaceCount = 0;
+	let nonSpaceCount = 0;
+	let cjkCount = 0;
+	let latinLikeCount = 0;
+	let punctuationCount = 0;
+	let nonSpaceWidth = 0;
+	let insideWord = false;
+	forEachAtomInRange(prepared, line.start, line.end, (atom) => {
+		if (atom.kind === "space" && !atom.preservesLineEnd && atom.atomicGroupId == null) wordGapCount++;
+		renderAtomCount++;
+		if (atom.kind === "space") {
+			spaceCount++;
+			insideWord = false;
+			return;
+		}
+		nonSpaceCount++;
+		nonSpaceWidth += atom.width + atom.extraWidthAfter;
+		if (!insideWord) {
+			wordCount++;
+			insideWord = true;
+		}
+		if (isCJK(atom.text)) {
+			cjkCount++;
+			return;
+		}
+		if (PUNCTUATION_OR_SYMBOL_PATTERN.test(atom.text)) {
+			punctuationCount++;
+			return;
+		}
+		latinLikeCount++;
+	});
+	return {
+		wordGapCount,
+		wordCount,
+		renderAtomCount,
+		letterGapCount: Math.max(renderAtomCount - 1, 0),
+		spaceCount,
+		nonSpaceCount,
+		cjkCount,
+		latinLikeCount,
+		punctuationCount,
+		lineWidth: line.width,
+		nonSpaceWidth
+	};
+}
+function getAverageWordWidth(info) {
+	return info.wordCount > 0 ? info.nonSpaceWidth / info.wordCount : info.lineWidth;
+}
+function getAverageCharWidth(info) {
+	return info.renderAtomCount > 0 ? info.lineWidth / info.renderAtomCount : info.lineWidth;
+}
+function resolvePerGapSpacing(totalSpace, gapCount) {
+	if (totalSpace === 0) return 0;
+	if (gapCount <= 0) return null;
+	return totalSpace / gapCount;
+}
+function exceedsThreshold(perGap, averageWidth, threshold) {
+	if (!Number.isFinite(threshold)) return false;
+	return perGap > threshold * averageWidth;
+}
+function createJustifySpacing(wordSpacingPx, letterSpacingPx) {
+	return {
+		wordSpacing: `${wordSpacingPx}px`,
+		letterSpacing: `${letterSpacingPx}px`,
+		wordSpacingPx,
+		letterSpacingPx
+	};
+}
+function computeJustifySpacing(lineWidth, maxWidth, info, mode, threshold = Number.POSITIVE_INFINITY) {
+	const extraSpace = maxWidth - lineWidth;
+	if (extraSpace <= 0 || mode == null) return null;
+	if (mode === "inter-word" && info.wordGapCount > 0) {
+		const perGap = extraSpace / info.wordGapCount;
+		if (exceedsThreshold(perGap, Math.max(getAverageWordWidth(info), Number.EPSILON), threshold)) return null;
+		return createJustifySpacing(perGap, 0);
+	}
+	if (mode !== "inter-character" || info.renderAtomCount === 0) return null;
+	const avgCharWidth = Math.max(getAverageCharWidth(info), Number.EPSILON);
+	if (info.wordGapCount === 0) {
+		const perGap = resolvePerGapSpacing(extraSpace, info.letterGapCount);
+		if (perGap == null) return null;
+		if (exceedsThreshold(perGap, avgCharWidth, threshold)) return null;
+		return createJustifySpacing(0, perGap);
+	}
+	const avgWordWidth = Math.max(getAverageWordWidth(info), Number.EPSILON);
+	const nonSpaceCount = Math.max(info.nonSpaceCount, 1);
+	const cjkRatio = info.cjkCount / nonSpaceCount;
+	const latinLikeRatio = info.latinLikeCount / nonSpaceCount;
+	const punctuationRatio = info.punctuationCount / nonSpaceCount;
+	const wordPenalty = 1 + cjkRatio;
+	const letterPenalty = 1 + latinLikeRatio + .5 * punctuationRatio;
+	let bestCandidate = null;
+	for (const wordShare of HYBRID_WORD_SHARE_CANDIDATES) {
+		const wordExtraSpace = extraSpace * wordShare;
+		const letterExtraSpace = extraSpace - wordExtraSpace;
+		const wordSpacingPx = resolvePerGapSpacing(wordExtraSpace, info.wordGapCount);
+		const letterSpacingPx = resolvePerGapSpacing(letterExtraSpace, info.letterGapCount);
+		if (wordSpacingPx == null || letterSpacingPx == null) continue;
+		if (exceedsThreshold(wordSpacingPx, avgWordWidth, threshold) || exceedsThreshold(letterSpacingPx, avgCharWidth, threshold)) continue;
+		const wordRatio = wordSpacingPx / avgWordWidth;
+		const letterRatio = letterSpacingPx / avgCharWidth;
+		const score = wordPenalty * wordRatio ** 2 + letterPenalty * letterRatio ** 2;
+		if (bestCandidate == null || score < bestCandidate.score - JUSTIFY_SCORE_EPSILON || Math.abs(score - bestCandidate.score) <= JUSTIFY_SCORE_EPSILON && wordShare > bestCandidate.wordShare) bestCandidate = {
+			spacing: createJustifySpacing(wordSpacingPx, letterSpacingPx),
+			score,
+			wordShare
+		};
+	}
+	return bestCandidate?.spacing ?? null;
+}
+//#endregion
 //#region src/text/plain-core.ts
 function readPreparedText(text, font, whiteSpace, wordBreak) {
 	return readPreparedInlineLayout(getPlainPreparedKey(text, font, whiteSpace, wordBreak), createPlainSourceItems(text, font), whiteSpace, wordBreak);
@@ -2759,174 +2907,26 @@ function layoutRichTextWithOverflow(ctx, spans, maxWidth, defaultFont, defaultCo
 	};
 }
 //#endregion
-//#region src/text/justify.ts
-let _justifySupported;
-function isJustifySupported(ctx) {
-	if (_justifySupported !== void 0) return _justifySupported;
-	_justifySupported = typeof ctx.wordSpacing === "string" && typeof ctx.letterSpacing === "string";
-	return _justifySupported;
-}
-function resolveJustifyMode(justify) {
-	if (justify === true) return "inter-word";
-	if (justify === "inter-word" || justify === "inter-character") return justify;
-	return null;
-}
-const HYBRID_WORD_SHARE_CANDIDATES = [
-	.15,
-	.2,
-	.25,
-	.3,
-	.35,
-	.4,
-	.45,
-	.5,
-	.55,
-	.6,
-	.65,
-	.7,
-	.75,
-	.8,
-	.85,
-	1,
-	0
-];
-const PUNCTUATION_OR_SYMBOL_PATTERN = /^[\p{P}\p{S}]$/u;
-const JUSTIFY_SCORE_EPSILON = 1e-9;
-function analyzeLineForJustify(prepared, line) {
-	let wordGapCount = 0;
-	let wordCount = 0;
-	let renderAtomCount = 0;
-	let spaceCount = 0;
-	let nonSpaceCount = 0;
-	let cjkCount = 0;
-	let latinLikeCount = 0;
-	let punctuationCount = 0;
-	let nonSpaceWidth = 0;
-	let insideWord = false;
-	forEachAtomInRange(prepared, line.start, line.end, (atom) => {
-		if (atom.kind === "space" && !atom.preservesLineEnd && atom.atomicGroupId == null) wordGapCount++;
-		renderAtomCount++;
-		if (atom.kind === "space") {
-			spaceCount++;
-			insideWord = false;
-			return;
-		}
-		nonSpaceCount++;
-		nonSpaceWidth += atom.width + atom.extraWidthAfter;
-		if (!insideWord) {
-			wordCount++;
-			insideWord = true;
-		}
-		if (isCJK(atom.text)) {
-			cjkCount++;
-			return;
-		}
-		if (PUNCTUATION_OR_SYMBOL_PATTERN.test(atom.text)) {
-			punctuationCount++;
-			return;
-		}
-		latinLikeCount++;
-	});
-	return {
-		wordGapCount,
-		wordCount,
-		renderAtomCount,
-		letterGapCount: Math.max(renderAtomCount - 1, 0),
-		spaceCount,
-		nonSpaceCount,
-		cjkCount,
-		latinLikeCount,
-		punctuationCount,
-		lineWidth: line.width,
-		nonSpaceWidth
-	};
-}
-function getAverageWordWidth(info) {
-	return info.wordCount > 0 ? info.nonSpaceWidth / info.wordCount : info.lineWidth;
+//#region src/nodes/text.ts
+function resolvePhysicalTextAlign(options) {
+	if (options.physicalAlign != null) return options.physicalAlign;
+	if (options.align != null) switch (options.align) {
+		case "start": return "left";
+		case "center": return "center";
+		case "end": return "right";
+	}
+	return "left";
 }
-function getAverageCharWidth(info) {
-	return info.renderAtomCount > 0 ? info.lineWidth / info.renderAtomCount : info.lineWidth;
+function normalizeTextMaxWidth(maxWidth) {
+	if (maxWidth == null) return;
+	return Math.max(0, maxWidth);
 }
-function resolvePerGapSpacing(totalSpace, gapCount) {
-	if (totalSpace === 0) return 0;
-	if (gapCount <= 0) return null;
-	return totalSpace / gapCount;
-}
-function exceedsThreshold(perGap, averageWidth, threshold) {
-	if (!Number.isFinite(threshold)) return false;
-	return perGap > threshold * averageWidth;
-}
-function createJustifySpacing(wordSpacingPx, letterSpacingPx) {
-	return {
-		wordSpacing: `${wordSpacingPx}px`,
-		letterSpacing: `${letterSpacingPx}px`,
-		wordSpacingPx,
-		letterSpacingPx
-	};
-}
-function computeJustifySpacing(lineWidth, maxWidth, info, mode, threshold = Number.POSITIVE_INFINITY) {
-	const extraSpace = maxWidth - lineWidth;
-	if (extraSpace <= 0 || mode == null) return null;
-	if (mode === "inter-word" && info.wordGapCount > 0) {
-		const perGap = extraSpace / info.wordGapCount;
-		if (exceedsThreshold(perGap, Math.max(getAverageWordWidth(info), Number.EPSILON), threshold)) return null;
-		return createJustifySpacing(perGap, 0);
-	}
-	if (mode !== "inter-character" || info.renderAtomCount === 0) return null;
-	const avgCharWidth = Math.max(getAverageCharWidth(info), Number.EPSILON);
-	if (info.wordGapCount === 0) {
-		const perGap = resolvePerGapSpacing(extraSpace, info.letterGapCount);
-		if (perGap == null) return null;
-		if (exceedsThreshold(perGap, avgCharWidth, threshold)) return null;
-		return createJustifySpacing(0, perGap);
-	}
-	const avgWordWidth = Math.max(getAverageWordWidth(info), Number.EPSILON);
-	const nonSpaceCount = Math.max(info.nonSpaceCount, 1);
-	const cjkRatio = info.cjkCount / nonSpaceCount;
-	const latinLikeRatio = info.latinLikeCount / nonSpaceCount;
-	const punctuationRatio = info.punctuationCount / nonSpaceCount;
-	const wordPenalty = 1 + cjkRatio;
-	const letterPenalty = 1 + latinLikeRatio + .5 * punctuationRatio;
-	let bestCandidate = null;
-	for (const wordShare of HYBRID_WORD_SHARE_CANDIDATES) {
-		const wordExtraSpace = extraSpace * wordShare;
-		const letterExtraSpace = extraSpace - wordExtraSpace;
-		const wordSpacingPx = resolvePerGapSpacing(wordExtraSpace, info.wordGapCount);
-		const letterSpacingPx = resolvePerGapSpacing(letterExtraSpace, info.letterGapCount);
-		if (wordSpacingPx == null || letterSpacingPx == null) continue;
-		if (exceedsThreshold(wordSpacingPx, avgWordWidth, threshold) || exceedsThreshold(letterSpacingPx, avgCharWidth, threshold)) continue;
-		const wordRatio = wordSpacingPx / avgWordWidth;
-		const letterRatio = letterSpacingPx / avgCharWidth;
-		const score = wordPenalty * wordRatio ** 2 + letterPenalty * letterRatio ** 2;
-		if (bestCandidate == null || score < bestCandidate.score - JUSTIFY_SCORE_EPSILON || Math.abs(score - bestCandidate.score) <= JUSTIFY_SCORE_EPSILON && wordShare > bestCandidate.wordShare) bestCandidate = {
-			spacing: createJustifySpacing(wordSpacingPx, letterSpacingPx),
-			score,
-			wordShare
-		};
-	}
-	return bestCandidate?.spacing ?? null;
-}
-//#endregion
-//#region src/nodes/text.ts
-function resolvePhysicalTextAlign(options) {
-	if (options.physicalAlign != null) return options.physicalAlign;
-	if (options.align != null) switch (options.align) {
-		case "start": return "left";
-		case "center": return "center";
-		case "end": return "right";
-	}
-	return "left";
-}
-function normalizeTextMaxWidth(maxWidth) {
-	if (maxWidth == null) return;
-	return Math.max(0, maxWidth);
-}
-const DEFAULT_TEXT_SPACING = {
-	wordSpacing: "0px",
-	letterSpacing: "0px"
-};
-function supportsTextSpacing(g) {
-	return typeof g.wordSpacing === "string" && typeof g.letterSpacing === "string";
+const DEFAULT_TEXT_SPACING = {
+	wordSpacing: "0px",
+	letterSpacing: "0px"
+};
+function supportsTextSpacing(g) {
+	return typeof g.wordSpacing === "string" && typeof g.letterSpacing === "string";
 }
 function withTextSpacing(g, spacing, cb) {
 	if (!supportsTextSpacing(g)) return cb();
@@ -3574,30 +3574,13 @@ var DebugRenderer = class extends BaseRenderer {
 	}
 };
 //#endregion
-//#region src/renderer/weak-listeners.ts
-function pruneWeakListenerMap(listeners) {
-	for (const [token, listener] of listeners) if (listener.ownerRef.deref() == null) listeners.delete(token);
-}
-function emitWeakListeners(listeners, event) {
-	for (const [token, listener] of [...listeners]) {
-		const owner = listener.ownerRef.deref();
-		if (owner == null) {
-			listeners.delete(token);
-			continue;
-		}
-		listener.notify(owner, event);
-	}
-}
-//#endregion
 //#region src/renderer/list-state.ts
-const listStateListeners = /* @__PURE__ */ new WeakMap();
-const listStateListenerRegistry = typeof FinalizationRegistry === "function" ? new FinalizationRegistry(({ listRef, token }) => {
-	const list = listRef.deref();
-	if (list == null) return;
-	deleteListStateListener(list, token);
-}) : null;
+const listStateChangeQueues = /* @__PURE__ */ new WeakMap();
 const listScrollMutations = /* @__PURE__ */ new WeakMap();
 const WRITE_LIST_SCROLL_STATE = Symbol("writeListScrollState");
+const FINALIZE_LIST_DELETE = Symbol("finalizeListDelete");
+const LIST_STATE_CHANGE_TIME = Symbol("listStateChangeTime");
+const LIST_STATE_CHANGE_SNAPSHOT = Symbol("listStateChangeSnapshot");
 function normalizePosition(value) {
 	return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : void 0;
 }
@@ -3630,34 +3613,43 @@ function readListScrollMutation(list) {
 function writeInternalListScrollState(list, state) {
 	list[WRITE_LIST_SCROLL_STATE](state, "internal");
 }
-function deleteListStateListener(list, token) {
-	const listeners = listStateListeners.get(list);
-	if (listeners == null) return;
-	listeners.delete(token);
-	if (listeners.size === 0) listStateListeners.delete(list);
-}
-function emitListStateChange(list, change) {
-	const listeners = listStateListeners.get(list);
-	if (listeners == null) return;
-	emitWeakListeners(listeners, change);
-	if (listeners.size === 0) listStateListeners.delete(list);
+function finalizeInternalListDelete(list, item) {
+	list[FINALIZE_LIST_DELETE](item);
 }
-function subscribeListState(list, owner, listener) {
+function enqueueListStateChange(list, change) {
 	const key = list;
-	let listeners = listStateListeners.get(key);
-	if (listeners == null) {
-		listeners = /* @__PURE__ */ new Map();
-		listStateListeners.set(key, listeners);
-	} else pruneWeakListenerMap(listeners);
-	const token = Symbol();
-	listeners.set(token, {
-		ownerRef: new WeakRef(owner),
-		notify: listener
+	let queue = listStateChangeQueues.get(key);
+	if (queue == null) {
+		queue = [];
+		listStateChangeQueues.set(key, queue);
+	}
+	const timestampedChange = change;
+	Object.defineProperty(timestampedChange, LIST_STATE_CHANGE_TIME, {
+		value: performance.now(),
+		configurable: true
 	});
-	listStateListenerRegistry?.register(owner, {
-		listRef: new WeakRef(key),
-		token
+	Object.defineProperty(timestampedChange, LIST_STATE_CHANGE_SNAPSHOT, {
+		value: {
+			items: [...list.items],
+			position: list.position,
+			offset: list.offset
+		},
+		configurable: true
 	});
+	queue.push(timestampedChange);
+}
+function drainInternalListStateChanges(list) {
+	const key = list;
+	const queue = listStateChangeQueues.get(key);
+	if (queue == null || queue.length === 0) return [];
+	listStateChangeQueues.delete(key);
+	return queue;
+}
+function readInternalListStateChangeTime(change) {
+	return change[LIST_STATE_CHANGE_TIME];
+}
+function readInternalListStateChangeSnapshot(change) {
+	return change[LIST_STATE_CHANGE_SNAPSHOT];
 }
 function isObjectIdentityCandidate(value) {
 	return typeof value === "object" && value !== null || typeof value === "function";
@@ -3706,16 +3698,10 @@ var ListState = class {
 	get offset() {
 		return this.#offset;
 	}
-	set offset(value) {
-		this.#writeScrollState({ offset: normalizeOffset$1(value) }, "external");
-	}
 	/** Anchor item index, or `undefined` to use the renderer default. */
 	get position() {
 		return this.#position;
 	}
-	set position(value) {
-		this.#writeScrollState({ position: normalizePosition(value) }, "external");
-	}
 	/** Items currently managed by the renderer. */
 	get items() {
 		return this.#items;
@@ -3726,7 +3712,7 @@ var ListState = class {
 		assertUniqueItemReferences(nextItems);
 		this.#items = nextItems;
 		this.#pendingDeletes.clear();
-		emitListStateChange(this, { type: "set" });
+		enqueueListStateChange(this, { type: "set" });
 	}
 	/**
 	* @param items Initial list items.
@@ -3747,7 +3733,7 @@ var ListState = class {
 		const normalizedAnimation = normalizeInsertAnimation(animation);
 		if (this.position != null) this.#writeScrollState({ position: this.position + items.length }, "internal");
 		this.#items = items.concat(this.#items);
-		emitListStateChange(this, {
+		enqueueListStateChange(this, {
 			type: "unshift",
 			count: items.length,
 			animation: normalizedAnimation
@@ -3763,7 +3749,7 @@ var ListState = class {
 		assertUniqueItemReferences(items, this.#items);
 		const normalizedAnimation = normalizeInsertAnimation(animation);
 		this.#items.push(...items);
-		emitListStateChange(this, {
+		enqueueListStateChange(this, {
 			type: "push",
 			count: items.length,
 			animation: normalizedAnimation
@@ -3781,7 +3767,7 @@ var ListState = class {
 		if (this.#items.includes(nextItem)) throw new Error("update() nextItem is already present in the list.");
 		const prevItem = this.#items[index];
 		this.#items[index] = nextItem;
-		emitListStateChange(this, {
+		enqueueListStateChange(this, {
 			type: "update",
 			prevItem,
 			nextItem,
@@ -3798,11 +3784,11 @@ var ListState = class {
 		const normalizedAnimation = normalizeDeleteAnimation(animation);
 		if (!((normalizedAnimation?.duration ?? 0) > 0)) {
 			this.#pendingDeletes.add(item);
-			this.finalizeDelete(item);
+			this[FINALIZE_LIST_DELETE](item);
 			return;
 		}
 		this.#pendingDeletes.add(item);
-		emitListStateChange(this, {
+		enqueueListStateChange(this, {
 			type: "delete",
 			item,
 			animation: normalizedAnimation
@@ -3811,7 +3797,7 @@ var ListState = class {
 	/**
 	* Finalizes a pending delete by removing the item from the list.
 	*/
-	finalizeDelete(item) {
+	[FINALIZE_LIST_DELETE](item) {
 		if (!this.#pendingDeletes.has(item)) return;
 		const index = this.#items.indexOf(item);
 		this.#pendingDeletes.delete(item);
@@ -3825,21 +3811,12 @@ var ListState = class {
 			if (this.position > index) this.#writeScrollState({ position: this.position - 1 }, "internal");
 			else if (this.position === index) this.#writeScrollState({ position: Math.min(index, this.#items.length - 1) }, "internal");
 		}
-		emitListStateChange(this, {
+		enqueueListStateChange(this, {
 			type: "delete-finalize",
 			item
 		});
 	}
 	/**
-	* Sets the current anchor item and pixel offset.
-	*/
-	setAnchor(position, offset = 0) {
-		this.#writeScrollState({
-			position: normalizePosition(position),
-			offset: normalizeOffset$1(offset)
-		}, "external");
-	}
-	/**
 	* Replaces all items and clears scroll state.
 	*/
 	reset(items = []) {
@@ -3851,14 +3828,7 @@ var ListState = class {
 			position: void 0,
 			offset: 0
 		}, "internal");
-		emitListStateChange(this, { type: "reset" });
-	}
-	/** Clears the current scroll anchor while keeping the items. */
-	resetScroll() {
-		this.#writeScrollState({
-			position: void 0,
-			offset: 0
-		}, "external");
+		enqueueListStateChange(this, { type: "reset" });
 	}
 	/** Applies a relative pixel scroll delta. */
 	applyScroll(delta) {
@@ -3948,7 +3918,22 @@ function memoRenderItemBy(keyOf, renderItem, options = {}) {
 	});
 }
 //#endregion
-//#region src/renderer/virtualized/base-animation.ts
+//#region src/renderer/virtualized/frame-session.ts
+function prepareFrameSession(params) {
+	let solution = params.resolveVisibleWindow(params.now);
+	params.captureVisibleItemSnapshot(solution);
+	const requestSettleRedraw = params.pruneTransitionAnimations(solution.window, params.now);
+	if (requestSettleRedraw) {
+		solution = params.resolveVisibleWindow(params.now);
+		params.captureVisibleItemSnapshot(solution);
+	}
+	return {
+		solution,
+		requestSettleRedraw
+	};
+}
+//#endregion
+//#region src/renderer/virtualized/virtualized-animation.ts
 const CONTROLLED_STATE_OFFSET_EPSILON = 1e-9;
 function clamp$1(value, min, max) {
 	return Math.min(Math.max(value, min), max);
@@ -4039,21 +4024,6 @@ function getNow() {
 	return globalThis.performance?.now() ?? Date.now();
 }
 //#endregion
-//#region src/renderer/virtualized/frame-session.ts
-function prepareFrameSession(params) {
-	let solution = params.resolveVisibleWindow(params.now);
-	params.captureVisibleItemSnapshot(solution);
-	const requestSettleRedraw = params.pruneTransitionAnimations(solution.window, params.now);
-	if (requestSettleRedraw) {
-		solution = params.resolveVisibleWindow(params.now);
-		params.captureVisibleItemSnapshot(solution);
-	}
-	return {
-		solution,
-		requestSettleRedraw
-	};
-}
-//#endregion
 //#region src/renderer/virtualized/jump-controller.ts
 var JumpController = class JumpController {
 	static TRANSITION_SETTLE_SNAP_DURATION = 120;
@@ -4064,6 +4034,10 @@ var JumpController = class JumpController {
 	#pendingAutoFollowRecomputeReasonTop = "init";
 	#pendingAutoFollowRecomputeReasonBottom = "init";
 	#pendingTransitionSettleReconcile = false;
+	#autoFollowObservationCountTop = 0;
+	#autoFollowObservationCountBottom = 0;
+	#pendingAutoFollowInvalidationTop = false;
+	#pendingAutoFollowInvalidationBottom = false;
 	#lastArmedAutoFollowBoundary;
 	#lastObservedRenderedAutoFollowTop = false;
 	#lastObservedRenderedAutoFollowBottom = false;
@@ -4145,12 +4119,32 @@ var JumpController = class JumpController {
 			block: boundary === "bottom" ? "end" : "start"
 		});
 	}
+	beginAutoFollowBoundaryObservation(boundary) {
+		if (boundary === "top") {
+			this.#autoFollowObservationCountTop += 1;
+			return;
+		}
+		this.#autoFollowObservationCountBottom += 1;
+	}
+	endAutoFollowBoundaryObservation(boundary) {
+		if (boundary === "top") {
+			this.#autoFollowObservationCountTop = Math.max(0, this.#autoFollowObservationCountTop - 1);
+			return;
+		}
+		this.#autoFollowObservationCountBottom = Math.max(0, this.#autoFollowObservationCountBottom - 1);
+	}
+	invalidateAutoFollowBoundary(boundary) {
+		if (boundary == null || boundary === "top") this.#pendingAutoFollowInvalidationTop = true;
+		if (boundary == null || boundary === "bottom") this.#pendingAutoFollowInvalidationBottom = true;
+	}
 	recomputeAutoFollowCapabilities(capabilities) {
 		const previouslyObservedDualBoundary = this.#lastObservedRenderedAutoFollowTop && this.#lastObservedRenderedAutoFollowBottom;
 		if (capabilities.top && capabilities.bottom && !previouslyObservedDualBoundary) {
 			this.#setAutoFollowBoundary("top", true, "dual-boundary-promotion");
 			this.#setAutoFollowBoundary("bottom", true, "dual-boundary-promotion");
 		}
+		this.#syncObservedOrInvalidatedBoundary("top", capabilities);
+		this.#syncObservedOrInvalidatedBoundary("bottom", capabilities);
 		if (this.#pendingAutoFollowRecomputeTop) {
 			this.#setAutoFollowBoundary("top", capabilities.top, `strict-recompute:${this.#pendingAutoFollowRecomputeReasonTop}`);
 			this.#pendingAutoFollowRecomputeTop = false;
@@ -4177,22 +4171,23 @@ var JumpController = class JumpController {
 	reconcileAutoFollowAfterTransitionSettle() {
 		this.#pendingTransitionSettleReconcile = true;
 	}
-	handleListStateChange(change) {
+	handleListStateChange(change, now = getNow()) {
 		switch (change.type) {
 			case "reset":
 			case "set":
 				this.#cancelJumpAnimation();
 				this.#clearPendingPostJumpBoundary();
 				this.#clearPendingTransitionSettleReconcile();
+				this.#clearAutoFollowObservationState();
 				this.#syncScrollMutationVersion();
 				this.#markAutoFollowRecompute(void 0, change.type);
 				return change;
 			case "push":
-			case "unshift": return this.#handleBoundaryInsert(change);
+			case "unshift": return this.#handleBoundaryInsert(change, now);
 			default: return change;
 		}
 	}
-	#handleBoundaryInsert(change) {
+	#handleBoundaryInsert(change, now) {
 		if (this.#handlePendingExternalScrollMutation()) return change;
 		this.#clearPendingTransitionSettleReconcile();
 		const followChange = this.#resolveAutoFollowChange(change);
@@ -4205,21 +4200,21 @@ var JumpController = class JumpController {
 			this.#lastArmedAutoFollowBoundary = followChange.boundary;
 		}
 		this.#clearPendingPostJumpBoundary();
-		this.#materializeAnimatedAnchor(getNow(), followChange.direction, followChange.count);
+		this.#materializeAnimatedAnchor(now, followChange.direction, followChange.count);
 		this.#startJumpToIndex(followChange.boundary === "bottom" ? this.#options.getItemCount() - 1 : 0, {
 			block: followChange.boundary === "bottom" ? "end" : "start",
 			duration: followChange.animation?.duration
-		});
+		}, now);
 		return change;
 	}
 	#cancelJumpAnimation() {
 		this.#jumpAnimation = void 0;
 	}
-	#startJumpToIndex(index, options) {
+	#startJumpToIndex(index, options, now = getNow()) {
 		const targetIndex = this.#options.clampItemIndex(index);
 		const targetBlock = options.block ?? this.#options.getDefaultJumpBlock();
 		const settleBoundary = this.#resolveBoundaryLatchTarget(targetIndex, targetBlock);
-		this.#materializeAnimatedAnchor(getNow());
+		this.#materializeAnimatedAnchor(now);
 		const currentState = this.#options.normalizeListState(this.#options.readListState());
 		const targetAnchor = this.#options.getTargetAnchor(targetIndex, targetBlock);
 		if (!(options.animated ?? true)) {
@@ -4252,7 +4247,7 @@ var JumpController = class JumpController {
 		}
 		this.#jumpAnimation = {
 			path,
-			startTime: getNow(),
+			startTime: now,
 			duration,
 			needsMoreFrames: true,
 			onComplete: options.onComplete
@@ -4306,6 +4301,12 @@ var JumpController = class JumpController {
 	#clearPendingTransitionSettleReconcile() {
 		this.#pendingTransitionSettleReconcile = false;
 	}
+	#clearAutoFollowObservationState() {
+		this.#autoFollowObservationCountTop = 0;
+		this.#autoFollowObservationCountBottom = 0;
+		this.#pendingAutoFollowInvalidationTop = false;
+		this.#pendingAutoFollowInvalidationBottom = false;
+	}
 	#materializeAnimatedAnchor(now, direction, count = 0) {
 		const animation = this.#jumpAnimation;
 		if (animation == null) return;
@@ -4320,6 +4321,20 @@ var JumpController = class JumpController {
 		if (boundary === "top") this.#canAutoFollowTop = value;
 		else this.#canAutoFollowBottom = value;
 	}
+	#syncObservedOrInvalidatedBoundary(boundary, capabilities) {
+		const isObserved = this.#readAutoFollowObservationCount(boundary) > 0;
+		const isInvalidated = boundary === "top" ? this.#pendingAutoFollowInvalidationTop : this.#pendingAutoFollowInvalidationBottom;
+		if (!isObserved && !isInvalidated) return;
+		this.#setAutoFollowBoundary(boundary, this.#readCapabilityForBoundary(capabilities, boundary), "transition-observation");
+		if (boundary === "top") {
+			this.#pendingAutoFollowInvalidationTop = false;
+			return;
+		}
+		this.#pendingAutoFollowInvalidationBottom = false;
+	}
+	#readAutoFollowObservationCount(boundary) {
+		return boundary === "top" ? this.#autoFollowObservationCountTop : this.#autoFollowObservationCountBottom;
+	}
 	#syncLastArmedBoundaryFromLatchedState() {
 		if (this.#canAutoFollowTop === this.#canAutoFollowBottom) return;
 		this.#lastArmedAutoFollowBoundary = this.#canAutoFollowTop ? "top" : "bottom";
@@ -4369,777 +4384,176 @@ var JumpController = class JumpController {
 	}
 };
 //#endregion
-//#region src/renderer/virtualized/transition-snapshot.ts
-var VisibilitySnapshot = class {
-	#drawnItems = /* @__PURE__ */ new Set();
-	#visibleItems = /* @__PURE__ */ new Set();
-	#previousVisibleItems = /* @__PURE__ */ new Set();
-	#hasSnapshot = false;
-	#snapshotState;
-	#previousSnapshotState;
-	#emptyState;
-	#coversShortList = false;
-	#atStartBoundary = false;
-	#atEndBoundary = false;
-	#minDrawnIndex = Number.POSITIVE_INFINITY;
-	#maxDrawnIndex = Number.NEGATIVE_INFINITY;
-	#topBoundaryItem;
-	#bottomBoundaryItem;
-	get coversShortList() {
-		return this.#hasSnapshot && this.#snapshotState != null && this.#coversShortList;
-	}
-	get hasSnapshot() {
-		return this.#hasSnapshot;
-	}
-	get previousState() {
-		return this.#previousSnapshotState;
-	}
-	readDrawnIndexRange() {
-		if (!Number.isFinite(this.#minDrawnIndex) || !Number.isFinite(this.#maxDrawnIndex)) return;
-		return {
-			minIndex: this.#minDrawnIndex,
-			maxIndex: this.#maxDrawnIndex
-		};
-	}
-	readBoundaryItem(boundary) {
-		return boundary === "top" ? this.#topBoundaryItem : this.#bottomBoundaryItem;
-	}
-	capture(window, _resolutionPath, items, viewport, snapshotState, readVisibleRange, readOuterVisibleRange) {
-		this.#previousVisibleItems = this.#visibleItems;
-		this.#previousSnapshotState = this.#snapshotState;
-		const nextDrawnItems = /* @__PURE__ */ new Set();
-		const nextVisibleItems = /* @__PURE__ */ new Set();
-		let minVisibleIndex = Number.POSITIVE_INFINITY;
-		let maxVisibleIndex = Number.NEGATIVE_INFINITY;
-		let topMostY = Number.POSITIVE_INFINITY;
-		let bottomMostY = Number.NEGATIVE_INFINITY;
-		let nextMinDrawnIndex = Number.POSITIVE_INFINITY;
-		let nextMaxDrawnIndex = Number.NEGATIVE_INFINITY;
-		let nextTopBoundaryItem;
-		let nextBottomBoundaryItem;
-		let nextTopBoundaryY = Number.POSITIVE_INFINITY;
-		let nextBottomBoundaryY = Number.NEGATIVE_INFINITY;
-		const effectiveShift = window.shift;
-		const contentOriginY = viewport.contentTop;
-		for (const { idx, offset, height } of window.drawList) {
-			const y = offset + effectiveShift + contentOriginY;
-			topMostY = Math.min(topMostY, y);
-			bottomMostY = Math.max(bottomMostY, y + height);
-			const item = items[idx];
-			if (item != null && readOuterVisibleRange(y, height) != null) {
-				nextDrawnItems.add(item);
-				nextMinDrawnIndex = Math.min(nextMinDrawnIndex, idx);
-				nextMaxDrawnIndex = Math.max(nextMaxDrawnIndex, idx);
-			}
-			if (item == null) continue;
-			if (readVisibleRange(y, height) != null) {
-				minVisibleIndex = Math.min(minVisibleIndex, idx);
-				maxVisibleIndex = Math.max(maxVisibleIndex, idx);
-				nextVisibleItems.add(item);
-				if (y < nextTopBoundaryY) {
-					nextTopBoundaryY = y;
-					nextTopBoundaryItem = item;
-				}
-				if (y + height > nextBottomBoundaryY) {
-					nextBottomBoundaryY = y + height;
-					nextBottomBoundaryItem = item;
-				}
-			}
-		}
-		this.#drawnItems = nextDrawnItems;
-		this.#visibleItems = nextVisibleItems;
-		this.#hasSnapshot = true;
-		this.#snapshotState = snapshotState;
-		this.#minDrawnIndex = nextMinDrawnIndex;
-		this.#maxDrawnIndex = nextMaxDrawnIndex;
-		this.#topBoundaryItem = nextTopBoundaryItem;
-		this.#bottomBoundaryItem = nextBottomBoundaryItem;
-		this.#emptyState = items.length === 0 && window.drawList.length === 0 ? snapshotState : void 0;
-		const contentHeight = bottomMostY - topMostY;
-		this.#coversShortList = window.drawList.length > 0 && items.length > 0 && window.drawList.length === items.length && minVisibleIndex === 0 && maxVisibleIndex === items.length - 1 && topMostY >= viewport.contentTop - 1e-6 && bottomMostY <= viewport.contentBottom + 1e-6 && contentHeight < viewport.contentHeight - 1e-6;
-		this.#atStartBoundary = window.drawList.length > 0 && items.length > 0 && minVisibleIndex === 0 && topMostY >= viewport.contentTop - 1e-6;
-		this.#atEndBoundary = window.drawList.length > 0 && items.length > 0 && maxVisibleIndex === items.length - 1 && bottomMostY <= viewport.contentBottom + 1e-6;
-	}
-	matchesCurrentState(position, offset) {
-		return this.#hasSnapshot && this.#snapshotState != null && sameState(this.#snapshotState, position, offset);
-	}
-	matchesBoundaryInsertState(direction, count, position, offset) {
-		if (!this.coversShortList || this.#snapshotState == null) return false;
-		return this.#matchesStateAfterBoundaryInsert(direction, count, position, offset);
-	}
-	matchesFollowBoundaryInsertState(direction, count, position, offset) {
-		if (!this.#hasSnapshot || this.#snapshotState == null) return false;
-		if (direction === "push" ? !this.#atEndBoundary : !this.#atStartBoundary) return false;
-		return this.#matchesStateAfterBoundaryInsert(direction, count, position, offset);
-	}
-	matchesEmptyBoundaryInsertState(direction, count, position, offset) {
-		const emptyState = this.#emptyState;
-		if (!this.#hasSnapshot || emptyState == null) return false;
-		return sameState({
-			position: direction === "unshift" && emptyState.position != null ? emptyState.position + count : emptyState.position,
-			offset: emptyState.offset
-		}, position, offset);
-	}
-	isVisible(item) {
-		return this.#visibleItems.has(item);
-	}
-	wasVisible(item) {
-		return this.#previousVisibleItems.has(item);
-	}
-	tracks(item, retention) {
-		return retention === "drawn" ? this.#drawnItems.has(item) : this.#visibleItems.has(item);
-	}
-	reset() {
-		this.#drawnItems.clear();
-		this.#visibleItems.clear();
-		this.#previousVisibleItems.clear();
-		this.#hasSnapshot = false;
-		this.#snapshotState = void 0;
-		this.#previousSnapshotState = void 0;
-		this.#emptyState = void 0;
-		this.#coversShortList = false;
-		this.#atStartBoundary = false;
-		this.#atEndBoundary = false;
-		this.#minDrawnIndex = Number.POSITIVE_INFINITY;
-		this.#maxDrawnIndex = Number.NEGATIVE_INFINITY;
-		this.#topBoundaryItem = void 0;
-		this.#bottomBoundaryItem = void 0;
-	}
-	#matchesStateAfterBoundaryInsert(direction, count, position, offset) {
-		const snapshotState = this.#snapshotState;
-		if (snapshotState == null) return false;
-		return sameState({
-			position: direction === "unshift" && snapshotState.position != null ? snapshotState.position + count : snapshotState.position,
-			offset: snapshotState.offset
-		}, position, offset);
-	}
-};
-//#endregion
-//#region src/renderer/virtualized/transition-store.ts
-var TransitionStore = class {
-	#transitions = /* @__PURE__ */ new Map();
-	get size() {
-		return this.#transitions.size;
-	}
-	has(item) {
-		return this.#transitions.has(item);
-	}
-	set(item, transition) {
-		this.#transitions.set(item, transition);
-	}
-	replace(prevItem, nextItem, transition) {
-		this.#transitions.delete(prevItem);
-		this.#transitions.set(nextItem, transition);
-	}
-	delete(item) {
-		const transition = this.#transitions.get(item);
-		if (transition != null) this.#transitions.delete(item);
-		return transition;
-	}
-	readActive(item, now) {
-		const transition = this.#transitions.get(item);
-		if (transition == null) return;
-		return this.#isComplete(transition, now) ? void 0 : transition;
-	}
-	prepare(now) {
-		for (const transition of this.#transitions.values()) if (!this.#isComplete(transition, now)) return true;
-		return false;
-	}
-	findCompleted(now) {
-		return [...this.#transitions.entries()].filter(([, transition]) => this.#isComplete(transition, now)).map(([item, transition]) => ({
-			item,
-			transition
-		}));
-	}
-	findInvisible(snapshot) {
-		return [...this.#transitions.entries()].filter(([item, transition]) => !snapshot.tracks(item, transition.retention) && !(transition.kind === "insert" && !snapshot.wasVisible(item))).map(([item, transition]) => ({
-			item,
-			transition
-		}));
-	}
-	reset() {
-		this.#transitions.clear();
-	}
-	#isComplete(transition, now) {
-		return getProgress(transition.height.startTime, transition.height.duration, now) >= 1;
-	}
-};
-//#endregion
-//#region src/renderer/virtualized/transition-planner.ts
-function normalizeDuration(duration) {
-	return Math.max(0, typeof duration === "number" && Number.isFinite(duration) ? duration : 0);
+//#region src/renderer/virtualized/solver.ts
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
 }
-function createScalarAnimation(from, to, startTime, duration) {
-	return {
-		from,
-		to,
-		startTime,
-		duration
-	};
+function normalizeOffset(offset) {
+	return Number.isFinite(offset) ? offset : 0;
 }
-function createLayerAnimation(node, fromAlpha, toAlpha, startTime, duration, fromTranslateY, toTranslateY) {
+function normalizeListPadding(padding) {
 	return {
-		node,
-		alpha: createScalarAnimation(fromAlpha, toAlpha, startTime, duration),
-		translateY: createScalarAnimation(fromTranslateY, toTranslateY, startTime, duration)
+		top: typeof padding?.top === "number" && Number.isFinite(padding.top) ? Math.max(0, padding.top) : 0,
+		bottom: typeof padding?.bottom === "number" && Number.isFinite(padding.bottom) ? Math.max(0, padding.bottom) : 0
 	};
 }
-function findVisibleEntry(index, resolveVisibleWindow, readVisibleRange) {
-	if (index < 0) return;
-	const solution = resolveVisibleWindow();
-	for (const entry of solution.window.drawList) {
-		if (entry.idx !== index) continue;
-		if (readVisibleRange(entry.offset + solution.window.shift, entry.height) != null) return entry;
-	}
-}
-function isIndexVisible(index, resolveVisibleWindow, readVisibleRange) {
-	return findVisibleEntry(index, resolveVisibleWindow, readVisibleRange) != null;
-}
-function resolveAnimationEligibility(params) {
-	if (params.index < 0) return false;
-	if (params.snapshot.matchesCurrentState(params.position, params.offset)) return params.snapshot.tracks(params.item, "drawn");
-	return isIndexVisible(params.index, params.resolveVisibleWindow, params.readOuterVisibleRange);
-}
-function hasVisibleBoundaryInsertItems(direction, count, ctx) {
-	if (count <= 0) return false;
-	const start = direction === "push" ? ctx.items.length - count : 0;
-	const end = direction === "push" ? ctx.items.length : Math.min(count, ctx.items.length);
-	if (start < 0 || end <= start) return false;
-	const solution = ctx.resolveVisibleWindow();
-	return solution.window.drawList.some((entry) => entry.idx >= start && entry.idx < end && ctx.readOuterVisibleRange(entry.offset + solution.window.shift, entry.height) != null);
-}
-function sampleScalarAnimation(animation, now) {
-	return interpolate(animation.from, animation.to, animation.startTime, animation.duration, now);
-}
-function sampleLayerAnimation(layer, now) {
-	const alpha = sampleScalarAnimation(layer.alpha, now);
-	if (alpha <= .001) return;
+function resolveListViewport(outerHeight, padding) {
+	const height = typeof outerHeight === "number" && Number.isFinite(outerHeight) ? Math.max(0, outerHeight) : 0;
+	const resolvedPadding = normalizeListPadding(padding);
+	const contentTop = resolvedPadding.top;
+	const contentBottom = Math.max(contentTop, height - resolvedPadding.bottom);
 	return {
-		alpha,
-		node: layer.node,
-		translateY: sampleScalarAnimation(layer.translateY, now)
+		outerHeight: height,
+		contentTop,
+		contentBottom,
+		contentHeight: contentBottom - contentTop,
+		outerContentTop: -contentTop,
+		outerContentBottom: height - contentTop
 	};
 }
-function sampleTransition(transition, now) {
+function resolveListLayoutOptions(options = {}) {
 	return {
-		kind: transition.kind,
-		slotHeight: sampleScalarAnimation(transition.height, now),
-		layers: transition.layers.map((layer) => sampleLayerAnimation(layer, now)).filter((layer) => layer != null),
-		retention: transition.retention
+		anchorMode: options.anchorMode ?? "top",
+		underflowAlign: options.underflowAlign ?? "top",
+		padding: normalizeListPadding(options.padding)
 	};
 }
-function planExistingItemTransition(params) {
-	if (!params.canAnimate || params.duration <= 0) return;
-	if (params.kind === "update" && !Number.isFinite(params.nextHeight)) return;
-	const layers = [];
-	if (params.currentVisualState.alpha > .001) layers.push(createLayerAnimation(params.currentVisualState.node, params.currentVisualState.alpha, 0, params.now, params.duration, params.currentVisualState.translateY, 0));
-	if (params.kind === "update") {
-		layers.push(createLayerAnimation(params.nextNode, 0, 1, params.now, params.duration, params.currentVisualState.translateY, 0));
-		return {
-			kind: "update",
-			layers,
-			height: createScalarAnimation(params.currentVisualState.height, params.nextHeight, params.now, params.duration),
-			retention: "drawn"
-		};
-	}
+function normalizeVisibleState(itemCount, state, layout) {
+	if (itemCount <= 0) return {
+		position: 0,
+		offset: 0
+	};
+	const position = state.position;
+	const fallbackPosition = layout.anchorMode === "top" ? 0 : itemCount - 1;
+	if (typeof position !== "number" || !Number.isFinite(position)) return {
+		position: fallbackPosition,
+		offset: normalizeOffset(state.offset)
+	};
 	return {
-		kind: "delete",
-		layers,
-		height: createScalarAnimation(params.currentVisualState.height, 0, params.now, params.duration),
-		retention: "drawn"
+		position: clamp(Math.trunc(position), 0, itemCount - 1),
+		offset: normalizeOffset(state.offset)
 	};
 }
-function planBoundaryInsertItems(params) {
-	const entries = [];
-	for (const { item, node, height } of params.measuredItems) {
-		if (!Number.isFinite(height) || height < 0) return;
-		entries.push({
-			item,
-			transition: {
-				kind: "insert",
-				layers: [createLayerAnimation(node, 0, 1, params.now, params.duration, 0, 0)],
-				height: createScalarAnimation(params.animateHeight ? 0 : height, height, params.now, params.duration),
-				retention: "drawn"
-			}
-		});
-	}
-	return entries.length === 0 ? void 0 : { entries };
-}
-function measureBoundaryInsertItems(direction, count, ctx) {
-	const start = direction === "push" ? ctx.items.length - count : 0;
-	const end = direction === "push" ? ctx.items.length : Math.min(count, ctx.items.length);
-	if (start < 0 || end < start) return;
-	const measured = [];
-	for (let index = start; index < end; index += 1) {
-		const item = ctx.items[index];
-		if (item == null) continue;
-		const node = ctx.renderItem(item);
-		const height = ctx.measureNode(node).height;
-		measured.push({
-			item,
-			node,
-			height
-		});
-	}
-	return measured;
-}
-function drawSampledLayers(sampled, y, adapter) {
-	if (sampled.slotHeight <= 0) return false;
-	let result = false;
-	for (const layer of sampled.layers) {
-		const alpha = clamp$1(layer.alpha, 0, 1);
-		if (alpha <= .001) continue;
-		adapter.graphics.save();
-		try {
-			if (sampled.kind === "insert") {
-				adapter.graphics.beginPath();
-				adapter.graphics.rect(0, y, adapter.graphics.canvas.clientWidth, sampled.slotHeight);
-				adapter.graphics.clip();
-			}
-			if (typeof adapter.graphics.globalAlpha === "number") adapter.graphics.globalAlpha *= alpha;
-			if (adapter.drawNode(layer.node, 0, y + layer.translateY)) result = true;
-		} finally {
-			adapter.graphics.restore();
+function resolveVisibleWindow(items, state, viewportHeight, resolveItem, layout) {
+	const viewport = typeof viewportHeight === "number" ? resolveListViewport(viewportHeight, layout.padding) : viewportHeight;
+	const contentHeight = viewport.contentHeight;
+	const normalizedState = normalizeVisibleState(items.length, state, layout);
+	const resolutionPath = /* @__PURE__ */ new Set();
+	const readResolvedItem = (item, idx) => {
+		resolutionPath.add(idx);
+		return resolveItem(item, idx);
+	};
+	if (items.length === 0) return {
+		normalizedState,
+		resolutionPath: [],
+		window: {
+			drawList: [],
+			shift: 0
 		}
-	}
-	return result;
-}
-function planUpdateTransition(prevItem, nextItem, duration, now, currentVisualState, ctx, snapshot, store) {
-	const nextIndex = ctx.items.indexOf(nextItem);
-	const nextNode = ctx.renderItem(nextItem);
-	const nextHeight = ctx.measureNode(nextNode).height;
-	return planExistingItemTransition({
-		kind: "update",
-		duration: normalizeDuration(duration),
-		canAnimate: resolveAnimationEligibility({
-			index: nextIndex,
-			item: prevItem,
-			position: ctx.position,
-			offset: ctx.offset,
-			snapshot,
-			hasActiveTransition: store.has(prevItem),
-			resolveVisibleWindow: ctx.resolveVisibleWindow,
-			readOuterVisibleRange: ctx.readOuterVisibleRange
-		}),
-		now,
-		currentVisualState,
-		nextNode,
-		nextHeight
-	});
-}
-function planDeleteTransition(item, duration, now, currentVisualState, ctx, snapshot, store) {
-	const index = ctx.items.indexOf(item);
-	return planExistingItemTransition({
-		kind: "delete",
-		duration: normalizeDuration(duration),
-		canAnimate: resolveAnimationEligibility({
-			index,
-			item,
-			position: ctx.position,
-			offset: ctx.offset,
-			snapshot,
-			hasActiveTransition: store.has(item),
-			resolveVisibleWindow: ctx.resolveVisibleWindow,
-			readOuterVisibleRange: ctx.readOuterVisibleRange
-		}),
-		now,
-		currentVisualState
-	});
-}
-function planBoundaryInsertTransition(direction, count, duration, now, ctx, snapshot) {
-	const normalizedDuration = normalizeDuration(duration);
-	if (count <= 0 || normalizedDuration <= 0) return;
-	const matchesBoundaryState = snapshot.matchesBoundaryInsertState(direction, count, ctx.position, ctx.offset);
-	const matchesFollowState = snapshot.matchesFollowBoundaryInsertState(direction, count, ctx.position, ctx.offset);
-	const matchesEmptyState = snapshot.matchesEmptyBoundaryInsertState(direction, count, ctx.position, ctx.offset);
-	if (!(matchesBoundaryState || matchesFollowState || matchesEmptyState || snapshot.hasSnapshot && hasVisibleBoundaryInsertItems(direction, count, ctx))) return;
-	const animateHeight = !(direction === "unshift" && matchesFollowState && !matchesBoundaryState && !matchesEmptyState);
-	const measuredItems = measureBoundaryInsertItems(direction, count, ctx);
-	if (measuredItems == null) return;
-	return planBoundaryInsertItems({
-		duration: normalizedDuration,
-		animateHeight,
-		now,
-		measuredItems
-	});
-}
-function getTransitionedItemHeight(item, now, store, adapter) {
-	const transition = store.readActive(item, now);
-	if (transition != null) return sampleTransition(transition, now).slotHeight;
-	const node = adapter.renderItem(item);
-	return adapter.measureNode(node).height;
-}
-function resolveTransitionedItem(item, now, store, adapter, lifecycle) {
-	const transition = store.readActive(item, now);
-	if (transition == null) {
-		const node = adapter.renderItem(item);
-		return {
-			value: {
-				draw: (y) => adapter.drawNode(node, 0, y),
-				hittest: (test, y) => node.hittest(adapter.getRootContext(), {
-					...test,
-					y: test.y - y
-				})
-			},
-			height: adapter.measureNode(node).height
-		};
-	}
-	const sampled = sampleTransition(transition, now);
-	return {
-		value: {
-			draw: (y) => drawSampledLayers(sampled, y, adapter),
-			hittest: () => false
-		},
-		height: sampled.slotHeight
-	};
-}
-function readCurrentVisualState(item, now, store, adapter) {
-	const transition = store.readActive(item, now);
-	if (transition != null && transition.layers.length > 0) {
-		const primaryLayer = transition.layers[transition.layers.length - 1];
-		return {
-			node: primaryLayer.node,
-			alpha: sampleScalarAnimation(primaryLayer.alpha, now),
-			height: sampleScalarAnimation(transition.height, now),
-			translateY: sampleScalarAnimation(primaryLayer.translateY, now)
-		};
-	}
-	const node = adapter.renderItem(item);
-	return {
-		node,
-		alpha: 1,
-		height: adapter.measureNode(node).height,
-		translateY: 0
 	};
-}
-function handleTransitionStateChange(store, snapshot, change, ctx, lifecycle) {
-	switch (change.type) {
-		case "update": {
-			const now = getNow();
-			const currentVisualState = readCurrentVisualState(change.prevItem, now, store, ctx);
-			const transition = planUpdateTransition(change.prevItem, change.nextItem, change.animation?.duration, now, currentVisualState, ctx, snapshot, store);
-			if (transition == null) {
-				store.delete(change.prevItem);
-				return;
+	if (layout.anchorMode === "top") {
+		let { position, offset } = normalizedState;
+		let drawLength = 0;
+		if (offset > 0) if (position === 0) offset = 0;
+		else {
+			for (let i = position - 1; i >= 0; i -= 1) {
+				const { height } = readResolvedItem(items[i], i);
+				position = i;
+				offset -= height;
+				if (offset <= 0) break;
 			}
-			store.replace(change.prevItem, change.nextItem, transition);
-			return;
+			if (position === 0 && offset > 0) offset = 0;
 		}
-		case "delete": {
-			const now = getNow();
-			const currentVisualState = readCurrentVisualState(change.item, now, store, ctx);
-			const transition = planDeleteTransition(change.item, change.animation?.duration, now, currentVisualState, ctx, snapshot, store);
-			if (transition == null) {
-				store.delete(change.item);
-				lifecycle.onDeleteComplete(change.item);
-				return;
+		let y = offset;
+		const drawList = [];
+		for (let i = position; i < items.length; i += 1) {
+			const { value, height } = readResolvedItem(items[i], i);
+			if (y + height > 0) {
+				drawList.push({
+					index: i,
+					value,
+					offset: y,
+					height
+				});
+				drawLength += height;
+			} else {
+				offset += height;
+				position = i + 1;
 			}
-			store.set(change.item, transition);
-			return;
+			y += height;
+			if (y >= contentHeight) break;
 		}
-		case "delete-finalize":
-			store.delete(change.item);
-			return;
-		case "unshift":
-		case "push": {
-			const now = getNow();
-			const plan = planBoundaryInsertTransition(change.type, change.count, change.animation?.duration, now, ctx, snapshot);
-			if (plan == null) return;
-			for (const entry of plan.entries) store.set(entry.item, entry.transition);
-			if (ctx.position == null && snapshot.coversShortList && (change.type === "push" && ctx.anchorMode === "bottom" || change.type === "unshift" && ctx.anchorMode === "top")) {
-				const boundary = change.type === "push" ? "bottom" : "top";
-				const boundaryItem = snapshot.readBoundaryItem(boundary);
-				if (boundaryItem != null) lifecycle.snapItemToViewportBoundary(boundaryItem, boundary);
+		let shift = 0;
+		if (y < contentHeight) {
+			if (drawList.length > 0 && drawList.at(-1)?.index === items.length - 1 && !(drawList.at(-1)?.height > Number.EPSILON)) return finalizeVisibleWindowResult(items.length, viewport, layout, {
+				position,
+				offset
+			}, Array.from(resolutionPath), extendVisibleWindowToOuterBounds(items, {
+				drawList,
+				shift
+			}, viewport, readResolvedItem));
+			if (position === 0 && drawLength < contentHeight) {
+				shift = -offset;
+				offset = 0;
+			} else {
+				shift = contentHeight - y;
+				y = offset += shift;
+				let lastIdx = -1;
+				for (let i = position - 1; i >= 0; i -= 1) {
+					const { value, height } = readResolvedItem(items[i], i);
+					drawLength += height;
+					y -= height;
+					drawList.push({
+						index: i,
+						value,
+						offset: y - shift,
+						height
+					});
+					lastIdx = i;
+					if (y < 0) break;
+				}
+				if (lastIdx === 0 && drawLength < contentHeight) {
+					shift = drawList.at(-1)?.offset == null ? 0 : -drawList.at(-1).offset;
+					position = 0;
+					offset = 0;
+				}
 			}
-			return;
-		}
-		case "reset":
-		case "set":
-			store.reset();
-			snapshot.reset();
-			return;
-	}
-}
-//#endregion
-//#region src/renderer/virtualized/base-transition.ts
-function remapAnchorAfterDeletes(anchor, deletedIndices) {
-	if (!Number.isFinite(anchor) || deletedIndices.length === 0) return anchor;
-	const sortedIndices = [...deletedIndices].filter((index) => Number.isFinite(index) && index >= 0).sort((a, b) => a - b);
-	let removedBeforeAnchor = 0;
-	for (const index of sortedIndices) {
-		if (anchor > index + 1) {
-			removedBeforeAnchor += 1;
-			continue;
 		}
-		if (anchor >= index) return index - removedBeforeAnchor;
-	}
-	return anchor - removedBeforeAnchor;
-}
-var TransitionController = class {
-	#store = new TransitionStore();
-	#snapshot = new VisibilitySnapshot();
-	captureVisibilitySnapshot(window, resolutionPath, items, viewport, snapshotState, readVisibleRange, readOuterVisibleRange) {
-		this.#snapshot.capture(window, resolutionPath, items, viewport, snapshotState, readVisibleRange, readOuterVisibleRange);
-	}
-	pruneInvisible(ctx, lifecycle) {
-		return this.pruneInvisibleAt(getNow(), ctx, lifecycle);
-	}
-	prepare(now, lifecycle) {
-		this.settle(now, lifecycle);
-		return this.#store.prepare(now);
+		return finalizeVisibleWindowResult(items.length, viewport, layout, {
+			position,
+			offset
+		}, Array.from(resolutionPath), extendVisibleWindowToOuterBounds(items, {
+			drawList,
+			shift
+		}, viewport, readResolvedItem));
 	}
-	canAutoFollowBoundaryInsert(direction, count, position, offset) {
-		return this.#snapshot.matchesFollowBoundaryInsertState(direction, count, position, offset);
+	let { position, offset } = normalizedState;
+	let drawLength = 0;
+	if (offset < 0) if (position === items.length - 1) offset = 0;
+	else for (let i = position + 1; i < items.length; i += 1) {
+		const { height } = readResolvedItem(items[i], i);
+		position = i;
+		offset += height;
+		if (offset > 0) break;
 	}
-	getItemHeight(item, now, adapter) {
-		return getTransitionedItemHeight(item, now, this.#store, adapter);
-	}
-	resolveItem(item, now, adapter, lifecycle) {
-		return resolveTransitionedItem(item, now, this.#store, adapter, lifecycle);
-	}
-	handleListStateChange(change, ctx, lifecycle) {
-		const now = getNow();
-		this.settle(now, lifecycle);
-		handleTransitionStateChange(this.#store, this.#snapshot, change, ctx, lifecycle);
-	}
-	settle(now, lifecycle) {
-		return this.#settleTransitions(this.#store.findCompleted(now), now, lifecycle);
-	}
-	pruneInvisibleAt(now, ctx, lifecycle) {
-		const removals = this.#store.findInvisible(this.#snapshot);
-		return this.#settleTransitions(removals, now, lifecycle, this.#resolveNaturalBoundarySnap(removals, now, ctx, lifecycle));
-	}
-	reset() {
-		this.#store.reset();
-		this.#snapshot.reset();
-	}
-	#settleTransitions(removals, now, lifecycle, boundarySnap) {
-		if (removals.length === 0) return false;
-		const anchor = lifecycle.captureVisualAnchor(now);
-		const beforeState = lifecycle.readScrollState();
-		const completedDeleteIndices = [];
-		for (const { item, transition } of removals) {
-			if (transition.kind === "delete") {
-				const index = lifecycle.readItemIndex(item);
-				if (index >= 0) completedDeleteIndices.push(index);
-			}
-			this.#store.delete(item);
-			if (transition.kind === "delete") lifecycle.onDeleteComplete(item);
-		}
-		if (anchor != null && Number.isFinite(anchor)) lifecycle.restoreVisualAnchor(remapAnchorAfterDeletes(anchor, completedDeleteIndices));
-		if (boundarySnap != null) lifecycle.snapItemToViewportBoundary(boundarySnap.item, boundarySnap.boundary);
-		const afterState = lifecycle.readScrollState();
-		if (!sameState(beforeState, afterState.position, afterState.offset)) lifecycle.onTransitionSettleScrollAdjusted();
-		return true;
-	}
-	#resolveNaturalBoundarySnap(removals, now, ctx, lifecycle) {
-		const previousState = this.#snapshot.previousState;
-		const drawnRange = this.#snapshot.readDrawnIndexRange();
-		if (previousState == null || drawnRange == null) return;
-		const naturalIndices = [];
-		for (const { item, transition } of removals) {
-			if (transition.kind !== "update" && transition.kind !== "delete") continue;
-			const index = lifecycle.readItemIndex(item);
-			if (index < 0 || !this.#snapshot.wasVisible(item)) return;
-			if (this.#isTransitionVisibleInState(index, previousState, now, ctx)) return;
-			naturalIndices.push(index);
-		}
-		if (naturalIndices.length === 0) return;
-		if (naturalIndices.every((index) => index < drawnRange.minIndex)) {
-			const item = this.#snapshot.readBoundaryItem("top");
-			return item == null ? void 0 : {
-				item,
-				boundary: "top"
-			};
-		}
-		if (naturalIndices.every((index) => index > drawnRange.maxIndex)) {
-			const item = this.#snapshot.readBoundaryItem("bottom");
-			return item == null ? void 0 : {
-				item,
-				boundary: "bottom"
-			};
-		}
-	}
-	#isTransitionVisibleInState(index, state, now, ctx) {
-		const solution = ctx.resolveVisibleWindowForState(state, now);
-		for (const entry of solution.window.drawList) {
-			if (entry.idx !== index) continue;
-			return ctx.readOuterVisibleRange(entry.offset + solution.window.shift, entry.height) != null;
-		}
-		return false;
-	}
-};
-//#endregion
-//#region src/renderer/virtualized/solver.ts
-function clamp(value, min, max) {
-	return Math.min(Math.max(value, min), max);
-}
-function normalizeOffset(offset) {
-	return Number.isFinite(offset) ? offset : 0;
-}
-function normalizeListPadding(padding) {
-	return {
-		top: typeof padding?.top === "number" && Number.isFinite(padding.top) ? Math.max(0, padding.top) : 0,
-		bottom: typeof padding?.bottom === "number" && Number.isFinite(padding.bottom) ? Math.max(0, padding.bottom) : 0
-	};
-}
-function resolveListViewport(outerHeight, padding) {
-	const height = typeof outerHeight === "number" && Number.isFinite(outerHeight) ? Math.max(0, outerHeight) : 0;
-	const resolvedPadding = normalizeListPadding(padding);
-	const contentTop = resolvedPadding.top;
-	const contentBottom = Math.max(contentTop, height - resolvedPadding.bottom);
-	return {
-		outerHeight: height,
-		contentTop,
-		contentBottom,
-		contentHeight: contentBottom - contentTop,
-		outerContentTop: -contentTop,
-		outerContentBottom: height - contentTop
-	};
-}
-function resolveListLayoutOptions(options = {}) {
-	return {
-		anchorMode: options.anchorMode ?? "top",
-		underflowAlign: options.underflowAlign ?? "top",
-		padding: normalizeListPadding(options.padding)
-	};
-}
-function normalizeVisibleState(itemCount, state, layout) {
-	if (itemCount <= 0) return {
-		position: 0,
-		offset: 0
-	};
-	const position = state.position;
-	const fallbackPosition = layout.anchorMode === "top" ? 0 : itemCount - 1;
-	if (typeof position !== "number" || !Number.isFinite(position)) return {
-		position: fallbackPosition,
-		offset: normalizeOffset(state.offset)
-	};
-	return {
-		position: clamp(Math.trunc(position), 0, itemCount - 1),
-		offset: normalizeOffset(state.offset)
-	};
-}
-function resolveVisibleWindow(items, state, viewportHeight, resolveItem, layout) {
-	const viewport = typeof viewportHeight === "number" ? resolveListViewport(viewportHeight, layout.padding) : viewportHeight;
-	const contentHeight = viewport.contentHeight;
-	const normalizedState = normalizeVisibleState(items.length, state, layout);
-	const resolutionPath = /* @__PURE__ */ new Set();
-	const readResolvedItem = (item, idx) => {
-		resolutionPath.add(idx);
-		return resolveItem(item, idx);
-	};
-	if (items.length === 0) return {
-		normalizedState,
-		resolutionPath: [],
-		window: {
-			drawList: [],
-			shift: 0
-		}
-	};
-	if (layout.anchorMode === "top") {
-		let { position, offset } = normalizedState;
-		let drawLength = 0;
-		if (offset > 0) if (position === 0) offset = 0;
-		else {
-			for (let i = position - 1; i >= 0; i -= 1) {
-				const { height } = readResolvedItem(items[i], i);
-				position = i;
-				offset -= height;
-				if (offset <= 0) break;
-			}
-			if (position === 0 && offset > 0) offset = 0;
-		}
-		let y = offset;
-		const drawList = [];
-		for (let i = position; i < items.length; i += 1) {
-			const { value, height } = readResolvedItem(items[i], i);
-			if (y + height > 0) {
-				drawList.push({
-					idx: i,
-					value,
-					offset: y,
-					height
-				});
-				drawLength += height;
-			} else {
-				offset += height;
-				position = i + 1;
-			}
-			y += height;
-			if (y >= contentHeight) break;
-		}
-		let shift = 0;
-		if (y < contentHeight) {
-			if (drawList.length > 0 && drawList.at(-1)?.idx === items.length - 1 && !(drawList.at(-1)?.height > Number.EPSILON)) return finalizeVisibleWindowResult(items.length, viewport, layout, {
-				position,
-				offset
-			}, Array.from(resolutionPath), extendVisibleWindowToOuterBounds(items, {
-				drawList,
-				shift
-			}, viewport, readResolvedItem));
-			if (position === 0 && drawLength < contentHeight) {
-				shift = -offset;
-				offset = 0;
-			} else {
-				shift = contentHeight - y;
-				y = offset += shift;
-				let lastIdx = -1;
-				for (let i = position - 1; i >= 0; i -= 1) {
-					const { value, height } = readResolvedItem(items[i], i);
-					drawLength += height;
-					y -= height;
-					drawList.push({
-						idx: i,
-						value,
-						offset: y - shift,
-						height
-					});
-					lastIdx = i;
-					if (y < 0) break;
-				}
-				if (lastIdx === 0 && drawLength < contentHeight) {
-					shift = drawList.at(-1)?.offset == null ? 0 : -drawList.at(-1).offset;
-					position = 0;
-					offset = 0;
-				}
-			}
-		}
-		return finalizeVisibleWindowResult(items.length, viewport, layout, {
-			position,
-			offset
-		}, Array.from(resolutionPath), extendVisibleWindowToOuterBounds(items, {
-			drawList,
-			shift
-		}, viewport, readResolvedItem));
-	}
-	let { position, offset } = normalizedState;
-	let drawLength = 0;
-	if (offset < 0) if (position === items.length - 1) offset = 0;
-	else for (let i = position + 1; i < items.length; i += 1) {
-		const { height } = readResolvedItem(items[i], i);
-		position = i;
-		offset += height;
-		if (offset > 0) break;
-	}
-	let y = contentHeight + offset;
-	const drawList = [];
-	for (let i = position; i >= 0; i -= 1) {
-		const { value, height } = readResolvedItem(items[i], i);
-		y -= height;
-		if (y <= contentHeight) {
-			drawList.push({
-				idx: i,
-				value,
-				offset: y,
-				height
-			});
-			drawLength += height;
-		} else {
-			offset -= height;
-			position = i - 1;
-		}
-		if (y < 0) break;
+	let y = contentHeight + offset;
+	const drawList = [];
+	for (let i = position; i >= 0; i -= 1) {
+		const { value, height } = readResolvedItem(items[i], i);
+		y -= height;
+		if (y <= contentHeight) {
+			drawList.push({
+				index: i,
+				value,
+				offset: y,
+				height
+			});
+			drawLength += height;
+		} else {
+			offset -= height;
+			position = i - 1;
+		}
+		if (y < 0) break;
 	}
 	let shift = 0;
 	if (y > 0) {
@@ -5149,7 +4563,7 @@ function resolveVisibleWindow(items, state, viewportHeight, resolveItem, layout)
 			for (let i = position + 1; i < items.length; i += 1) {
 				const { value, height } = readResolvedItem(items[i], i);
 				drawList.push({
-					idx: i,
+					index: i,
 					value,
 					offset: y - shift,
 					height
@@ -5187,96 +4601,745 @@ function finalizeVisibleWindowResult(itemCount, viewport, layout, normalizedStat
 			minOffset = Math.min(minOffset, entry.offset);
 			maxBottom = Math.max(maxBottom, entry.offset + entry.height);
 		}
-		minIndex = Math.min(minIndex, entry.idx);
-		maxIndex = Math.max(maxIndex, entry.idx);
+		minIndex = Math.min(minIndex, entry.index);
+		maxIndex = Math.max(maxIndex, entry.index);
+	}
+	if (!Number.isFinite(minOffset) || !Number.isFinite(maxBottom)) return {
+		normalizedState,
+		resolutionPath,
+		window
+	};
+	const contentHeight = maxBottom - minOffset;
+	if (minIndex !== 0 || maxIndex !== itemCount - 1 || !(contentHeight < viewportHeight - Number.EPSILON)) return {
+		normalizedState,
+		resolutionPath,
+		window
+	};
+	const desiredTop = layout.underflowAlign === "bottom" ? viewportHeight - contentHeight : 0;
+	return {
+		normalizedState: hasDeferredSlots ? normalizedState : layout.anchorMode === "top" ? {
+			position: 0,
+			offset: 0
+		} : {
+			position: itemCount - 1,
+			offset: 0
+		},
+		resolutionPath,
+		window: {
+			drawList: window.drawList,
+			shift: desiredTop - minOffset
+		}
+	};
+}
+function extendVisibleWindowToOuterBounds(items, window, viewport, resolveItem) {
+	if (window.drawList.length === 0 || items.length === 0) return window;
+	const drawList = [...window.drawList];
+	const existingIndices = new Set(drawList.map((entry) => entry.index));
+	let topEntry = drawList[0];
+	let bottomEntry = drawList[0];
+	for (const entry of drawList) {
+		if (entry.offset < topEntry.offset) topEntry = entry;
+		if (entry.offset + entry.height > bottomEntry.offset + bottomEntry.height) bottomEntry = entry;
+	}
+	let topIdx = topEntry.index;
+	let topY = topEntry.offset + window.shift;
+	while (topIdx > 0) {
+		const prevIdx = topIdx - 1;
+		if (existingIndices.has(prevIdx)) {
+			const existing = drawList.find((entry) => entry.index === prevIdx);
+			topIdx = prevIdx;
+			if (existing != null) topY = existing.offset + window.shift;
+			continue;
+		}
+		const { value, height } = resolveItem(items[prevIdx], prevIdx);
+		const prevY = topY - height;
+		if (prevY + height <= viewport.outerContentTop) break;
+		drawList.push({
+			index: prevIdx,
+			value,
+			offset: prevY - window.shift,
+			height
+		});
+		existingIndices.add(prevIdx);
+		topIdx = prevIdx;
+		topY = prevY;
+	}
+	let bottomIdx = bottomEntry.index;
+	let bottomY = bottomEntry.offset + window.shift + bottomEntry.height;
+	while (bottomIdx < items.length - 1) {
+		const nextIdx = bottomIdx + 1;
+		if (existingIndices.has(nextIdx)) {
+			const existing = drawList.find((entry) => entry.index === nextIdx);
+			bottomIdx = nextIdx;
+			if (existing != null) bottomY = Math.max(bottomY, existing.offset + window.shift + existing.height);
+			continue;
+		}
+		const { value, height } = resolveItem(items[nextIdx], nextIdx);
+		if (bottomY >= viewport.outerContentBottom) break;
+		drawList.push({
+			index: nextIdx,
+			value,
+			offset: bottomY - window.shift,
+			height
+		});
+		existingIndices.add(nextIdx);
+		bottomIdx = nextIdx;
+		bottomY += height;
+	}
+	return {
+		drawList,
+		shift: window.shift
+	};
+}
+//#endregion
+//#region src/renderer/virtualized/transition-snapshot.ts
+var VisibilitySnapshot = class {
+	#drawnItems = /* @__PURE__ */ new Set();
+	#visibleItems = /* @__PURE__ */ new Set();
+	#previousVisibleItems = /* @__PURE__ */ new Set();
+	#hasSnapshot = false;
+	#snapshotState;
+	#previousSnapshotState;
+	#emptyState;
+	#coversShortList = false;
+	#atStartBoundary = false;
+	#atEndBoundary = false;
+	#minDrawnIndex = Number.POSITIVE_INFINITY;
+	#maxDrawnIndex = Number.NEGATIVE_INFINITY;
+	#topBoundaryItem;
+	#bottomBoundaryItem;
+	get coversShortList() {
+		return this.#hasSnapshot && this.#snapshotState != null && this.#coversShortList;
+	}
+	get hasSnapshot() {
+		return this.#hasSnapshot;
+	}
+	get previousState() {
+		return this.#previousSnapshotState;
+	}
+	readDrawnIndexRange() {
+		if (!Number.isFinite(this.#minDrawnIndex) || !Number.isFinite(this.#maxDrawnIndex)) return;
+		return {
+			minIndex: this.#minDrawnIndex,
+			maxIndex: this.#maxDrawnIndex
+		};
+	}
+	readBoundaryItem(boundary) {
+		return boundary === "top" ? this.#topBoundaryItem : this.#bottomBoundaryItem;
+	}
+	capture(window, _resolutionPath, items, viewport, snapshotState, readVisibleRange, readOuterVisibleRange) {
+		this.#previousVisibleItems = this.#visibleItems;
+		this.#previousSnapshotState = this.#snapshotState;
+		const nextDrawnItems = /* @__PURE__ */ new Set();
+		const nextVisibleItems = /* @__PURE__ */ new Set();
+		let minVisibleIndex = Number.POSITIVE_INFINITY;
+		let maxVisibleIndex = Number.NEGATIVE_INFINITY;
+		let topMostY = Number.POSITIVE_INFINITY;
+		let bottomMostY = Number.NEGATIVE_INFINITY;
+		let nextMinDrawnIndex = Number.POSITIVE_INFINITY;
+		let nextMaxDrawnIndex = Number.NEGATIVE_INFINITY;
+		let nextTopBoundaryItem;
+		let nextBottomBoundaryItem;
+		let nextTopBoundaryY = Number.POSITIVE_INFINITY;
+		let nextBottomBoundaryY = Number.NEGATIVE_INFINITY;
+		const effectiveShift = window.shift;
+		const contentOriginY = viewport.contentTop;
+		for (const { index, offset, height } of window.drawList) {
+			const y = offset + effectiveShift + contentOriginY;
+			topMostY = Math.min(topMostY, y);
+			bottomMostY = Math.max(bottomMostY, y + height);
+			const item = items[index];
+			if (item != null && readOuterVisibleRange(y, height) != null) {
+				nextDrawnItems.add(item);
+				nextMinDrawnIndex = Math.min(nextMinDrawnIndex, index);
+				nextMaxDrawnIndex = Math.max(nextMaxDrawnIndex, index);
+			}
+			if (item == null) continue;
+			if (readVisibleRange(y, height) != null) {
+				minVisibleIndex = Math.min(minVisibleIndex, index);
+				maxVisibleIndex = Math.max(maxVisibleIndex, index);
+				nextVisibleItems.add(item);
+				if (y < nextTopBoundaryY) {
+					nextTopBoundaryY = y;
+					nextTopBoundaryItem = item;
+				}
+				if (y + height > nextBottomBoundaryY) {
+					nextBottomBoundaryY = y + height;
+					nextBottomBoundaryItem = item;
+				}
+			}
+		}
+		this.#drawnItems = nextDrawnItems;
+		this.#visibleItems = nextVisibleItems;
+		this.#hasSnapshot = true;
+		this.#snapshotState = snapshotState;
+		this.#minDrawnIndex = nextMinDrawnIndex;
+		this.#maxDrawnIndex = nextMaxDrawnIndex;
+		this.#topBoundaryItem = nextTopBoundaryItem;
+		this.#bottomBoundaryItem = nextBottomBoundaryItem;
+		this.#emptyState = items.length === 0 && window.drawList.length === 0 ? snapshotState : void 0;
+		const contentHeight = bottomMostY - topMostY;
+		this.#coversShortList = window.drawList.length > 0 && items.length > 0 && window.drawList.length === items.length && minVisibleIndex === 0 && maxVisibleIndex === items.length - 1 && topMostY >= viewport.contentTop - 1e-6 && bottomMostY <= viewport.contentBottom + 1e-6 && contentHeight < viewport.contentHeight - 1e-6;
+		this.#atStartBoundary = window.drawList.length > 0 && items.length > 0 && minVisibleIndex === 0 && topMostY >= viewport.contentTop - 1e-6;
+		this.#atEndBoundary = window.drawList.length > 0 && items.length > 0 && maxVisibleIndex === items.length - 1 && bottomMostY <= viewport.contentBottom + 1e-6;
+	}
+	matchesCurrentState(position, offset) {
+		return this.#hasSnapshot && this.#snapshotState != null && sameState(this.#snapshotState, position, offset);
+	}
+	matchesBoundaryInsertState(direction, count, position, offset) {
+		if (!this.coversShortList || this.#snapshotState == null) return false;
+		return this.#matchesStateAfterBoundaryInsert(direction, count, position, offset);
+	}
+	matchesFollowBoundaryInsertState(direction, count, position, offset) {
+		if (!this.#hasSnapshot || this.#snapshotState == null) return false;
+		if (direction === "push" ? !this.#atEndBoundary : !this.#atStartBoundary) return false;
+		return this.#matchesStateAfterBoundaryInsert(direction, count, position, offset);
+	}
+	matchesEmptyBoundaryInsertState(direction, count, position, offset) {
+		const emptyState = this.#emptyState;
+		if (!this.#hasSnapshot || emptyState == null) return false;
+		return sameState({
+			position: direction === "unshift" && emptyState.position != null ? emptyState.position + count : emptyState.position,
+			offset: emptyState.offset
+		}, position, offset);
+	}
+	isVisible(item) {
+		return this.#visibleItems.has(item);
+	}
+	wasVisible(item) {
+		return this.#previousVisibleItems.has(item);
+	}
+	tracks(item, retention) {
+		return retention === "drawn" ? this.#drawnItems.has(item) : this.#visibleItems.has(item);
+	}
+	reset() {
+		this.#drawnItems.clear();
+		this.#visibleItems.clear();
+		this.#previousVisibleItems.clear();
+		this.#hasSnapshot = false;
+		this.#snapshotState = void 0;
+		this.#previousSnapshotState = void 0;
+		this.#emptyState = void 0;
+		this.#coversShortList = false;
+		this.#atStartBoundary = false;
+		this.#atEndBoundary = false;
+		this.#minDrawnIndex = Number.POSITIVE_INFINITY;
+		this.#maxDrawnIndex = Number.NEGATIVE_INFINITY;
+		this.#topBoundaryItem = void 0;
+		this.#bottomBoundaryItem = void 0;
+	}
+	#matchesStateAfterBoundaryInsert(direction, count, position, offset) {
+		const snapshotState = this.#snapshotState;
+		if (snapshotState == null) return false;
+		return sameState({
+			position: direction === "unshift" && snapshotState.position != null ? snapshotState.position + count : snapshotState.position,
+			offset: snapshotState.offset
+		}, position, offset);
+	}
+};
+//#endregion
+//#region src/renderer/virtualized/transition-store.ts
+var TransitionStore = class {
+	#transitions = /* @__PURE__ */ new Map();
+	get size() {
+		return this.#transitions.size;
+	}
+	has(item) {
+		return this.#transitions.has(item);
+	}
+	set(item, transition) {
+		const previous = this.#transitions.get(item);
+		this.#transitions.set(item, transition);
+		return previous;
+	}
+	replace(prevItem, nextItem, transition) {
+		const previous = this.#transitions.get(prevItem);
+		this.#transitions.delete(prevItem);
+		this.#transitions.set(nextItem, transition);
+		return previous;
+	}
+	delete(item) {
+		const transition = this.#transitions.get(item);
+		if (transition != null) this.#transitions.delete(item);
+		return transition;
+	}
+	readActive(item, now) {
+		const transition = this.#transitions.get(item);
+		if (transition == null) return;
+		return this.#isComplete(transition, now) ? void 0 : transition;
+	}
+	prepare(now) {
+		for (const transition of this.#transitions.values()) if (!this.#isComplete(transition, now)) return true;
+		return false;
+	}
+	findCompleted(now) {
+		return [...this.#transitions.entries()].filter(([, transition]) => this.#isComplete(transition, now)).map(([item, transition]) => ({
+			item,
+			transition
+		}));
+	}
+	findInvisible(snapshot) {
+		return [...this.#transitions.entries()].filter(([item, transition]) => !snapshot.tracks(item, transition.retention) && !(transition.kind === "insert" && !snapshot.wasVisible(item))).map(([item, transition]) => ({
+			item,
+			transition
+		}));
+	}
+	entries() {
+		return [...this.#transitions.entries()].map(([item, transition]) => ({
+			item,
+			transition
+		}));
+	}
+	reset() {
+		this.#transitions.clear();
+	}
+	#isComplete(transition, now) {
+		return getProgress(transition.height.startTime, transition.height.duration, now) >= 1;
+	}
+};
+//#endregion
+//#region src/renderer/virtualized/transition-planner.ts
+function normalizeDuration(duration) {
+	return Math.max(0, typeof duration === "number" && Number.isFinite(duration) ? duration : 0);
+}
+function createScalarAnimation(from, to, startTime, duration) {
+	return {
+		from,
+		to,
+		startTime,
+		duration
+	};
+}
+function createLayerAnimation(node, fromAlpha, toAlpha, startTime, duration, fromTranslateY, toTranslateY) {
+	return {
+		node,
+		alpha: createScalarAnimation(fromAlpha, toAlpha, startTime, duration),
+		translateY: createScalarAnimation(fromTranslateY, toTranslateY, startTime, duration)
+	};
+}
+function findVisibleEntry(index, resolveVisibleWindow, readVisibleRange) {
+	if (index < 0) return;
+	const solution = resolveVisibleWindow();
+	for (const entry of solution.window.drawList) {
+		if (entry.index !== index) continue;
+		if (readVisibleRange(entry.offset + solution.window.shift, entry.height) != null) return entry;
+	}
+}
+function isIndexVisible(index, resolveVisibleWindow, readVisibleRange) {
+	return findVisibleEntry(index, resolveVisibleWindow, readVisibleRange) != null;
+}
+function resolveAnimationEligibility(params) {
+	if (params.index < 0) return false;
+	if (params.snapshot.matchesCurrentState(params.position, params.offset)) return params.snapshot.tracks(params.item, "drawn");
+	return isIndexVisible(params.index, params.resolveVisibleWindow, params.readOuterVisibleRange);
+}
+function hasVisibleBoundaryInsertItems(direction, count, ctx) {
+	if (count <= 0) return false;
+	const start = direction === "push" ? ctx.items.length - count : 0;
+	const end = direction === "push" ? ctx.items.length : Math.min(count, ctx.items.length);
+	if (start < 0 || end <= start) return false;
+	const solution = ctx.resolveVisibleWindow();
+	return solution.window.drawList.some((entry) => entry.index >= start && entry.index < end && ctx.readOuterVisibleRange(entry.offset + solution.window.shift, entry.height) != null);
+}
+function sampleScalarAnimation(animation, now) {
+	return interpolate(animation.from, animation.to, animation.startTime, animation.duration, now);
+}
+function sampleLayerAnimation(layer, now) {
+	const alpha = sampleScalarAnimation(layer.alpha, now);
+	if (alpha <= .001) return;
+	return {
+		alpha,
+		node: layer.node,
+		translateY: sampleScalarAnimation(layer.translateY, now)
+	};
+}
+function sampleTransition(transition, now) {
+	return {
+		kind: transition.kind,
+		slotHeight: sampleScalarAnimation(transition.height, now),
+		layers: transition.layers.map((layer) => sampleLayerAnimation(layer, now)).filter((layer) => layer != null),
+		retention: transition.retention
+	};
+}
+function planExistingItemTransition(params) {
+	if (!params.canAnimate || params.duration <= 0) return;
+	if (params.kind === "update" && !Number.isFinite(params.nextHeight)) return;
+	const layers = [];
+	if (params.currentVisualState.alpha > .001) layers.push(createLayerAnimation(params.currentVisualState.node, params.currentVisualState.alpha, 0, params.now, params.duration, params.currentVisualState.translateY, 0));
+	if (params.kind === "update") {
+		layers.push(createLayerAnimation(params.nextNode, 0, 1, params.now, params.duration, params.currentVisualState.translateY, 0));
+		return {
+			kind: "update",
+			layers,
+			height: createScalarAnimation(params.currentVisualState.height, params.nextHeight, params.now, params.duration),
+			retention: "drawn"
+		};
+	}
+	return {
+		kind: "delete",
+		layers,
+		height: createScalarAnimation(params.currentVisualState.height, 0, params.now, params.duration),
+		retention: "drawn"
+	};
+}
+function resolveAutoFollowBoundaryRisk(index, ctx, snapshot) {
+	const drawnRange = snapshot.readDrawnIndexRange();
+	if (index < 0 || !snapshot.hasSnapshot || drawnRange == null || !Number.isFinite(drawnRange.minIndex) || !Number.isFinite(drawnRange.maxIndex)) return;
+	if (ctx.anchorMode === "bottom") return index <= drawnRange.minIndex ? "top" : void 0;
+	return index >= drawnRange.maxIndex ? "bottom" : void 0;
+}
+function canClassifyAutoFollowBoundaryRisk(index, snapshot) {
+	return index >= 0 && snapshot.hasSnapshot && snapshot.readDrawnIndexRange() != null;
+}
+function beginTransitionAutoFollowObservation(transition, lifecycle) {
+	if (transition.observedAutoFollowBoundary == null) return;
+	lifecycle.beginAutoFollowBoundaryObservation(transition.observedAutoFollowBoundary);
+}
+function endTransitionAutoFollowObservation(transition, lifecycle) {
+	if (transition?.observedAutoFollowBoundary == null) return;
+	lifecycle.endAutoFollowBoundaryObservation(transition.observedAutoFollowBoundary);
+}
+function invalidateAutoFollowBoundaryRisk(boundary, canClassify, lifecycle) {
+	if (boundary != null) {
+		lifecycle.invalidateAutoFollowBoundary(boundary);
+		return;
+	}
+	if (!canClassify) lifecycle.invalidateAutoFollowBoundary(void 0);
+}
+function planBoundaryInsertItems(params) {
+	const entries = [];
+	for (const { item, node, height } of params.measuredItems) {
+		if (!Number.isFinite(height) || height < 0) return;
+		entries.push({
+			item,
+			transition: {
+				kind: "insert",
+				layers: [createLayerAnimation(node, 0, 1, params.now, params.duration, 0, 0)],
+				height: createScalarAnimation(params.animateHeight ? 0 : height, height, params.now, params.duration),
+				retention: "drawn"
+			}
+		});
+	}
+	return entries.length === 0 ? void 0 : { entries };
+}
+function measureBoundaryInsertItems(direction, count, ctx) {
+	const start = direction === "push" ? ctx.items.length - count : 0;
+	const end = direction === "push" ? ctx.items.length : Math.min(count, ctx.items.length);
+	if (start < 0 || end < start) return;
+	const measured = [];
+	for (let index = start; index < end; index += 1) {
+		const item = ctx.items[index];
+		if (item == null) continue;
+		const node = ctx.renderItem(item);
+		const height = ctx.measureNode(node).height;
+		measured.push({
+			item,
+			node,
+			height
+		});
+	}
+	return measured;
+}
+function drawSampledLayers(sampled, y, adapter) {
+	if (sampled.slotHeight <= 0) return false;
+	let result = false;
+	for (const layer of sampled.layers) {
+		const alpha = clamp$1(layer.alpha, 0, 1);
+		if (alpha <= .001) continue;
+		adapter.graphics.save();
+		try {
+			if (sampled.kind === "insert") {
+				adapter.graphics.beginPath();
+				adapter.graphics.rect(0, y, adapter.graphics.canvas.clientWidth, sampled.slotHeight);
+				adapter.graphics.clip();
+			}
+			if (typeof adapter.graphics.globalAlpha === "number") adapter.graphics.globalAlpha *= alpha;
+			if (adapter.drawNode(layer.node, 0, y + layer.translateY)) result = true;
+		} finally {
+			adapter.graphics.restore();
+		}
+	}
+	return result;
+}
+function planUpdateTransition(prevItem, nextItem, duration, now, currentVisualState, ctx, snapshot, store) {
+	const nextIndex = ctx.items.indexOf(nextItem);
+	const nextNode = ctx.renderItem(nextItem);
+	const nextHeight = ctx.measureNode(nextNode).height;
+	return planExistingItemTransition({
+		kind: "update",
+		duration: normalizeDuration(duration),
+		canAnimate: resolveAnimationEligibility({
+			index: nextIndex,
+			item: prevItem,
+			position: ctx.position,
+			offset: ctx.offset,
+			snapshot,
+			hasActiveTransition: store.has(prevItem),
+			resolveVisibleWindow: ctx.resolveVisibleWindow,
+			readOuterVisibleRange: ctx.readOuterVisibleRange
+		}),
+		now,
+		currentVisualState,
+		nextNode,
+		nextHeight
+	});
+}
+function planDeleteTransition(item, duration, now, currentVisualState, ctx, snapshot, store) {
+	const index = ctx.items.indexOf(item);
+	return planExistingItemTransition({
+		kind: "delete",
+		duration: normalizeDuration(duration),
+		canAnimate: resolveAnimationEligibility({
+			index,
+			item,
+			position: ctx.position,
+			offset: ctx.offset,
+			snapshot,
+			hasActiveTransition: store.has(item),
+			resolveVisibleWindow: ctx.resolveVisibleWindow,
+			readOuterVisibleRange: ctx.readOuterVisibleRange
+		}),
+		now,
+		currentVisualState
+	});
+}
+function planBoundaryInsertTransition(direction, count, duration, now, ctx, snapshot) {
+	const normalizedDuration = normalizeDuration(duration);
+	if (count <= 0 || normalizedDuration <= 0) return;
+	const matchesBoundaryState = snapshot.matchesBoundaryInsertState(direction, count, ctx.position, ctx.offset);
+	const matchesFollowState = snapshot.matchesFollowBoundaryInsertState(direction, count, ctx.position, ctx.offset);
+	const matchesEmptyState = snapshot.matchesEmptyBoundaryInsertState(direction, count, ctx.position, ctx.offset);
+	if (!(matchesBoundaryState || matchesFollowState || matchesEmptyState || snapshot.hasSnapshot && hasVisibleBoundaryInsertItems(direction, count, ctx))) return;
+	const animateHeight = !(direction === "unshift" && matchesFollowState && !matchesBoundaryState && !matchesEmptyState);
+	const measuredItems = measureBoundaryInsertItems(direction, count, ctx);
+	if (measuredItems == null) return;
+	return planBoundaryInsertItems({
+		duration: normalizedDuration,
+		animateHeight,
+		now,
+		measuredItems
+	});
+}
+function getTransitionedItemHeight(item, now, store, adapter) {
+	const transition = store.readActive(item, now);
+	if (transition != null) return sampleTransition(transition, now).slotHeight;
+	const node = adapter.renderItem(item);
+	return adapter.measureNode(node).height;
+}
+function resolveTransitionedItem(item, now, store, adapter, lifecycle) {
+	const transition = store.readActive(item, now);
+	if (transition == null) {
+		const node = adapter.renderItem(item);
+		return {
+			value: {
+				draw: (y) => adapter.drawNode(node, 0, y),
+				hittest: (test, y) => node.hittest(adapter.getRootContext(), {
+					...test,
+					y: test.y - y
+				})
+			},
+			height: adapter.measureNode(node).height
+		};
 	}
-	if (!Number.isFinite(minOffset) || !Number.isFinite(maxBottom)) return {
-		normalizedState,
-		resolutionPath,
-		window
-	};
-	const contentHeight = maxBottom - minOffset;
-	if (minIndex !== 0 || maxIndex !== itemCount - 1 || !(contentHeight < viewportHeight - Number.EPSILON)) return {
-		normalizedState,
-		resolutionPath,
-		window
-	};
-	const desiredTop = layout.underflowAlign === "bottom" ? viewportHeight - contentHeight : 0;
+	const sampled = sampleTransition(transition, now);
 	return {
-		normalizedState: hasDeferredSlots ? normalizedState : layout.anchorMode === "top" ? {
-			position: 0,
-			offset: 0
-		} : {
-			position: itemCount - 1,
-			offset: 0
+		value: {
+			draw: (y) => drawSampledLayers(sampled, y, adapter),
+			hittest: () => false
 		},
-		resolutionPath,
-		window: {
-			drawList: window.drawList,
-			shift: desiredTop - minOffset
-		}
+		height: sampled.slotHeight
 	};
 }
-function extendVisibleWindowToOuterBounds(items, window, viewport, resolveItem) {
-	if (window.drawList.length === 0 || items.length === 0) return window;
-	const drawList = [...window.drawList];
-	const existingIndices = new Set(drawList.map((entry) => entry.idx));
-	let topEntry = drawList[0];
-	let bottomEntry = drawList[0];
-	for (const entry of drawList) {
-		if (entry.offset < topEntry.offset) topEntry = entry;
-		if (entry.offset + entry.height > bottomEntry.offset + bottomEntry.height) bottomEntry = entry;
+function readCurrentVisualState(item, now, store, adapter) {
+	const transition = store.readActive(item, now);
+	if (transition != null && transition.layers.length > 0) {
+		const primaryLayer = transition.layers[transition.layers.length - 1];
+		return {
+			node: primaryLayer.node,
+			alpha: sampleScalarAnimation(primaryLayer.alpha, now),
+			height: sampleScalarAnimation(transition.height, now),
+			translateY: sampleScalarAnimation(primaryLayer.translateY, now)
+		};
 	}
-	let topIdx = topEntry.idx;
-	let topY = topEntry.offset + window.shift;
-	while (topIdx > 0) {
-		const prevIdx = topIdx - 1;
-		if (existingIndices.has(prevIdx)) {
-			const existing = drawList.find((entry) => entry.idx === prevIdx);
-			topIdx = prevIdx;
-			if (existing != null) topY = existing.offset + window.shift;
-			continue;
+	const node = adapter.renderItem(item);
+	return {
+		node,
+		alpha: 1,
+		height: adapter.measureNode(node).height,
+		translateY: 0
+	};
+}
+function handleTransitionStateChange(store, snapshot, change, ctx, lifecycle, now = getNow()) {
+	switch (change.type) {
+		case "update": {
+			const nextIndex = ctx.items.indexOf(change.nextItem);
+			const canClassifyRisk = canClassifyAutoFollowBoundaryRisk(nextIndex, snapshot);
+			const observedBoundary = resolveAutoFollowBoundaryRisk(nextIndex, ctx, snapshot);
+			const currentVisualState = readCurrentVisualState(change.prevItem, now, store, ctx);
+			const transition = planUpdateTransition(change.prevItem, change.nextItem, change.animation?.duration, now, currentVisualState, ctx, snapshot, store);
+			if (transition == null) {
+				endTransitionAutoFollowObservation(store.delete(change.prevItem), lifecycle);
+				invalidateAutoFollowBoundaryRisk(observedBoundary, canClassifyRisk, lifecycle);
+				return;
+			}
+			transition.observedAutoFollowBoundary = observedBoundary;
+			endTransitionAutoFollowObservation(store.replace(change.prevItem, change.nextItem, transition), lifecycle);
+			beginTransitionAutoFollowObservation(transition, lifecycle);
+			return;
 		}
-		const { value, height } = resolveItem(items[prevIdx], prevIdx);
-		const prevY = topY - height;
-		if (prevY + height <= viewport.outerContentTop) break;
-		drawList.push({
-			idx: prevIdx,
-			value,
-			offset: prevY - window.shift,
-			height
-		});
-		existingIndices.add(prevIdx);
-		topIdx = prevIdx;
-		topY = prevY;
+		case "delete": {
+			const index = ctx.items.indexOf(change.item);
+			const canClassifyRisk = canClassifyAutoFollowBoundaryRisk(index, snapshot);
+			const observedBoundary = resolveAutoFollowBoundaryRisk(index, ctx, snapshot);
+			const currentVisualState = readCurrentVisualState(change.item, now, store, ctx);
+			const transition = planDeleteTransition(change.item, change.animation?.duration, now, currentVisualState, ctx, snapshot, store);
+			if (transition == null) {
+				endTransitionAutoFollowObservation(store.delete(change.item), lifecycle);
+				invalidateAutoFollowBoundaryRisk(observedBoundary, canClassifyRisk, lifecycle);
+				lifecycle.onDeleteComplete(change.item);
+				return;
+			}
+			transition.observedAutoFollowBoundary = observedBoundary;
+			endTransitionAutoFollowObservation(store.set(change.item, transition), lifecycle);
+			beginTransitionAutoFollowObservation(transition, lifecycle);
+			return;
+		}
+		case "delete-finalize":
+			endTransitionAutoFollowObservation(store.delete(change.item), lifecycle);
+			lifecycle.invalidateAutoFollowBoundary(void 0);
+			return;
+		case "unshift":
+		case "push": {
+			const plan = planBoundaryInsertTransition(change.type, change.count, change.animation?.duration, now, ctx, snapshot);
+			if (plan == null) return;
+			for (const entry of plan.entries) endTransitionAutoFollowObservation(store.set(entry.item, entry.transition), lifecycle);
+			if (ctx.position == null && snapshot.coversShortList && (change.type === "push" && ctx.anchorMode === "bottom" || change.type === "unshift" && ctx.anchorMode === "top")) {
+				const boundary = change.type === "push" ? "bottom" : "top";
+				const boundaryItem = snapshot.readBoundaryItem(boundary);
+				if (boundaryItem != null) lifecycle.snapItemToViewportBoundary(boundaryItem, boundary);
+			}
+			return;
+		}
+		case "reset":
+		case "set":
+			for (const entry of store.entries()) endTransitionAutoFollowObservation(entry.transition, lifecycle);
+			store.reset();
+			snapshot.reset();
+			return;
 	}
-	let bottomIdx = bottomEntry.idx;
-	let bottomY = bottomEntry.offset + window.shift + bottomEntry.height;
-	while (bottomIdx < items.length - 1) {
-		const nextIdx = bottomIdx + 1;
-		if (existingIndices.has(nextIdx)) {
-			const existing = drawList.find((entry) => entry.idx === nextIdx);
-			bottomIdx = nextIdx;
-			if (existing != null) bottomY = Math.max(bottomY, existing.offset + window.shift + existing.height);
+}
+//#endregion
+//#region src/renderer/virtualized/transition-controller.ts
+function remapAnchorAfterDeletes(anchor, deletedIndices) {
+	if (!Number.isFinite(anchor) || deletedIndices.length === 0) return anchor;
+	const sortedIndices = [...deletedIndices].filter((index) => Number.isFinite(index) && index >= 0).sort((a, b) => a - b);
+	let removedBeforeAnchor = 0;
+	for (const index of sortedIndices) {
+		if (anchor > index + 1) {
+			removedBeforeAnchor += 1;
 			continue;
 		}
-		const { value, height } = resolveItem(items[nextIdx], nextIdx);
-		if (bottomY >= viewport.outerContentBottom) break;
-		drawList.push({
-			idx: nextIdx,
-			value,
-			offset: bottomY - window.shift,
-			height
-		});
-		existingIndices.add(nextIdx);
-		bottomIdx = nextIdx;
-		bottomY += height;
+		if (anchor >= index) return index - removedBeforeAnchor;
 	}
-	return {
-		drawList,
-		shift: window.shift
-	};
+	return anchor - removedBeforeAnchor;
 }
+var TransitionController = class {
+	#store = new TransitionStore();
+	#snapshot = new VisibilitySnapshot();
+	captureVisibilitySnapshot(window, resolutionPath, items, viewport, snapshotState, readVisibleRange, readOuterVisibleRange) {
+		this.#snapshot.capture(window, resolutionPath, items, viewport, snapshotState, readVisibleRange, readOuterVisibleRange);
+	}
+	pruneInvisible(ctx, lifecycle) {
+		return this.pruneInvisibleAt(getNow(), ctx, lifecycle);
+	}
+	prepare(now, lifecycle) {
+		this.settle(now, lifecycle);
+		return this.#store.prepare(now);
+	}
+	canAutoFollowBoundaryInsert(direction, count, position, offset) {
+		return this.#snapshot.matchesFollowBoundaryInsertState(direction, count, position, offset);
+	}
+	getItemHeight(item, now, adapter) {
+		return getTransitionedItemHeight(item, now, this.#store, adapter);
+	}
+	resolveItem(item, now, adapter, lifecycle) {
+		return resolveTransitionedItem(item, now, this.#store, adapter, lifecycle);
+	}
+	handleListStateChange(change, ctx, lifecycle, now = getNow()) {
+		this.settle(now, lifecycle);
+		handleTransitionStateChange(this.#store, this.#snapshot, change, ctx, lifecycle, now);
+	}
+	settle(now, lifecycle) {
+		return this.#settleTransitions(this.#store.findCompleted(now), now, lifecycle);
+	}
+	pruneInvisibleAt(now, ctx, lifecycle) {
+		const removals = this.#store.findInvisible(this.#snapshot);
+		return this.#settleTransitions(removals, now, lifecycle, this.#resolveNaturalBoundarySnap(removals, now, ctx, lifecycle));
+	}
+	reset() {
+		this.#store.reset();
+		this.#snapshot.reset();
+	}
+	#settleTransitions(removals, now, lifecycle, boundarySnap) {
+		if (removals.length === 0) return false;
+		const anchor = lifecycle.captureVisualAnchor(now);
+		const beforeState = lifecycle.readScrollState();
+		const completedDeleteIndices = [];
+		for (const { item, transition } of removals) {
+			if (transition.kind === "delete") {
+				const index = lifecycle.readItemIndex(item);
+				if (index >= 0) completedDeleteIndices.push(index);
+			}
+			const removedTransition = this.#store.delete(item);
+			if (removedTransition?.observedAutoFollowBoundary != null) {
+				lifecycle.endAutoFollowBoundaryObservation(removedTransition.observedAutoFollowBoundary);
+				lifecycle.invalidateAutoFollowBoundary(removedTransition.observedAutoFollowBoundary);
+			}
+			if (transition.kind === "delete") lifecycle.onDeleteComplete(item);
+		}
+		if (anchor != null && Number.isFinite(anchor)) lifecycle.restoreVisualAnchor(remapAnchorAfterDeletes(anchor, completedDeleteIndices));
+		if (boundarySnap != null) lifecycle.snapItemToViewportBoundary(boundarySnap.item, boundarySnap.boundary);
+		const afterState = lifecycle.readScrollState();
+		if (!sameState(beforeState, afterState.position, afterState.offset)) lifecycle.onTransitionSettleScrollAdjusted();
+		return true;
+	}
+	#resolveNaturalBoundarySnap(removals, now, ctx, lifecycle) {
+		const previousState = this.#snapshot.previousState;
+		const drawnRange = this.#snapshot.readDrawnIndexRange();
+		if (previousState == null || drawnRange == null) return;
+		const naturalIndices = [];
+		for (const { item, transition } of removals) {
+			if (transition.kind !== "update" && transition.kind !== "delete") continue;
+			const index = lifecycle.readItemIndex(item);
+			if (index < 0 || !this.#snapshot.wasVisible(item)) return;
+			if (this.#isTransitionVisibleInState(index, previousState, now, ctx)) return;
+			naturalIndices.push(index);
+		}
+		if (naturalIndices.length === 0) return;
+		if (naturalIndices.every((index) => index < drawnRange.minIndex)) {
+			const item = this.#snapshot.readBoundaryItem("top");
+			return item == null ? void 0 : {
+				item,
+				boundary: "top"
+			};
+		}
+		if (naturalIndices.every((index) => index > drawnRange.maxIndex)) {
+			const item = this.#snapshot.readBoundaryItem("bottom");
+			return item == null ? void 0 : {
+				item,
+				boundary: "bottom"
+			};
+		}
+	}
+	#isTransitionVisibleInState(index, state, now, ctx) {
+		const solution = ctx.resolveVisibleWindowForState(state, now);
+		for (const entry of solution.window.drawList) {
+			if (entry.index !== index) continue;
+			return ctx.readOuterVisibleRange(entry.offset + solution.window.shift, entry.height) != null;
+		}
+		return false;
+	}
+};
 //#endregion
 //#region src/renderer/virtualized/base.ts
 /**
@@ -5288,6 +5351,7 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 	static JUMP_DURATION_PER_PIXEL = .7;
 	#jumpController;
 	#transitionController = new TransitionController();
+	#listStateOverride;
 	constructor(graphics, options) {
 		super(graphics, options);
 		this.#jumpController = new JumpController({
@@ -5305,29 +5369,18 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 			clampItemIndex: this._clampItemIndex.bind(this),
 			getItemHeight: this._getItemHeight.bind(this)
 		});
-		subscribeListState(options.list, this, (owner, change) => {
-			owner.#handleListStateChange(change);
-		});
 	}
 	/** Current anchor item index. */
 	get position() {
-		return this.options.list.position;
-	}
-	/** Updates the current anchor item index. */
-	set position(value) {
-		this.options.list.position = value;
+		return this.#listStateOverride?.position ?? this.options.list.position;
 	}
 	/** Pixel offset from the anchored item edge. */
 	get offset() {
-		return this.options.list.offset;
-	}
-	/** Updates the pixel offset from the anchored item edge. */
-	set offset(value) {
-		this.options.list.offset = value;
+		return this.#listStateOverride?.offset ?? this.options.list.offset;
 	}
 	/** Items currently available to the renderer. */
 	get items() {
-		return this.options.list.items;
+		return this.#listStateOverride?.items ?? this.options.list.items;
 	}
 	/** Replaces the current item collection. */
 	set items(value) {
@@ -5335,6 +5388,7 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 	}
 	/** Renders the current visible window. */
 	render(feedback) {
+		this.#drainPendingListStateChanges();
 		this.#jumpController.beforeFrame();
 		this.#jumpController.noteViewportWidth(this.graphics.canvas.clientWidth);
 		const now = getNow();
@@ -5358,6 +5412,7 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 	}
 	/** Hit-tests the current visible window. */
 	hittest(test) {
+		this.#drainPendingListStateChanges();
 		this.#jumpController.beforeFrame();
 		this.#jumpController.noteViewportWidth(this.graphics.canvas.clientWidth);
 		const now = getNow();
@@ -5424,9 +5479,9 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 	_renderDrawList(list, shift, feedback) {
 		let result = false;
 		const viewport = this._getViewportMetrics();
-		for (const { idx, value: item, offset, height } of list) {
+		for (const { index, value: item, offset, height } of list) {
 			const y = offset + shift + viewport.contentTop;
-			if (feedback != null) this._accumulateRenderFeedback(feedback, idx, y, height);
+			if (feedback != null) this._accumulateRenderFeedback(feedback, index, y, height);
 			if (y + height < 0 || y > viewport.outerHeight) continue;
 			if (item.draw(y)) result = true;
 		}
@@ -5446,9 +5501,9 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 		let topMostY = Number.POSITIVE_INFINITY;
 		let bottomMostY = Number.NEGATIVE_INFINITY;
 		const viewport = this._getViewportMetrics();
-		for (const { idx, offset, height } of window.drawList) {
-			minIndex = Math.min(minIndex, idx);
-			maxIndex = Math.max(maxIndex, idx);
+		for (const { index, offset, height } of window.drawList) {
+			minIndex = Math.min(minIndex, index);
+			maxIndex = Math.max(maxIndex, index);
 			const y = offset + window.shift + viewport.contentTop;
 			topMostY = Math.min(topMostY, y);
 			bottomMostY = Math.max(bottomMostY, y + height);
@@ -5539,7 +5594,8 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 		return resolveListViewport(this.graphics.canvas.clientHeight, this._getLayoutOptions().padding);
 	}
 	#handleDeleteComplete(item) {
-		this.options.list.finalizeDelete(item);
+		finalizeInternalListDelete(this.options.list, item);
+		this.#drainPendingListStateChanges();
 	}
 	#getTransitionLifecycleAdapter() {
 		return {
@@ -5549,7 +5605,10 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 			readScrollState: this._readListState.bind(this),
 			readItemIndex: (item) => this.items.indexOf(item),
 			snapItemToViewportBoundary: this.#snapItemToViewportBoundary.bind(this),
-			onTransitionSettleScrollAdjusted: () => this.#jumpController.reconcileAutoFollowAfterTransitionSettle()
+			onTransitionSettleScrollAdjusted: () => this.#jumpController.reconcileAutoFollowAfterTransitionSettle(),
+			beginAutoFollowBoundaryObservation: (boundary) => this.#jumpController.beginAutoFollowBoundaryObservation(boundary),
+			endAutoFollowBoundaryObservation: (boundary) => this.#jumpController.endAutoFollowBoundaryObservation(boundary),
+			invalidateAutoFollowBoundary: (boundary) => this.#jumpController.invalidateAutoFollowBoundary(boundary)
 		};
 	}
 	#getVirtualizedRuntime() {
@@ -5583,9 +5642,25 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 			anchorMode: this._getLayoutOptions().anchorMode
 		};
 	}
-	#handleListStateChange(change) {
-		const nextChange = this.#jumpController.handleListStateChange(change);
-		this.#transitionController.handleListStateChange(nextChange, this.#getTransitionPlanningAdapter(), this.#getTransitionLifecycleAdapter());
+	#handleListStateChange(change, now = getNow(), snapshot) {
+		this.#listStateOverride = snapshot == null ? void 0 : {
+			items: [...snapshot.items],
+			position: snapshot.position,
+			offset: snapshot.offset
+		};
+		try {
+			const nextChange = this.#jumpController.handleListStateChange(change, now);
+			this.#transitionController.handleListStateChange(nextChange, this.#getTransitionPlanningAdapter(), this.#getTransitionLifecycleAdapter(), now);
+		} finally {
+			this.#listStateOverride = void 0;
+		}
+	}
+	#drainPendingListStateChanges() {
+		while (true) {
+			const changes = drainInternalListStateChanges(this.options.list);
+			if (changes.length === 0) return;
+			for (const change of changes) this.#handleListStateChange(change, readInternalListStateChangeTime(change), readInternalListStateChangeSnapshot(change));
+		}
 	}
 };
 //#endregion