silvery 0.17.0 → 0.17.2

package/dist/pipeline-DDOPrjuY.mjs

@@ -0,0 +1,4387 @@
+import { F as outputPhase, Ft as createMutableCell, G as getActiveLineHeight, It as createTextFrame, J as graphemeWidth, Lt as init_buffer, Ot as DEFAULT_BG, R as canBreakAnywhere, U as displayWidthAnsi, W as ensureEmojiPresentation, Y as hasAnsi, _ as isCurrentEpoch, c as clearDirtyTracking, ct as runWithMeasurer, d as hasScrollDirty, dt as sliceByWidth, f as measureStats, ft as sliceByWidthFromEnd, g as isAnyDirty, h as getRenderEpoch, ht as splitGraphemesAnsiAware, kt as TerminalBuffer, l as clearLayoutDirtyTracking, m as advanceRenderEpoch, mt as splitGraphemes, nt as isWordBoundary, p as collectPlainText, st as parseAnsiText, u as hasLayoutDirty, v as isDirty, yt as wrapText } from "./reconciler-2lp5VXK7.mjs";
+import { C as resolveThemeColor } from "./src-9B5k0JmY.mjs";
+import { D as init_state, E as getActiveTheme, O as popContextTheme, k as pushContextTheme, x as init_resolve } from "./src-C9f3hiVG.mjs";
+import { r as getLayoutEngine } from "./layout-engine-B3dsnVLU.mjs";
+import { t as rectEqual } from "./types-Bhj5QkIQ.mjs";
+import { createLogger } from "loggily";
+//#region packages/ag-term/src/pipeline/prepared-text.ts
+const MAX_FORMAT_ENTRIES = 4;
+/** Content-affecting flags that invalidate plain text. */
+const PLAIN_TEXT_DIRTY = 9;
+/**
+* All flags that affect collected text (ANSI codes, bg segments, child spans).
+* SUBTREE_BIT is included because collectTextWithBg recurses into virtual text
+* children — a child's style change sets SUBTREE_BIT on the parent without
+* setting STYLE_PROPS_BIT (the parent's own props didn't change).
+*/
+const COLLECTED_TEXT_DIRTY = 31;
+/** Set to true to disable all caching (for testing/debugging). */
+let _cacheDisabled = !!process.env.SILVERY_NO_TEXT_CACHE;
+const textCaches = /* @__PURE__ */ new WeakMap();
+function getOrCreate(node) {
+	let entry = textCaches.get(node);
+	if (!entry) {
+		entry = {
+			plainText: null,
+			plainTextLineCount: 0,
+			collected: null,
+			collectedMaxDisplayWidth: void 0,
+			formats: [],
+			analysis: null
+		};
+		textCaches.set(node, entry);
+	}
+	return entry;
+}
+/**
+* Get cached plain text and line count.
+* Returns null on cache miss (content/children changed or first access).
+*/
+function getCachedPlainText(node) {
+	if (_cacheDisabled) return null;
+	const entry = textCaches.get(node);
+	if (entry?.plainText == null) return null;
+	if (isDirty(node.dirtyBits, node.dirtyEpoch, PLAIN_TEXT_DIRTY)) {
+		entry.plainText = null;
+		return null;
+	}
+	return {
+		text: entry.plainText,
+		lineCount: entry.plainTextLineCount
+	};
+}
+/** Store plain text in cache. */
+function setCachedPlainText(node, text, lineCount) {
+	const entry = getOrCreate(node);
+	entry.plainText = text;
+	entry.plainTextLineCount = lineCount;
+}
+/**
+* Get cached collected text (from collectTextWithBg).
+* Invalidated by content, children, style, or bg changes, or maxDisplayWidth mismatch.
+*/
+function getCachedCollectedText(node, maxDisplayWidth) {
+	if (_cacheDisabled) return null;
+	const entry = textCaches.get(node);
+	if (!entry?.collected) return null;
+	if (isDirty(node.dirtyBits, node.dirtyEpoch, COLLECTED_TEXT_DIRTY)) {
+		entry.collected = null;
+		entry.formats = [];
+		entry.analysis = null;
+		return null;
+	}
+	if (entry.collectedMaxDisplayWidth !== maxDisplayWidth) {
+		entry.collected = null;
+		entry.formats = [];
+		entry.analysis = null;
+		return null;
+	}
+	return entry.collected;
+}
+/** Store collected text in cache. */
+function setCachedCollectedText(node, result, maxDisplayWidth) {
+	const entry = getOrCreate(node);
+	entry.collected = result;
+	entry.collectedMaxDisplayWidth = maxDisplayWidth;
+}
+/**
+* Get cached formatted lines for the given width/wrap/trim.
+* Returns null on cache miss.
+*/
+function getCachedFormat(node, width, wrap, trim) {
+	if (_cacheDisabled) return null;
+	const entry = textCaches.get(node);
+	if (!entry || entry.formats.length === 0) return null;
+	for (let i = 0; i < entry.formats.length; i++) {
+		const f = entry.formats[i];
+		if (f.width === width && f.wrap === wrap && f.trim === trim) {
+			if (i < entry.formats.length - 1) {
+				entry.formats.splice(i, 1);
+				entry.formats.push(f);
+			}
+			return f;
+		}
+	}
+	return null;
+}
+/** Store formatted lines in cache (LRU, evicts oldest when full). */
+function setCachedFormat(node, width, wrap, trim, lines, lineOffsets, hasLineOffsets) {
+	const entry = getOrCreate(node);
+	for (let i = 0; i < entry.formats.length; i++) {
+		const f = entry.formats[i];
+		if (f.width === width && f.wrap === wrap && f.trim === trim) {
+			entry.formats[i] = {
+				width,
+				wrap,
+				trim,
+				lines,
+				lineOffsets,
+				hasLineOffsets
+			};
+			return;
+		}
+	}
+	if (entry.formats.length >= MAX_FORMAT_ENTRIES) entry.formats.shift();
+	entry.formats.push({
+		width,
+		wrap,
+		trim,
+		lines,
+		lineOffsets,
+		hasLineOffsets
+	});
+}
+/**
+* Get cached text analysis. Invalidated when content changes.
+* Uses PLAIN_TEXT_DIRTY (not COLLECTED_TEXT_DIRTY) because analysis
+* is built from plain text in measure phase, not styled text.
+*/
+function getCachedAnalysis(node) {
+	if (_cacheDisabled) return null;
+	const entry = textCaches.get(node);
+	if (!entry?.analysis) return null;
+	if (isDirty(node.dirtyBits, node.dirtyEpoch, PLAIN_TEXT_DIRTY)) {
+		entry.analysis = null;
+		return null;
+	}
+	return entry.analysis;
+}
+/** Store text analysis in cache. */
+function setCachedAnalysis(node, analysis) {
+	const entry = getOrCreate(node);
+	entry.analysis = analysis;
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/pretext.ts
+/**
+* Pretext: Grapheme-indexed text analysis for layout queries.
+*
+* Inspired by https://chenglou.me/pretext/ — prepare text once, measure at
+* any width cheaply. Enables layout algorithms CSS can't express:
+*
+* - **Shrinkwrap**: find the narrowest width that keeps the same line count
+* - **Balanced**: equalize line widths (reduce raggedness)
+* - **Knuth-Plass**: optimal paragraph breaking (minimize total raggedness)
+* - **Height prediction**: exact line count at any width without full wrapping
+*/
+/**
+* Build text analysis from an ANSI-embedded text string.
+* O(N) where N is grapheme count. Call once per text change (cached by PreparedText).
+*/
+function buildTextAnalysis(text, gWidthFn = graphemeWidth) {
+	const graphemes = splitGraphemesAnsiAware(text);
+	const len = graphemes.length;
+	const widths = new Array(len);
+	const cumWidths = new Array(len + 1);
+	const newlineIndices = [];
+	const breakIndices = [];
+	cumWidths[0] = 0;
+	let maxWordWidth = 0;
+	let maxGraphemeWidth = 0;
+	let currentWordWidth = 0;
+	for (let i = 0; i < len; i++) {
+		const g = graphemes[i];
+		const w = gWidthFn(g);
+		widths[i] = w;
+		cumWidths[i + 1] = cumWidths[i] + w;
+		if (w > maxGraphemeWidth) maxGraphemeWidth = w;
+		if (g === "\n") {
+			newlineIndices.push(i);
+			maxWordWidth = Math.max(maxWordWidth, currentWordWidth);
+			currentWordWidth = 0;
+		} else if (isWordBoundary(g)) {
+			breakIndices.push(i + 1);
+			maxWordWidth = Math.max(maxWordWidth, currentWordWidth);
+			currentWordWidth = 0;
+		} else if (canBreakAnywhere(g)) {
+			breakIndices.push(i);
+			maxWordWidth = Math.max(maxWordWidth, currentWordWidth);
+			currentWordWidth = w;
+		} else if (w > 0) currentWordWidth += w;
+	}
+	maxWordWidth = Math.max(maxWordWidth, currentWordWidth);
+	return {
+		graphemes,
+		widths,
+		cumWidths,
+		totalWidth: cumWidths[len],
+		maxWordWidth,
+		maxGraphemeWidth,
+		newlineIndices,
+		breakIndices,
+		text
+	};
+}
+/**
+* Count how many lines text would occupy at a given width.
+*
+* Delegates to wrapText for correctness — the greedy wrapping algorithm has
+* subtle boundary-char handling (spaces consumed on overflow, leading space
+* trimming on continuation lines) that's error-prone to reimplement.
+*
+* For terminal text (20-200 chars), wrapText is ~5-12µs per call.
+* Shrinkwrap does ~7-9 calls (log2(width)), so total is ~50-100µs.
+*/
+function countLinesAtWidth(analysis, width) {
+	if (width <= 0) return Infinity;
+	if (analysis.totalWidth <= width && analysis.newlineIndices.length === 0) return 1;
+	return wrapText(analysis.text, width, true, true).length;
+}
+/**
+* Find the narrowest integer width that produces the same line count as maxWidth.
+*
+* CSS fit-content uses the widest wrapped line — leaving dead space when the
+* last line is short. Shrinkwrap binary-searches for the tightest width that
+* keeps the same number of lines, eliminating wasted area in bubbles/cards.
+*
+* O(log(maxWidth) × wrapText) — ~7-9 iterations for terminal widths.
+*/
+function shrinkwrapWidth(analysis, maxWidth) {
+	if (maxWidth <= 0) return 0;
+	const targetLineCount = countLinesAtWidth(analysis, maxWidth);
+	if (targetLineCount <= 1) return Math.min(Math.ceil(analysis.totalWidth), maxWidth);
+	let lo = Math.max(1, analysis.maxGraphemeWidth);
+	let hi = maxWidth;
+	if (lo >= hi) return Math.min(hi, maxWidth);
+	while (lo < hi) {
+		const mid = lo + hi >> 1;
+		if (countLinesAtWidth(analysis, mid) <= targetLineCount) hi = mid;
+		else lo = mid + 1;
+	}
+	return Math.min(lo, maxWidth);
+}
+/**
+* Find optimal line breaks that minimize total raggedness.
+*
+* Runs per-paragraph (split by newlines) to avoid penalty interactions
+* around forced breaks. Falls back to greedy wrapping for paragraphs
+* where the DP finds no feasible solution (overlong words).
+*
+* O(breakpoints²) per paragraph, typically much less with pruning.
+*/
+function knuthPlassBreaks(analysis, width) {
+	if (width <= 0) return [];
+	if (analysis.totalWidth <= width && analysis.newlineIndices.length === 0) return [];
+	const { newlineIndices, graphemes } = analysis;
+	const allBreaks = [];
+	const paragraphStarts = [0];
+	for (const nl of newlineIndices) paragraphStarts.push(nl + 1);
+	for (let p = 0; p < paragraphStarts.length; p++) {
+		const pStart = paragraphStarts[p];
+		const pEnd = p + 1 < paragraphStarts.length ? paragraphStarts[p + 1] - 1 : graphemes.length;
+		if (pStart >= pEnd) continue;
+		const breaks = knuthPlassForParagraph(analysis, pStart, pEnd, width);
+		allBreaks.push(...breaks);
+		if (p < paragraphStarts.length - 1 && pEnd < graphemes.length) allBreaks.push(pEnd + 1);
+	}
+	return allBreaks;
+}
+/** DP for a single paragraph (no newlines). */
+function knuthPlassForParagraph(analysis, pStart, pEnd, width) {
+	const { cumWidths, breakIndices, widths, graphemes } = analysis;
+	const candidates = [pStart];
+	for (const bp of breakIndices) if (bp > pStart && bp <= pEnd) candidates.push(bp);
+	candidates.push(pEnd);
+	const n = candidates.length;
+	if (n <= 2) return [];
+	const cost = new Array(n).fill(Infinity);
+	const next = new Array(n).fill(-1);
+	cost[n - 1] = 0;
+	for (let i = n - 2; i >= 0; i--) {
+		const lineStart = candidates[i];
+		const lineStartCum = cumWidths[lineStart];
+		for (let j = i + 1; j < n; j++) {
+			let trimEnd = candidates[j];
+			while (trimEnd > lineStart) {
+				const prevG = graphemes[trimEnd - 1];
+				if (widths[trimEnd - 1] === 0) {
+					trimEnd--;
+					continue;
+				}
+				if (prevG === " " || prevG === "	") {
+					trimEnd--;
+					continue;
+				}
+				break;
+			}
+			const lineWidth = cumWidths[trimEnd] - lineStartCum;
+			if (lineWidth > width) break;
+			const leftover = width - lineWidth;
+			const totalCost = (j === n - 1 ? 0 : leftover * leftover) + cost[j];
+			if (totalCost < cost[i]) {
+				cost[i] = totalCost;
+				next[i] = j;
+			}
+		}
+	}
+	if (cost[0] === Infinity) return [];
+	const breaks = [];
+	let idx = 0;
+	while (idx < n - 1 && next[idx] >= 0) {
+		idx = next[idx];
+		if (idx < n - 1) breaks.push(candidates[idx]);
+	}
+	return breaks;
+}
+/**
+* Wrap text using Knuth-Plass optimal breaks.
+* Returns line strings — drop-in replacement for greedy wrap.
+* Falls back to greedy wrapText when DP finds no feasible solution.
+*/
+function optimalWrap(text, analysis, width) {
+	const breaks = knuthPlassBreaks(analysis, width);
+	if (breaks.length === 0) {
+		if (analysis.totalWidth <= width && analysis.newlineIndices.length === 0) return [text];
+		return wrapText(text, width, true, true);
+	}
+	const { graphemes, widths } = analysis;
+	const lines = [];
+	let lineStart = 0;
+	for (const bp of breaks) {
+		let lineEnd = bp;
+		while (lineEnd > lineStart) {
+			if (widths[lineEnd - 1] === 0) {
+				lineEnd--;
+				continue;
+			}
+			const g = graphemes[lineEnd - 1];
+			if (g === " " || g === "	" || g === "\n") {
+				lineEnd--;
+				continue;
+			}
+			break;
+		}
+		lines.push(graphemes.slice(lineStart, lineEnd).join(""));
+		lineStart = bp;
+		while (lineStart < graphemes.length) {
+			const g = graphemes[lineStart];
+			if (g === " " || g === "	") {
+				lineStart++;
+				continue;
+			}
+			break;
+		}
+	}
+	if (lineStart < graphemes.length) lines.push(graphemes.slice(lineStart).join(""));
+	return lines;
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/helpers.ts
+/**
+* Get padding values from props.
+*/
+function getPadding(props) {
+	return {
+		top: props.paddingTop ?? props.paddingY ?? props.padding ?? 0,
+		bottom: props.paddingBottom ?? props.paddingY ?? props.padding ?? 0,
+		left: props.paddingLeft ?? props.paddingX ?? props.padding ?? 0,
+		right: props.paddingRight ?? props.paddingX ?? props.padding ?? 0
+	};
+}
+/**
+* Get border size (1 or 0 for each side).
+* In pixel/canvas mode (lineHeight > 1), borders are visual-only (fillRoundedRect)
+* and don't affect content positioning — returns 0.
+*/
+function getBorderSize(props) {
+	if (!props.borderStyle || getActiveLineHeight() > 1) return {
+		top: 0,
+		bottom: 0,
+		left: 0,
+		right: 0
+	};
+	return {
+		top: props.borderTop !== false ? 1 : 0,
+		bottom: props.borderBottom !== false ? 1 : 0,
+		left: props.borderLeft !== false ? 1 : 0,
+		right: props.borderRight !== false ? 1 : 0
+	};
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/measure-phase.ts
+/**
+* Handle fit-content nodes by measuring their intrinsic content size.
+*
+* Traverses the tree and for any node with width="fit-content" or
+* height="fit-content", measures the content and sets the Yoga constraint.
+*/
+function measurePhase(root, ctx) {
+	traverseTree$1(root, (node) => {
+		if (!node.layoutNode) return;
+		const props = node.props;
+		const isFitContent = props.width === "fit-content" || props.height === "fit-content";
+		const isSnugContent = props.width === "snug-content";
+		if (isFitContent || isSnugContent) {
+			let availableWidth;
+			const widthIsFixed = typeof props.width === "number";
+			if (props.height === "fit-content" && widthIsFixed) {
+				const padding = getPadding(props);
+				availableWidth = props.width - padding.left - padding.right;
+				if (props.borderStyle) {
+					const border = getBorderSize(props);
+					availableWidth -= border.left + border.right;
+				}
+				if (availableWidth < 1) availableWidth = 1;
+			}
+			const intrinsicSize = measureIntrinsicSize(node, ctx, availableWidth);
+			if (isSnugContent) {
+				const shrunkWidth = computeSnugContentWidth(node, intrinsicSize.width, ctx);
+				node.layoutNode.setWidth(shrunkWidth);
+			} else if (props.width === "fit-content") node.layoutNode.setWidth(intrinsicSize.width);
+			if (props.height === "fit-content") node.layoutNode.setHeight(intrinsicSize.height);
+		}
+	});
+}
+/**
+* Measure the intrinsic size of a node's content.
+*
+* For text nodes: measures the text width and line count.
+* For box nodes: recursively measures children based on flex direction.
+*
+* @param availableWidth - When set, text nodes wrap at this width for height calculation.
+*   Used when a container has fixed width + fit-content height.
+*/
+function measureIntrinsicSize(node, ctx, availableWidth) {
+	const props = node.props;
+	if (props.display === "none") return {
+		width: 0,
+		height: 0
+	};
+	if (node.type === "silvery-text") {
+		const textProps = props;
+		const cached = getCachedPlainText(node);
+		let text;
+		if (cached) text = cached.text;
+		else {
+			text = collectPlainText(node);
+			const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+			setCachedPlainText(node, text, lineCount);
+		}
+		const transform = textProps.internal_transform;
+		let lines;
+		if (availableWidth !== void 0 && availableWidth > 0 && isWrapEnabled(textProps.wrap)) lines = ctx ? ctx.measurer.wrapText(text, availableWidth, true, true) : wrapText(text, availableWidth, true, true);
+		else lines = text.split("\n");
+		if (transform) lines = lines.map((line, index) => transform(line, index));
+		return {
+			width: Math.max(...lines.map((line) => getTextWidth$1(line, ctx))),
+			height: lines.length * getActiveLineHeight()
+		};
+	}
+	const isRow = props.flexDirection === "row" || props.flexDirection === "row-reverse";
+	let width = 0;
+	let height = 0;
+	let childCount = 0;
+	for (const child of node.children) {
+		const childSize = measureIntrinsicSize(child, ctx, availableWidth);
+		childCount++;
+		if (isRow) {
+			width += childSize.width;
+			height = Math.max(height, childSize.height);
+		} else {
+			width = Math.max(width, childSize.width);
+			height += childSize.height;
+		}
+	}
+	const gap = props.gap ?? 0;
+	if (gap > 0 && childCount > 1) {
+		const totalGap = gap * (childCount - 1);
+		if (isRow) width += totalGap;
+		else height += totalGap;
+	}
+	const padding = getPadding(props);
+	width += padding.left + padding.right;
+	height += padding.top + padding.bottom;
+	if (props.borderStyle) {
+		const border = getBorderSize(props);
+		width += border.left + border.right;
+		height += border.top + border.bottom;
+	}
+	return {
+		width,
+		height
+	};
+}
+/**
+* Check if text wrapping is enabled for a text node.
+*/
+function isWrapEnabled(wrap) {
+	return wrap === "wrap" || wrap === "hard" || wrap === "even" || wrap === true || wrap === void 0;
+}
+/**
+* Compute snug-content width for a node.
+* Uses Pretext analysis to binary-search for the tightest width
+* that keeps the same line count as the fit-content width.
+*/
+function computeSnugContentWidth(node, fitContentWidth, ctx) {
+	const props = node.props;
+	let overhead = 0;
+	const padding = getPadding(props);
+	overhead += padding.left + padding.right;
+	if (props.borderStyle) {
+		const border = getBorderSize(props);
+		overhead += border.left + border.right;
+	}
+	const contentWidth = fitContentWidth - overhead;
+	let analysis = getCachedAnalysis(node);
+	if (!analysis) {
+		const cached = getCachedPlainText(node);
+		const text = cached ? cached.text : collectPlainText(node);
+		analysis = buildTextAnalysis(text, ctx?.measurer?.graphemeWidth?.bind(ctx.measurer) ?? graphemeWidth);
+		setCachedAnalysis(node, analysis);
+		if (!cached) setCachedPlainText(node, text, (text.match(/\n/g)?.length ?? 0) + 1);
+	}
+	return shrinkwrapWidth(analysis, contentWidth) + overhead;
+}
+/**
+* Traverse tree in depth-first order.
+*/
+function traverseTree$1(node, callback) {
+	callback(node);
+	for (const child of node.children) traverseTree$1(child, callback);
+}
+/**
+* Get text display width (accounting for wide characters and ANSI codes).
+* Uses ANSI-aware width calculation to handle styled text.
+*/
+function getTextWidth$1(text, ctx) {
+	if (ctx) return ctx.measurer.displayWidthAnsi(text);
+	return displayWidthAnsi(text);
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/layout-phase.ts
+/**
+* Phase 2: Layout Phase
+*
+* Run Yoga layout calculation and propagate dimensions to all nodes.
+*/
+const log$3 = createLogger("silvery:layout");
+/**
+* Run Yoga layout calculation and propagate dimensions to all nodes.
+*
+* @param root The root SilveryNode
+* @param width Terminal width in columns
+* @param height Terminal height in rows
+*/
+function layoutPhase(root, width, height) {
+	const prevLayout = root.boxRect;
+	const dimensionsChanged = prevLayout && (prevLayout.width !== width || prevLayout.height !== height);
+	if (!dimensionsChanged && !hasLayoutDirty()) return;
+	clearLayoutDirtyTracking();
+	if (root.layoutNode) {
+		const nodeCount = countNodes(root);
+		measureStats.reset();
+		const t0 = Date.now();
+		root.layoutNode.calculateLayout(width, height);
+		const elapsed = Date.now() - t0;
+		log$3.debug?.(`calculateLayout: ${elapsed}ms (${nodeCount} nodes) measure: calls=${measureStats.calls} hits=${measureStats.cacheHits} collects=${measureStats.textCollects} displayWidth=${measureStats.displayWidthCalls}`);
+	}
+	propagateLayout(root, 0, 0, !dimensionsChanged);
+}
+/**
+* Count total nodes in tree.
+*/
+function countNodes(node) {
+	let count = 1;
+	for (const child of node.children) count += countNodes(child);
+	return count;
+}
+/**
+* Propagate computed layout from Yoga nodes to SilveryNodes.
+* Sets boxRect (content-relative position) on each node.
+*
+* When `incrementalSkip` is true, nodes whose Flexily-computed rect matches
+* their existing boxRect can skip the entire subtree — their layout is
+* unchanged. This converts the O(N) tree walk into O(dirty) for frames
+* where only a few nodes changed layout.
+*
+* The skip is safe because:
+* - Flexily's internal fingerprint caching guarantees identical output for
+*   subtrees whose inputs didn't change
+* - If the parent's rect matches, all descendants' rects also match
+*   (Flexily computes absolute positions from parent dimensions)
+* - prevLayout, layoutDirty (already false), and layoutChangedThisFrame
+*   (stale epoch, won't match current) all retain correct values
+*
+* @param node The node to process
+* @param parentX Absolute X position of parent
+* @param parentY Absolute Y position of parent
+* @param incrementalSkip When true, skip subtrees where Flexily results match existing boxRect
+*/
+function propagateLayout(node, parentX, parentY, incrementalSkip) {
+	if (!node.layoutNode) {
+		node.prevLayout = node.boxRect;
+		node.boxRect = {
+			x: parentX,
+			y: parentY,
+			width: 0,
+			height: 0
+		};
+		node.layoutDirty = false;
+		for (const child of node.children) propagateLayout(child, parentX, parentY, incrementalSkip);
+		return;
+	}
+	const rect = {
+		x: parentX + node.layoutNode.getComputedLeft(),
+		y: parentY + node.layoutNode.getComputedTop(),
+		width: node.layoutNode.getComputedWidth(),
+		height: node.layoutNode.getComputedHeight()
+	};
+	if (incrementalSkip && node.boxRect && !node.layoutDirty && !isDirty(node.dirtyBits, node.dirtyEpoch, 16) && !isDirty(node.dirtyBits, node.dirtyEpoch, 8)) {
+		if (rect.x === node.boxRect.x && rect.y === node.boxRect.y && rect.width === node.boxRect.width && rect.height === node.boxRect.height) return;
+	}
+	node.prevLayout = node.boxRect;
+	node.boxRect = rect;
+	node.layoutDirty = false;
+	node.layoutChangedThisFrame = !!(node.prevLayout && !rectEqual(node.prevLayout, node.boxRect)) ? getRenderEpoch() : -1;
+	if (process?.env?.SILVERY_STRICT && isCurrentEpoch(node.layoutChangedThisFrame)) {
+		if (rectEqual(node.prevLayout, node.boxRect)) {
+			const props = node.props;
+			throw new Error(`[SILVERY_STRICT] layoutChangedThisFrame=true but prevLayout equals boxRect (node: ${props.id ?? node.type}, rect: ${JSON.stringify(node.boxRect)})`);
+		}
+	}
+	if (isCurrentEpoch(node.layoutChangedThisFrame)) {
+		const epoch = getRenderEpoch();
+		let ancestor = node.parent;
+		while (ancestor && !isDirty(ancestor.dirtyBits, ancestor.dirtyEpoch, 16)) {
+			if (ancestor.dirtyEpoch !== epoch) {
+				ancestor.dirtyBits = 16;
+				ancestor.dirtyEpoch = epoch;
+			} else ancestor.dirtyBits |= 16;
+			ancestor = ancestor.parent;
+		}
+	}
+	for (const child of node.children) propagateLayout(child, rect.x, rect.y, incrementalSkip);
+	if (isDirty(node.dirtyBits, node.dirtyEpoch, 16) && node.children.length > 0) {
+		const epoch = getRenderEpoch();
+		const absChild = _hasAbsoluteChildMutated(node.children);
+		const descOverflow = _hasDescendantOverflowChanged(node, rect);
+		let bits = node.dirtyBits;
+		if (absChild) bits |= 32;
+		else bits &= -33;
+		if (descOverflow) bits |= 64;
+		else bits &= -65;
+		node.dirtyBits = bits;
+		node.dirtyEpoch = epoch;
+	} else if (node.dirtyEpoch === getRenderEpoch()) node.dirtyBits &= -97;
+}
+/**
+* Check if any direct child is position="absolute" and had structural changes.
+*/
+function _hasAbsoluteChildMutated(children) {
+	for (const child of children) if (child.props.position === "absolute" && (isDirty(child.dirtyBits, child.dirtyEpoch, 8) || isCurrentEpoch(child.layoutChangedThisFrame) || _hasChildPositionChanged(child))) return true;
+	return false;
+}
+/**
+* Check if any child's position changed (boxRect vs prevLayout).
+*/
+function _hasChildPositionChanged(node) {
+	for (const child of node.children) if (child.boxRect && child.prevLayout) {
+		if (child.boxRect.x !== child.prevLayout.x || child.boxRect.y !== child.prevLayout.y) return true;
+	}
+	return false;
+}
+/**
+* Check if any descendant was overflowing THIS node's rect and had its layout change.
+* Recursive: follows subtreeDirty paths for efficiency.
+*/
+function _hasDescendantOverflowChanged(node, rect) {
+	return _checkDescendantOverflow(node.children, rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
+}
+function _checkDescendantOverflow(children, nodeLeft, nodeTop, nodeRight, nodeBottom) {
+	for (const child of children) {
+		if (child.prevLayout && isCurrentEpoch(child.layoutChangedThisFrame)) {
+			const prev = child.prevLayout;
+			if (prev.x + prev.width > nodeRight || prev.y + prev.height > nodeBottom || prev.x < nodeLeft || prev.y < nodeTop) return true;
+		}
+		if (isDirty(child.dirtyBits, child.dirtyEpoch, 16) && child.children !== void 0) {
+			if (_checkDescendantOverflow(child.children, nodeLeft, nodeTop, nodeRight, nodeBottom)) return true;
+		}
+	}
+	return false;
+}
+/**
+* Notify all layout subscribers of dimension changes.
+*
+* Called from executeRender AFTER scrollrectPhase completes,
+* so useScrollRect can read correct screen positions.
+*
+* Notifies when EITHER boxRect, scrollRect, or screenRect changed.
+* scrollRect can change from scroll offset changes even when
+* boxRect stays the same — subscribers (like useScrollRect)
+* need notification in both cases. screenRect can change from sticky
+* offset changes even when scrollRect stays the same.
+*/
+function notifyLayoutSubscribers(node) {
+	const contentChanged = !rectEqual(node.prevLayout, node.boxRect);
+	const screenChanged = !rectEqual(node.prevScrollRect, node.scrollRect);
+	const renderChanged = !rectEqual(node.prevScreenRect, node.screenRect);
+	if (contentChanged || screenChanged || renderChanged) for (const subscriber of node.layoutSubscribers) subscriber();
+	for (const child of node.children) notifyLayoutSubscribers(child);
+}
+/**
+* Calculate scroll state for all overflow='scroll' containers.
+*
+* This phase runs after layout to determine which children are visible
+* within each scrollable container.
+*/
+function scrollPhase(root, options = {}) {
+	const { skipStateUpdates = false } = options;
+	traverseTree(root, (node) => {
+		const props = node.props;
+		if (props.overflow !== "scroll") return;
+		calculateScrollState(node, props, skipStateUpdates);
+	});
+}
+/**
+* Calculate scroll state for a single scrollable container.
+*/
+function calculateScrollState(node, props, skipStateUpdates) {
+	const layout = node.boxRect;
+	if (!layout || !node.layoutNode) return;
+	const border = props.borderStyle ? getBorderSize(props) : {
+		top: 0,
+		bottom: 0,
+		left: 0,
+		right: 0
+	};
+	const padding = getPadding(props);
+	const rawViewportHeight = layout.height - border.top - border.bottom - padding.top - padding.bottom;
+	let contentHeight = 0;
+	const childPositions = [];
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (!child.layoutNode || !child.boxRect) continue;
+		const childTop = child.boxRect.y - layout.y - border.top - padding.top;
+		const childBottom = childTop + child.boxRect.height;
+		const childProps = child.props;
+		childPositions.push({
+			child,
+			top: childTop,
+			bottom: childBottom,
+			index: i,
+			isSticky: childProps.position === "sticky",
+			stickyTop: childProps.stickyTop,
+			stickyBottom: childProps.stickyBottom
+		});
+		contentHeight = Math.max(contentHeight, childBottom);
+	}
+	const viewportHeight = rawViewportHeight;
+	const indicatorReserve = props.overflowIndicator === true && !props.borderStyle && contentHeight > rawViewportHeight ? 1 : 0;
+	const prevOffset = node.scrollState?.offset;
+	let scrollOffset = props.scrollOffset ?? prevOffset ?? 0;
+	const scrollTo = props.scrollTo;
+	if (scrollTo !== void 0 && scrollTo >= 0 && scrollTo < childPositions.length) {
+		const target = childPositions.find((c) => c.index === scrollTo);
+		if (target) {
+			const effectiveHeight = viewportHeight - indicatorReserve;
+			const visibleTop = scrollOffset;
+			const visibleBottom = scrollOffset + effectiveHeight;
+			if (target.top < visibleTop) scrollOffset = target.top;
+			else if (target.bottom > visibleBottom) scrollOffset = target.bottom - effectiveHeight;
+		}
+	}
+	scrollOffset = Math.max(0, scrollOffset);
+	scrollOffset = Math.min(scrollOffset, Math.max(0, contentHeight - viewportHeight));
+	const visibleTop = scrollOffset;
+	const visibleBottom = scrollOffset + viewportHeight - indicatorReserve;
+	let firstVisible = -1;
+	let lastVisible = -1;
+	let hiddenAbove = 0;
+	let hiddenBelow = 0;
+	for (const cp of childPositions) {
+		if (cp.isSticky) {
+			if (firstVisible === -1) firstVisible = cp.index;
+			lastVisible = Math.max(lastVisible, cp.index);
+			continue;
+		}
+		if (cp.top === cp.bottom) continue;
+		if (cp.bottom <= visibleTop) hiddenAbove++;
+		else if (cp.top >= visibleBottom) hiddenBelow++;
+		else if (cp.top < visibleTop) {
+			if (firstVisible === -1) firstVisible = cp.index;
+			lastVisible = Math.max(lastVisible, cp.index);
+		} else if (cp.bottom > visibleBottom) {
+			if (firstVisible === -1) firstVisible = cp.index;
+			lastVisible = cp.index;
+			if (indicatorReserve > 0) hiddenBelow++;
+		} else {
+			if (firstVisible === -1) firstVisible = cp.index;
+			lastVisible = cp.index;
+		}
+	}
+	const stickyChildren = [];
+	for (const cp of childPositions) {
+		if (!cp.isSticky) continue;
+		const childHeight = cp.bottom - cp.top;
+		const stickyTop = cp.stickyTop ?? 0;
+		const stickyBottom = cp.stickyBottom;
+		const naturalRenderY = cp.top - scrollOffset;
+		let renderOffset;
+		if (stickyBottom !== void 0) {
+			const bottomPinPosition = viewportHeight - stickyBottom - childHeight;
+			renderOffset = Math.min(naturalRenderY, bottomPinPosition);
+		} else if (naturalRenderY >= stickyTop) renderOffset = naturalRenderY;
+		else if (childHeight > viewportHeight) renderOffset = Math.max(viewportHeight - childHeight, naturalRenderY);
+		else renderOffset = stickyTop;
+		if (renderOffset !== naturalRenderY) if (childHeight > viewportHeight) renderOffset = Math.max(viewportHeight - childHeight, renderOffset);
+		else renderOffset = Math.max(0, Math.min(renderOffset, viewportHeight - childHeight));
+		if (renderOffset + childHeight <= 0 || renderOffset >= viewportHeight) continue;
+		stickyChildren.push({
+			index: cp.index,
+			renderOffset,
+			naturalTop: cp.top,
+			height: childHeight
+		});
+	}
+	if (skipStateUpdates) return;
+	const prevFirstVisible = node.scrollState?.firstVisibleChild ?? firstVisible;
+	const prevLastVisible = node.scrollState?.lastVisibleChild ?? lastVisible;
+	if (scrollOffset !== prevOffset || firstVisible !== prevFirstVisible || lastVisible !== prevLastVisible) {
+		const epoch = getRenderEpoch();
+		if (node.dirtyEpoch !== epoch) {
+			node.dirtyBits = 16;
+			node.dirtyEpoch = epoch;
+		} else node.dirtyBits |= 16;
+	}
+	node.scrollState = {
+		offset: scrollOffset,
+		prevOffset: prevOffset ?? scrollOffset,
+		contentHeight,
+		viewportHeight,
+		firstVisibleChild: firstVisible,
+		lastVisibleChild: lastVisible,
+		prevFirstVisibleChild: prevFirstVisible,
+		prevLastVisibleChild: prevLastVisible,
+		hiddenAbove,
+		hiddenBelow,
+		stickyChildren: stickyChildren.length > 0 ? stickyChildren : void 0
+	};
+}
+/**
+* Compute sticky offsets for non-scroll containers that have sticky children.
+*
+* Scroll containers handle their own sticky logic in calculateScrollState().
+* This phase handles the remaining case: parents that are NOT overflow="scroll"
+* but still contain position="sticky" children with stickyBottom.
+*
+* For non-scroll containers, sticky means: pin the child to the parent's bottom
+* edge when content is shorter than the parent. When content fills the parent,
+* the child stays at its natural position.
+*/
+function stickyPhase(root) {
+	traverseTree(root, (node) => {
+		const props = node.props;
+		if (props.overflow === "scroll") return;
+		let hasStickyChildren = false;
+		for (const child of node.children) {
+			const childProps = child.props;
+			if (childProps.position === "sticky" && childProps.stickyBottom !== void 0) {
+				hasStickyChildren = true;
+				break;
+			}
+		}
+		if (!hasStickyChildren) {
+			if (node.stickyChildren !== void 0) {
+				node.stickyChildren = void 0;
+				const epoch = getRenderEpoch();
+				if (node.dirtyEpoch !== epoch) {
+					node.dirtyBits = 16;
+					node.dirtyEpoch = epoch;
+				} else node.dirtyBits |= 16;
+			}
+			return;
+		}
+		const layout = node.boxRect;
+		if (!layout || !node.layoutNode) return;
+		const border = props.borderStyle ? getBorderSize(props) : {
+			top: 0,
+			bottom: 0,
+			left: 0,
+			right: 0
+		};
+		const padding = getPadding(props);
+		const parentContentHeight = layout.height - border.top - border.bottom - padding.top - padding.bottom;
+		const newStickyChildren = [];
+		for (let i = 0; i < node.children.length; i++) {
+			const child = node.children[i];
+			const childProps = child.props;
+			if (childProps.position !== "sticky") continue;
+			if (childProps.stickyBottom === void 0) continue;
+			if (!child.boxRect) continue;
+			const naturalY = child.boxRect.y - layout.y - border.top - padding.top;
+			const childHeight = child.boxRect.height;
+			const bottomPin = parentContentHeight - childProps.stickyBottom - childHeight;
+			const renderOffset = Math.max(naturalY, bottomPin);
+			newStickyChildren.push({
+				index: i,
+				renderOffset,
+				naturalTop: naturalY,
+				height: childHeight
+			});
+		}
+		const prev = node.stickyChildren;
+		const next = newStickyChildren.length > 0 ? newStickyChildren : void 0;
+		const changed = !stickyChildrenEqual(prev, next);
+		node.stickyChildren = next;
+		if (changed) {
+			const epoch = getRenderEpoch();
+			if (node.dirtyEpoch !== epoch) {
+				node.dirtyBits = 16;
+				node.dirtyEpoch = epoch;
+			} else node.dirtyBits |= 16;
+		}
+	});
+}
+/**
+* Compare two stickyChildren arrays for equality.
+*/
+function stickyChildrenEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		const ai = a[i];
+		const bi = b[i];
+		if (ai.index !== bi.index || ai.renderOffset !== bi.renderOffset || ai.naturalTop !== bi.naturalTop || ai.height !== bi.height) return false;
+	}
+	return true;
+}
+/**
+* Traverse tree in depth-first order.
+*/
+function traverseTree(node, callback) {
+	callback(node);
+	for (const child of node.children) traverseTree(child, callback);
+}
+/**
+* Calculate screen-relative positions for all nodes.
+*
+* This phase runs after scroll phase to compute where each node actually
+* appears on the terminal screen, accounting for all ancestor scroll offsets.
+*
+* Also computes `screenRect` which accounts for sticky render offsets.
+* For non-sticky nodes, screenRect === scrollRect. For sticky nodes,
+* screenRect reflects the actual pixel position where the node is painted.
+*
+* Screen position = content position - sum of ancestor scroll offsets
+*/
+function scrollrectPhase(root) {
+	propagateScrollRect(root, 0);
+}
+/**
+* Fast path for scrollrectPhase when no scroll containers or sticky nodes exist.
+*
+* When there are no scroll containers and no sticky nodes, ancestorScrollOffset
+* is always 0, so scrollRect === boxRect and screenRect === scrollRect. This
+* avoids the overhead of accumulating scroll offsets through the tree.
+*/
+function scrollrectPhaseSimple(root) {
+	propagateScrollRectSimple(root);
+}
+/**
+* Propagate screen-relative positions through the tree.
+*
+* @param node The node to process
+* @param ancestorScrollOffset Sum of all ancestor scroll offsets
+*/
+function propagateScrollRect(node, ancestorScrollOffset) {
+	node.prevScrollRect = node.scrollRect;
+	node.prevScreenRect = node.screenRect;
+	const content = node.boxRect;
+	if (!content) {
+		node.scrollRect = null;
+		node.screenRect = null;
+		for (const child of node.children) propagateScrollRect(child, ancestorScrollOffset);
+		return;
+	}
+	node.scrollRect = {
+		x: content.x,
+		y: content.y - ancestorScrollOffset,
+		width: content.width,
+		height: content.height
+	};
+	node.screenRect = node.scrollRect;
+	const childScrollOffset = ancestorScrollOffset + (node.scrollState?.offset ?? 0);
+	computeStickyScreenRects(node);
+	for (const child of node.children) propagateScrollRect(child, childScrollOffset);
+}
+/**
+* Compute screenRect for sticky children of a node.
+*
+* For sticky children, the actual render position differs from the layout
+* position (scrollRect). The renderOffset from the scroll/sticky phase
+* determines where pixels are actually painted. This function sets
+* screenRect on those children to reflect the true screen position.
+*
+* @param parent The parent node whose sticky children need screenRect computation
+*/
+function computeStickyScreenRects(parent) {
+	const stickyList = parent.scrollState?.stickyChildren ?? parent.stickyChildren;
+	if (!stickyList || stickyList.length === 0) return;
+	const parentScrollRect = parent.scrollRect;
+	if (!parentScrollRect) return;
+	const props = parent.props;
+	const border = props.borderStyle ? getBorderSize(props) : {
+		top: 0,
+		bottom: 0,
+		left: 0,
+		right: 0
+	};
+	const padding = getPadding(props);
+	const contentOriginY = parentScrollRect.y + border.top + padding.top;
+	for (const sticky of stickyList) {
+		const child = parent.children[sticky.index];
+		if (!child?.scrollRect) continue;
+		child.screenRect = {
+			x: child.scrollRect.x,
+			y: contentOriginY + sticky.renderOffset,
+			width: child.scrollRect.width,
+			height: child.scrollRect.height
+		};
+	}
+}
+/**
+* Simple scrollRect propagation for trees without scroll containers or sticky nodes.
+* When ancestorScrollOffset is always 0, scrollRect === boxRect and screenRect === scrollRect.
+* Saves the overhead of accumulating scroll offsets and computing sticky screen rects.
+*/
+function propagateScrollRectSimple(node) {
+	node.prevScrollRect = node.scrollRect;
+	node.prevScreenRect = node.screenRect;
+	const content = node.boxRect;
+	if (!content) {
+		node.scrollRect = null;
+		node.screenRect = null;
+		for (const child of node.children) propagateScrollRectSimple(child);
+		return;
+	}
+	node.scrollRect = {
+		x: content.x,
+		y: content.y,
+		width: content.width,
+		height: content.height
+	};
+	node.screenRect = node.scrollRect;
+	for (const child of node.children) propagateScrollRectSimple(child);
+}
+/**
+* Scan the tree for features that require optional pipeline phases.
+*
+* Returns feature flags. This is called on every layout pass so newly
+* mounted components are detected. The caller should merge flags with
+* one-way semantics (false → true, never true → false).
+*/
+function detectPipelineFeatures(root) {
+	let hasScroll = false;
+	let hasSticky = false;
+	function scan(node) {
+		const props = node.props;
+		if (props.overflow === "scroll") hasScroll = true;
+		if (props.position === "sticky") hasSticky = true;
+		if (hasScroll && hasSticky) return;
+		for (const child of node.children) {
+			scan(child);
+			if (hasScroll && hasSticky) return;
+		}
+	}
+	scan(root);
+	return {
+		hasScroll,
+		hasSticky
+	};
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/render-helpers.ts
+init_buffer();
+init_state();
+init_resolve();
+const namedColors = {
+	black: 0,
+	red: 1,
+	green: 2,
+	yellow: 3,
+	blue: 4,
+	magenta: 5,
+	cyan: 6,
+	white: 7,
+	gray: 8,
+	grey: 8,
+	blackBright: 8,
+	redBright: 9,
+	greenBright: 10,
+	yellowBright: 11,
+	blueBright: 12,
+	magentaBright: 13,
+	cyanBright: 14,
+	whiteBright: 15
+};
+/**
+* Blend two RGB colors in sRGB space.
+* Formula: result = c1 * (1 - t) + c2 * t, where t is 0..1.
+* Returns an RGB object with each channel clamped to 0-255.
+*/
+function blendColors(c1, c2, t) {
+	return {
+		r: Math.round(c1.r * (1 - t) + c2.r * t),
+		g: Math.round(c1.g * (1 - t) + c2.g * t),
+		b: Math.round(c1.b * (1 - t) + c2.b * t)
+	};
+}
+/**
+* Parse color string to Color type.
+* Supports: mix(c1,c2,amount), $token (theme), named colors, hex (#rgb, #rrggbb), rgb(r,g,b)
+*/
+function parseColor(color) {
+	if (color === "inherit") return null;
+	if (color === "$default") return DEFAULT_BG;
+	if (color.startsWith("mix(") && color.endsWith(")")) {
+		const inner = color.slice(4, -1);
+		const args = [];
+		let depth = 0;
+		let start = 0;
+		for (let i = 0; i < inner.length; i++) if (inner[i] === "(") depth++;
+		else if (inner[i] === ")") depth--;
+		else if (inner[i] === "," && depth === 0) {
+			args.push(inner.slice(start, i).trim());
+			start = i + 1;
+		}
+		args.push(inner.slice(start).trim());
+		if (args.length === 3) {
+			const c1 = parseColor(args[0]);
+			const c2 = parseColor(args[1]);
+			const amountStr = args[2];
+			let t;
+			if (amountStr.endsWith("%")) t = Number.parseFloat(amountStr.slice(0, -1)) / 100;
+			else t = Number.parseFloat(amountStr);
+			if (c1 !== null && c2 !== null && typeof c1 === "object" && typeof c2 === "object" && !Number.isNaN(t)) return blendColors(c1, c2, Math.max(0, Math.min(1, t)));
+			return null;
+		}
+	}
+	if (color.startsWith("$")) {
+		const resolved = resolveThemeColor(color, getActiveTheme());
+		if (resolved && resolved !== color) return parseColor(resolved);
+		return null;
+	}
+	if (color in namedColors) return namedColors[color];
+	if (color.startsWith("#")) {
+		const hex = color.slice(1);
+		if (hex.length === 3) return {
+			r: Number.parseInt(hex[0] + hex[0], 16),
+			g: Number.parseInt(hex[1] + hex[1], 16),
+			b: Number.parseInt(hex[2] + hex[2], 16)
+		};
+		if (hex.length === 6) return {
+			r: Number.parseInt(hex.slice(0, 2), 16),
+			g: Number.parseInt(hex.slice(2, 4), 16),
+			b: Number.parseInt(hex.slice(4, 6), 16)
+		};
+	}
+	const rgbMatch = color.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+	if (rgbMatch) return {
+		r: Number.parseInt(rgbMatch[1], 10),
+		g: Number.parseInt(rgbMatch[2], 10),
+		b: Number.parseInt(rgbMatch[3], 10)
+	};
+	const ansi256Match = color.match(/^ansi256\s*\(\s*(\d+)\s*\)$/i);
+	if (ansi256Match) return Number.parseInt(ansi256Match[1], 10);
+	return null;
+}
+/**
+* Border character sets by style. Hoisted to module scope to avoid
+* re-allocating 7 objects on every call.
+*/
+const borders = {
+	single: {
+		topLeft: "┌",
+		topRight: "┐",
+		bottomLeft: "└",
+		bottomRight: "┘",
+		horizontal: "─",
+		vertical: "│"
+	},
+	double: {
+		topLeft: "╔",
+		topRight: "╗",
+		bottomLeft: "╚",
+		bottomRight: "╝",
+		horizontal: "═",
+		vertical: "║"
+	},
+	round: {
+		topLeft: "╭",
+		topRight: "╮",
+		bottomLeft: "╰",
+		bottomRight: "╯",
+		horizontal: "─",
+		vertical: "│"
+	},
+	bold: {
+		topLeft: "┏",
+		topRight: "┓",
+		bottomLeft: "┗",
+		bottomRight: "┛",
+		horizontal: "━",
+		vertical: "┃"
+	},
+	singleDouble: {
+		topLeft: "╓",
+		topRight: "╖",
+		bottomLeft: "╙",
+		bottomRight: "╜",
+		horizontal: "─",
+		vertical: "║"
+	},
+	doubleSingle: {
+		topLeft: "╒",
+		topRight: "╕",
+		bottomLeft: "╘",
+		bottomRight: "╛",
+		horizontal: "═",
+		vertical: "│"
+	},
+	classic: {
+		topLeft: "+",
+		topRight: "+",
+		bottomLeft: "+",
+		bottomRight: "+",
+		horizontal: "-",
+		vertical: "|"
+	}
+};
+/**
+* Get border characters for a style.
+*/
+function getBorderChars(style) {
+	if (style && typeof style === "object") {
+		const obj = style;
+		const topHorizontal = obj.top ?? obj.horizontal ?? "-";
+		const leftVertical = obj.left ?? obj.vertical ?? "|";
+		return {
+			topLeft: obj.topLeft ?? "+",
+			topRight: obj.topRight ?? "+",
+			bottomLeft: obj.bottomLeft ?? "+",
+			bottomRight: obj.bottomRight ?? "+",
+			horizontal: topHorizontal,
+			vertical: leftVertical,
+			bottomHorizontal: obj.bottom && obj.bottom !== topHorizontal ? obj.bottom : void 0,
+			rightVertical: obj.right && obj.right !== leftVertical ? obj.right : void 0
+		};
+	}
+	return borders[style ?? "single"];
+}
+/**
+* Get text style from props.
+*/
+function getTextStyle(props) {
+	let underlineStyle;
+	if (props.underlineStyle !== void 0) underlineStyle = props.underlineStyle;
+	else if (props.underline) underlineStyle = "single";
+	return {
+		fg: props.color ? parseColor(props.color) : null,
+		bg: props.backgroundColor ? parseColor(props.backgroundColor) : null,
+		underlineColor: props.underlineColor ? parseColor(props.underlineColor) : null,
+		attrs: {
+			bold: props.bold,
+			dim: props.dim || props.dimColor,
+			italic: props.italic,
+			underline: props.underline || !!underlineStyle,
+			underlineStyle,
+			strikethrough: props.strikethrough,
+			inverse: props.inverse
+		}
+	};
+}
+/**
+* Get text display width (accounting for wide characters and ANSI codes).
+* Uses ANSI-aware width calculation to handle styled text.
+*
+* When a PipelineContext is provided, uses the context's measurer for
+* terminal-capability-aware width calculation. Falls back to the module-level
+* displayWidthAnsi (which reads the scoped measurer or default).
+*/
+function getTextWidth(text, ctx) {
+	if (ctx) return ctx.measurer.displayWidthAnsi(text);
+	return displayWidthAnsi(text);
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/render-text.ts
+init_buffer();
+const log$2 = createLogger("silvery:content");
+/** Cached bg conflict mode. Read from env once at module load. */
+let bgConflictMode = (() => {
+	const env = typeof process !== "undefined" ? process.env.SILVERY_BG_CONFLICT?.toLowerCase() : void 0;
+	if (env === "ignore" || env === "warn" || env === "throw") return env;
+	return "throw";
+})();
+/**
+* Get the current background conflict detection mode.
+*/
+function getBgConflictMode() {
+	return bgConflictMode;
+}
+const warnedBgConflicts = /* @__PURE__ */ new Set();
+/** Format a Color value for bg conflict diagnostics */
+function formatBgConflictColor(c) {
+	if (c === null || c === void 0) return "none";
+	if (typeof c === "number") {
+		if (c & 16777216) {
+			const r = c >> 16 & 255;
+			const g = c >> 8 & 255;
+			const b = c & 255;
+			return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+		}
+		return {
+			40: "black",
+			41: "red",
+			42: "green",
+			43: "yellow",
+			44: "blue",
+			45: "magenta",
+			46: "cyan",
+			47: "white",
+			100: "brightBlack",
+			101: "brightRed",
+			102: "brightGreen",
+			103: "brightYellow",
+			104: "brightBlue",
+			105: "brightMagenta",
+			106: "brightCyan",
+			107: "brightWhite"
+		}[c] ?? `palette(${c})`;
+	}
+	return `rgb(${c.r},${c.g},${c.b})`;
+}
+/**
+* Clear the background conflict warning cache.
+* Call this at the start of each render cycle to:
+* - Prevent memory leaks in long-running apps
+* - Allow warnings to repeat after user fixes issues
+*/
+function clearBgConflictWarnings() {
+	warnedBgConflicts.clear();
+}
+/**
+* Build ANSI escape sequence for a style context.
+*
+* Note: backgroundColor is intentionally NOT embedded as ANSI codes.
+* Background color is handled at the buffer level (via BgSegment tracking)
+* to prevent bg bleed across wrapped text lines. See km-silvery.bg-bleed.
+*/
+function styleToAnsi(style) {
+	const parts = [];
+	if (style.color) {
+		const color = parseColor(style.color);
+		if (color !== null) if (typeof color === "number") parts.push(`38;5;${color}`);
+		else parts.push(`38;2;${color.r};${color.g};${color.b}`);
+	}
+	if (style.bold) parts.push("1");
+	if (style.dim) parts.push("2");
+	if (style.italic) parts.push("3");
+	if (style.underlineStyle) parts.push({
+		single: "4:1",
+		double: "4:2",
+		curly: "4:3",
+		dotted: "4:4",
+		dashed: "4:5"
+	}[style.underlineStyle] ?? "4");
+	else if (style.underline) parts.push("4");
+	if (style.underlineColor) {
+		const ulColor = parseColor(style.underlineColor);
+		if (ulColor !== null) if (typeof ulColor === "number") parts.push(`58;5;${ulColor}`);
+		else parts.push(`58;2;${ulColor.r};${ulColor.g};${ulColor.b}`);
+	}
+	if (style.inverse) parts.push("7");
+	if (style.strikethrough) parts.push("9");
+	if (parts.length === 0) return "";
+	return `\x1b[${parts.join(";")}m`;
+}
+/**
+* Merge child props into parent context.
+* Child values override parent values when specified.
+*/
+function mergeStyleContext(parent, childProps) {
+	return {
+		color: childProps.color ?? parent.color,
+		backgroundColor: childProps.backgroundColor ?? parent.backgroundColor,
+		bold: childProps.bold ?? parent.bold,
+		dim: childProps.dim ?? childProps.dimColor ?? parent.dim,
+		italic: childProps.italic ?? parent.italic,
+		underline: childProps.underline ?? childProps.underlineStyle ? true : parent.underline,
+		underlineStyle: childProps.underlineStyle ?? parent.underlineStyle,
+		underlineColor: childProps.underlineColor ?? parent.underlineColor,
+		inverse: childProps.inverse ?? parent.inverse,
+		strikethrough: childProps.strikethrough ?? parent.strikethrough
+	};
+}
+/**
+* Apply text styles as ANSI escape codes with proper push/pop behavior.
+* After the child text, restores the parent context's styles.
+*
+* @param text - The text content to wrap
+* @param childStyle - The merged style for this child (child overrides parent)
+* @param parentStyle - The parent's style context to restore after
+*/
+function applyTextStyleAnsi(text, childStyle, parentStyle) {
+	if (!text) return text;
+	const childAnsi = styleToAnsi(childStyle);
+	const parentAnsi = styleToAnsi(parentStyle);
+	if (!childAnsi) return text;
+	return `${childAnsi}${text}\x1b[0m${parentAnsi}`;
+}
+/**
+* Collect text content and background color segments from a node tree.
+*
+* Like collectTextContent, but also tracks backgroundColor from nested Text
+* elements as separate BgSegment entries. Background is NOT embedded as ANSI
+* codes, preventing bg bleed when text wraps across lines.
+*
+* @param node - The node to collect text from
+* @param parentContext - The inherited style context from parent
+* @param offset - Current character offset in the collected text (for bg tracking)
+* @param maxDisplayWidth - Maximum display width (columns) to collect. When set,
+*   stops collecting once this many display columns of content have been gathered.
+*   This truncates at the DOM level BEFORE ANSI serialization, so escape sequences
+*   (OSC 8, etc.) are never generated for content that won't be displayed.
+*   Uses getTextWidth (ANSI-aware) so pre-styled leaf text is handled correctly.
+*/
+function collectTextWithBg(node, parentContext = {}, offset = 0, maxDisplayWidth, ctx) {
+	if (node.textContent !== void 0) {
+		let text = node.textContent;
+		if (maxDisplayWidth !== void 0) {
+			if (getTextWidth(text, ctx) > maxDisplayWidth) text = (ctx ? ctx.measurer.sliceByWidth : sliceByWidth)(text, maxDisplayWidth);
+		}
+		const plainLen = getTextWidth(text, ctx);
+		return {
+			text,
+			bgSegments: [],
+			childSpans: [],
+			plainLen
+		};
+	}
+	let result = "";
+	const bgSegments = [];
+	const childSpans = [];
+	let currentOffset = offset;
+	let displayWidthCollected = 0;
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (maxDisplayWidth !== void 0 && displayWidthCollected >= maxDisplayWidth) break;
+		const childBudget = maxDisplayWidth !== void 0 ? maxDisplayWidth - displayWidthCollected : void 0;
+		if (child.type === "silvery-text" && child.props && !child.layoutNode) {
+			const childProps = child.props;
+			const childContext = mergeStyleContext(parentContext, childProps);
+			const childResult = collectTextWithBg(child, childContext, currentOffset, childBudget, ctx);
+			const childTransform = childProps.internal_transform;
+			if (childTransform && childResult.text.length > 0) childResult.text = childTransform(childResult.text, i);
+			const styledText = applyTextStyleAnsi(childResult.text, childContext, parentContext);
+			result += styledText;
+			if (childContext.backgroundColor) {
+				const bg = parseColor(childContext.backgroundColor);
+				if (bg !== null) {
+					if (childResult.plainLen > 0) bgSegments.push({
+						start: currentOffset,
+						end: currentOffset + childResult.plainLen,
+						bg
+					});
+				}
+			} else if (childProps.backgroundColor === "" && childResult.plainLen > 0) bgSegments.push({
+				start: currentOffset,
+				end: currentOffset + childResult.plainLen,
+				bg: null
+			});
+			if (childResult.plainLen > 0) childSpans.push({
+				node: child,
+				start: currentOffset,
+				end: currentOffset + childResult.plainLen
+			});
+			bgSegments.push(...childResult.bgSegments);
+			childSpans.push(...childResult.childSpans);
+			currentOffset += childResult.plainLen;
+			displayWidthCollected += childResult.plainLen;
+		} else {
+			const childResult = collectTextWithBg(child, parentContext, currentOffset, childBudget, ctx);
+			result += childResult.text;
+			bgSegments.push(...childResult.bgSegments);
+			childSpans.push(...childResult.childSpans);
+			currentOffset += childResult.plainLen;
+			displayWidthCollected += childResult.plainLen;
+		}
+	}
+	return {
+		text: result,
+		bgSegments,
+		childSpans,
+		plainLen: displayWidthCollected
+	};
+}
+/**
+* Apply background segments to buffer cells for a single rendered line.
+*
+* Maps character offsets from the original collected text to screen positions,
+* accounting for text wrapping. Each bg segment fills only the cells that
+* correspond to actual text characters, not trailing whitespace.
+*
+* @param buffer - The terminal buffer to write to
+* @param x - Screen x position of the line start
+* @param y - Screen y position of the line
+* @param lineText - The rendered line text (may contain ANSI codes)
+* @param lineCharStart - Character offset in original text where this line starts
+* @param lineCharEnd - Character offset in original text where this line ends
+* @param bgSegments - Background color segments to apply
+*/
+function applyBgSegmentsToLine(buffer, x, y, lineText, lineCharStart, lineCharEnd, bgSegments, ctx) {
+	if (bgSegments.length === 0) return;
+	if (y < 0 || y >= buffer.height) return;
+	const bgCell = createMutableCell();
+	const gWidthFn = ctx ? ctx.measurer.graphemeWidth : graphemeWidth;
+	for (const seg of bgSegments) {
+		const overlapStart = Math.max(seg.start, lineCharStart);
+		const overlapEnd = Math.min(seg.end, lineCharEnd);
+		if (overlapStart >= overlapEnd) continue;
+		const relStart = overlapStart - lineCharStart;
+		const relEnd = overlapEnd - lineCharStart;
+		let col = x;
+		const graphemes = splitGraphemes(hasAnsi(lineText) ? stripAnsiForBg(lineText) : lineText);
+		for (const grapheme of graphemes) {
+			const gWidth = gWidthFn(grapheme);
+			if (gWidth === 0) continue;
+			const displayOffset = col - x;
+			if (displayOffset >= relStart && displayOffset < relEnd) {
+				buffer.readCellInto(col, y, bgCell);
+				bgCell.bg = seg.bg;
+				buffer.setCell(col, y, bgCell);
+				if (gWidth === 2 && col + 1 < buffer.width) {
+					buffer.readCellInto(col + 1, y, bgCell);
+					bgCell.bg = seg.bg;
+					buffer.setCell(col + 1, y, bgCell);
+				}
+			}
+			col += gWidth;
+			if (col - x >= relEnd) break;
+		}
+	}
+}
+/**
+* Strip ANSI escape codes from text for character counting.
+*/
+function stripAnsiForBg(text) {
+	return text.replace(/\x1b\[[0-9;:?]*[A-Za-z]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b[DME78]/g, "").replace(/\x1b\(B/g, "");
+}
+/**
+* Map formatted lines back to character offsets in the original text.
+*
+* After wrapping/truncation, each output line corresponds to a range
+* of characters in the original text. This function computes those ranges
+* by searching for each line's content in the normalized text.
+*
+* Handles characters consumed by word wrapping (spaces at break points,
+* newlines) and characters added by truncation (ellipsis).
+*
+* Returns display-width offsets (not UTF-16 code units) to match BgSegment
+* coordinate system. BgSegments use display-width via getTextWidth/plainLen.
+*
+* @param originalText - The original collected text (with ANSI, before wrapping)
+* @param formattedLines - The wrapped/truncated output lines
+* @param ctx - Pipeline context for width measurement
+* @returns Array of { start, end } display-width offsets for each formatted line
+*/
+function mapLinesToCharOffsets(originalText, formattedLines, ctx) {
+	const normalized = (hasAnsi(originalText) ? stripAnsiForBg(originalText) : originalText).replace(/\t/g, "    ");
+	const result = [];
+	let charOffset = 0;
+	let displayOffset = 0;
+	for (const line of formattedLines) {
+		const plainLine = hasAnsi(line) ? stripAnsiForBg(line) : line;
+		const lineStart = findLineStart(normalized, plainLine, charOffset);
+		if (lineStart > charOffset) {
+			const skipped = normalized.slice(charOffset, lineStart);
+			displayOffset += getTextWidth(skipped, ctx);
+		}
+		const lineDisplayWidth = getTextWidth(plainLine, ctx);
+		result.push({
+			start: displayOffset,
+			end: displayOffset + lineDisplayWidth
+		});
+		charOffset = lineStart + Math.min(plainLine.length, normalized.length - lineStart);
+		displayOffset += lineDisplayWidth;
+	}
+	return result;
+}
+/**
+* Find where a formatted line starts in the normalized original text.
+*
+* Scans forward from the given offset, matching the line content
+* character by character. Skips newlines and whitespace that were
+* consumed by wrapping between lines.
+*/
+function findLineStart(normalized, plainLine, fromOffset) {
+	if (plainLine.length === 0) {
+		let pos = fromOffset;
+		while (pos < normalized.length && normalized[pos] === "\n") pos++;
+		return pos;
+	}
+	if (normalized.startsWith(plainLine, fromOffset)) return fromOffset;
+	const ellipsisIdx = plainLine.indexOf("…");
+	const truncatedPrefix = ellipsisIdx > 0 ? plainLine.slice(0, ellipsisIdx) : null;
+	if (truncatedPrefix && normalized.startsWith(truncatedPrefix, fromOffset)) return fromOffset;
+	let pos = fromOffset;
+	while (pos < normalized.length) {
+		const ch = normalized[pos];
+		if (ch === "\n" || ch === " ") {
+			pos++;
+			continue;
+		}
+		if (normalized.startsWith(plainLine, pos)) return pos;
+		if (truncatedPrefix && normalized.startsWith(truncatedPrefix, pos)) return pos;
+		pos++;
+	}
+	return fromOffset;
+}
+/**
+* Format text into lines based on wrap mode.
+*
+* @param trim - When true, trims trailing spaces on broken lines and skips leading
+*   spaces on continuation lines. When false (e.g., text has backgroundColor),
+*   preserves trailing spaces so background color covers them. Defaults to true.
+*/
+function formatTextLines(text, width, wrap, ctx, trim = true) {
+	if (width <= 0) return [];
+	const normalizedText = text.replace(/\t/g, "    ");
+	const lines = normalizedText.split("\n");
+	if (wrap === "clip") {
+		const sliceFn = ctx ? ctx.measurer.sliceByWidth : sliceByWidth;
+		return lines.map((line) => {
+			if (getTextWidth(line, ctx) <= width) return line;
+			return sliceFn(line, width);
+		});
+	}
+	if (wrap === "hard") {
+		const sliceFn = ctx ? ctx.measurer.sliceByWidth : sliceByWidth;
+		const out = [];
+		for (const line of lines) {
+			if (line === "") {
+				out.push("");
+				continue;
+			}
+			let remaining = line;
+			while (getTextWidth(remaining, ctx) > width) {
+				const head = sliceFn(remaining, width);
+				if (head.length === 0) break;
+				out.push(head);
+				remaining = remaining.slice(head.length);
+			}
+			out.push(remaining);
+		}
+		return out;
+	}
+	if (wrap === false || wrap === "truncate-end" || wrap === "truncate") return lines.map((line) => truncateText(line, width, "end", ctx));
+	if (wrap === "truncate-start") return lines.map((line) => truncateText(line, width, "start", ctx));
+	if (wrap === "truncate-middle") return lines.map((line) => truncateText(line, width, "middle", ctx));
+	if (wrap === "even") return optimalWrap(normalizedText, buildTextAnalysis(normalizedText, ctx?.measurer?.graphemeWidth?.bind(ctx.measurer) ?? graphemeWidth), width);
+	if (ctx) return ctx.measurer.wrapText(normalizedText, width, true, trim);
+	return wrapText(normalizedText, width, true, trim);
+}
+/**
+* Truncate text to fit within width.
+*/
+function truncateText(text, width, mode, ctx) {
+	if (getTextWidth(text, ctx) <= width) return text;
+	const ellipsis = "…";
+	const availableWidth = width - 1;
+	if (availableWidth <= 0) return width > 0 ? ellipsis : "";
+	const sliceFn = ctx ? ctx.measurer.sliceByWidth : sliceByWidth;
+	const sliceEndFn = ctx ? ctx.measurer.sliceByWidthFromEnd : sliceByWidthFromEnd;
+	if (mode === "end") return sliceFn(text, availableWidth) + ellipsis;
+	if (mode === "start") return ellipsis + sliceEndFn(text, availableWidth);
+	const halfWidth = Math.floor(availableWidth / 2);
+	const startPart = sliceFn(text, halfWidth);
+	const endPart = sliceEndFn(text, availableWidth - halfWidth);
+	return startPart + ellipsis + endPart;
+}
+/**
+* Render a single line of text to the buffer.
+*
+* @param maxCol - Right edge of the text node's layout area. Wide characters
+*   whose continuation cell would exceed this boundary are replaced with a
+*   space, matching terminal behavior for wide chars at the screen edge.
+*   Without this, continuation cells overflow into adjacent containers and
+*   become stale during incremental rendering (the owning container's dirty
+*   tracking doesn't cover cells outside its layout bounds).
+*/
+function renderTextLine(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx) {
+	if (hasAnsi(text)) {
+		renderAnsiTextLine(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx);
+		return;
+	}
+	renderGraphemes(buffer, splitGraphemes(text), x, y, baseStyle, maxCol, inheritedBg, ctx);
+}
+/**
+* Like renderTextLine but returns the column position after the last rendered character.
+* Used by renderText to know where to clear remaining cells.
+*/
+function renderTextLineReturn(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx, minCol) {
+	if (hasAnsi(text)) return renderAnsiTextLineReturn(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx, minCol);
+	return renderGraphemes(buffer, splitGraphemes(text), x, y, baseStyle, maxCol, inheritedBg, ctx, minCol);
+}
+/**
+* Render graphemes to buffer cells with proper Unicode handling.
+* Shared by renderTextLine (plain text) and renderAnsiTextLine (per-segment).
+*
+* @param maxCol - Right edge of the text node's layout area (exclusive).
+*   Wide characters whose continuation cell would reach or exceed this
+*   boundary are replaced with a space character. This matches terminal
+*   behavior for wide chars at the right edge of a container and prevents
+*   continuation cells from overflowing into adjacent containers, where
+*   they become stale during incremental rendering.
+* @param minCol - Left edge of the visible region (inclusive). Graphemes
+*   whose end position is at or before minCol are skipped (col still advances).
+*   Used to clip text that overflows the LEFT edge of an overflow:hidden
+*   container with a border (so the border isn't overwritten).
+*
+* Returns the column position after the last rendered grapheme.
+*/
+function renderGraphemes(buffer, graphemes, startCol, y, style, maxCol, inheritedBg, ctx, minCol) {
+	let col = startCol;
+	const rightEdge = maxCol !== void 0 ? Math.min(maxCol, buffer.width) : buffer.width;
+	const leftEdge = minCol !== void 0 ? Math.max(minCol, 0) : 0;
+	const gWidthFn = ctx ? ctx.measurer.graphemeWidth : graphemeWidth;
+	for (const grapheme of graphemes) {
+		if (col >= rightEdge) break;
+		const width = gWidthFn(grapheme);
+		if (width === 0) continue;
+		if (col + width <= leftEdge) {
+			col += width;
+			continue;
+		}
+		if (col < leftEdge) {
+			col = leftEdge;
+			continue;
+		}
+		const existingBg = style.bg !== null ? style.bg : inheritedBg !== void 0 ? inheritedBg : buffer.getCellBg(col, y);
+		if (width === 2 && col + 1 >= rightEdge) {
+			buffer.setCell(col, y, {
+				char: " ",
+				fg: style.fg,
+				bg: existingBg,
+				underlineColor: style.underlineColor ?? null,
+				attrs: style.attrs,
+				wide: false,
+				continuation: false,
+				hyperlink: style.hyperlink
+			});
+			col += 1;
+			continue;
+		}
+		const outputChar = width === 2 ? ensureEmojiPresentation(grapheme) : grapheme;
+		buffer.setCell(col, y, {
+			char: outputChar,
+			fg: style.fg,
+			bg: existingBg,
+			underlineColor: style.underlineColor ?? null,
+			attrs: style.attrs,
+			wide: width === 2,
+			continuation: false,
+			hyperlink: style.hyperlink
+		});
+		if (width === 2 && col + 1 < buffer.width) {
+			const existingBg2 = style.bg !== null ? style.bg : inheritedBg !== void 0 ? inheritedBg : buffer.getCellBg(col + 1, y);
+			buffer.setCell(col + 1, y, {
+				char: "",
+				fg: style.fg,
+				bg: existingBg2,
+				underlineColor: style.underlineColor ?? null,
+				attrs: style.attrs,
+				wide: false,
+				continuation: true,
+				hyperlink: style.hyperlink
+			});
+			col += 2;
+		} else col += width;
+	}
+	return col;
+}
+/**
+* Render text line with ANSI escape sequences.
+* Parses ANSI codes and applies styles to individual segments.
+*/
+function renderAnsiTextLine(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx) {
+	renderAnsiTextLineReturn(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx);
+}
+/**
+* Like renderAnsiTextLine but returns the column position after the last rendered character.
+*/
+function renderAnsiTextLineReturn(buffer, x, y, text, baseStyle, maxCol, inheritedBg, ctx, minCol) {
+	const segments = parseAnsiText(text);
+	let col = x;
+	for (const segment of segments) {
+		const style = mergeAnsiStyle(baseStyle, segment);
+		const effectiveBgConflictMode = ctx?.bgConflictMode ?? getBgConflictMode();
+		if (effectiveBgConflictMode !== "ignore" && !segment.bgOverride && segment.bg !== void 0 && segment.bg !== null) {
+			const existingBufBg = col < buffer.width ? buffer.getCellBg(col, y) : null;
+			if (baseStyle.bg !== null || existingBufBg !== null) {
+				const preview = segment.text.slice(0, 30);
+				const chalkBg = formatBgConflictColor(segment.bg);
+				const silveryBg = baseStyle.bg !== null ? `Text.bg=${formatBgConflictColor(baseStyle.bg)}` : `bufferBg=${formatBgConflictColor(existingBufBg)}`;
+				const textPreview = text.length > 80 ? text.slice(0, 80) + "…" : text;
+				const msg = `[silvery] Background conflict at (${col},${y}): chalk bg=${chalkBg} on silvery ${silveryBg}. Text: "${preview}${segment.text.length > 30 ? "…" : ""}". Raw ANSI (first 80): ${JSON.stringify(textPreview)}. Chalk bg will override only text characters, causing visual gaps in padding. Use ansi.bgOverride() to suppress if intentional.`;
+				if (effectiveBgConflictMode === "throw") throw new Error(msg);
+				const effectiveWarnedBgConflicts = ctx?.warnedBgConflicts ?? warnedBgConflicts;
+				const key = `${JSON.stringify(existingBufBg)}-${segment.bg}-${preview}`;
+				if (!effectiveWarnedBgConflicts.has(key)) {
+					effectiveWarnedBgConflicts.add(key);
+					log$2.warn?.(msg);
+				}
+			}
+		}
+		col = renderGraphemes(buffer, splitGraphemes(segment.text), col, y, style, maxCol, inheritedBg, ctx, minCol);
+	}
+	return col;
+}
+/**
+* Merge two styles using category-based semantics.
+*
+* Categories and their merge behavior:
+* - Container (bg): overlay replaces base
+* - Text (fg): overlay replaces base
+* - Decorations (underline*, strikethrough): OR merge if preserveDecorations=true
+* - Emphasis (bold, dim, italic): OR merge if preserveEmphasis=true
+* - Transform (inverse, hidden, blink): overlay only, not inherited
+*
+* @param base - The base style (from parent/container)
+* @param overlay - The overlay style (from child/content)
+* @param options - Merge behavior options
+*/
+function mergeStyles(base, overlay, options = {}) {
+	const { preserveDecorations = true, preserveEmphasis = true } = options;
+	const baseAttrs = base.attrs ?? {};
+	const overlayAttrs = overlay.attrs ?? {};
+	const attrs = {};
+	if (preserveDecorations) {
+		const hasBaseUnderline = baseAttrs.underline || baseAttrs.underlineStyle;
+		const hasOverlayUnderline = overlayAttrs.underline || overlayAttrs.underlineStyle;
+		if (hasBaseUnderline || hasOverlayUnderline) {
+			attrs.underline = true;
+			attrs.underlineStyle = overlayAttrs.underlineStyle ?? baseAttrs.underlineStyle ?? "single";
+		}
+		attrs.strikethrough = overlayAttrs.strikethrough || baseAttrs.strikethrough;
+	} else {
+		attrs.underline = overlayAttrs.underline ?? baseAttrs.underline;
+		attrs.underlineStyle = overlayAttrs.underlineStyle ?? baseAttrs.underlineStyle;
+		attrs.strikethrough = overlayAttrs.strikethrough ?? baseAttrs.strikethrough;
+	}
+	if (preserveEmphasis) {
+		attrs.bold = overlayAttrs.bold || baseAttrs.bold;
+		attrs.dim = overlayAttrs.dim || baseAttrs.dim;
+		attrs.italic = overlayAttrs.italic || baseAttrs.italic;
+	} else {
+		attrs.bold = overlayAttrs.bold ?? baseAttrs.bold;
+		attrs.dim = overlayAttrs.dim ?? baseAttrs.dim;
+		attrs.italic = overlayAttrs.italic ?? baseAttrs.italic;
+	}
+	attrs.inverse = overlayAttrs.inverse;
+	attrs.hidden = overlayAttrs.hidden;
+	attrs.blink = overlayAttrs.blink;
+	return {
+		fg: overlay.fg ?? base.fg,
+		bg: overlay.bg ?? base.bg,
+		underlineColor: overlay.underlineColor ?? base.underlineColor,
+		attrs
+	};
+}
+/**
+* Merge ANSI segment style with base style.
+* Uses category-based merging to preserve decorations and emphasis.
+*/
+function mergeAnsiStyle(base, segment, options = {}) {
+	const { preserveDecorations = true, preserveEmphasis = true } = options;
+	let fg = base.fg;
+	let bg = base.bg;
+	let underlineColor = base.underlineColor ?? null;
+	if (segment.fg !== void 0 && segment.fg !== null) fg = ansiColorToColor(segment.fg);
+	if (segment.bg !== void 0 && segment.bg !== null) bg = ansiColorToColor(segment.bg);
+	if (segment.underlineColor !== void 0 && segment.underlineColor !== null) underlineColor = ansiColorToColor(segment.underlineColor);
+	const overlayAttrs = {};
+	if (segment.bold !== void 0) overlayAttrs.bold = segment.bold;
+	if (segment.dim !== void 0) overlayAttrs.dim = segment.dim;
+	if (segment.italic !== void 0) overlayAttrs.italic = segment.italic;
+	if (segment.underline !== void 0) overlayAttrs.underline = segment.underline;
+	if (segment.underlineStyle !== void 0) overlayAttrs.underlineStyle = segment.underlineStyle;
+	if (segment.inverse !== void 0) overlayAttrs.inverse = segment.inverse;
+	const merged = mergeStyles(base, {
+		fg,
+		bg,
+		underlineColor,
+		attrs: overlayAttrs
+	}, {
+		preserveDecorations,
+		preserveEmphasis
+	});
+	if (segment.hyperlink) merged.hyperlink = segment.hyperlink;
+	return merged;
+}
+/**
+* Convert ANSI SGR color code to our Color type.
+* Color is: number (256-color index) | { r, g, b } (true color) | null
+*/
+function ansiColorToColor(code) {
+	if (code >= 16777216) return {
+		r: code >> 16 & 255,
+		g: code >> 8 & 255,
+		b: code & 255
+	};
+	if (code < 30 || code >= 38 && code < 40 || code >= 48 && code < 90) return code;
+	if (code >= 30 && code <= 37) return code - 30;
+	if (code >= 40 && code <= 47) return code - 40;
+	if (code >= 90 && code <= 97) return code - 90 + 8;
+	if (code >= 100 && code <= 107) return code - 100 + 8;
+	return null;
+}
+/**
+* Render a Text node.
+*
+* Background colors from nested Text elements are handled at the buffer level
+* (not via ANSI codes) to prevent bg bleed across wrapped text lines.
+* See km-silvery.bg-bleed for details.
+*/
+function renderText(node, buffer, layout, props, nodeState, inheritedBg, inheritedFg, ctx) {
+	const { scrollOffset, clipBounds } = nodeState;
+	const { x, width, height } = layout;
+	let { y } = layout;
+	y -= scrollOffset;
+	if (props.backgroundColor === "") inheritedBg = null;
+	if (clipBounds) {
+		if (y + height <= clipBounds.top || y >= clipBounds.bottom) return;
+		if (clipBounds.left !== void 0 && clipBounds.right !== void 0) {
+			if (x + width <= clipBounds.left || x >= clipBounds.right) return;
+		}
+	}
+	let maxDisplayWidth;
+	if ((props.wrap === false || props.wrap === "truncate-end" || props.wrap === "truncate" || props.wrap === "clip") && width > 0) {
+		const cachedPlain = getCachedPlainText(node);
+		let lineCount;
+		if (cachedPlain) lineCount = cachedPlain.lineCount;
+		else {
+			const plainText = collectPlainText(node);
+			lineCount = (plainText.match(/\n/g)?.length ?? 0) + 1;
+			setCachedPlainText(node, plainText, lineCount);
+		}
+		maxDisplayWidth = (width + 1) * lineCount;
+	}
+	let text;
+	let bgSegments;
+	let childSpans;
+	const cachedCollected = getCachedCollectedText(node, maxDisplayWidth);
+	if (cachedCollected) {
+		text = cachedCollected.text;
+		bgSegments = cachedCollected.bgSegments;
+		childSpans = cachedCollected.childSpans;
+	} else {
+		const collected = collectTextWithBg(node, {}, 0, maxDisplayWidth, ctx);
+		text = collected.text;
+		bgSegments = collected.bgSegments;
+		childSpans = collected.childSpans;
+		setCachedCollectedText(node, collected, maxDisplayWidth);
+	}
+	const style = getTextStyle(props);
+	if (style.fg === null && inheritedFg !== void 0) style.fg = inheritedFg;
+	const trim = !(style.bg !== null || bgSegments.length > 0 || inheritedBg !== void 0 && inheritedBg !== null);
+	const internalTransform = props.internal_transform;
+	let lines;
+	let lineOffsets;
+	const cachedFmt = !internalTransform ? getCachedFormat(node, width, props.wrap, trim) : null;
+	if (cachedFmt) {
+		lines = cachedFmt.lines;
+		lineOffsets = cachedFmt.hasLineOffsets ? cachedFmt.lineOffsets : [];
+	} else {
+		lines = formatTextLines(text, width, props.wrap, ctx, trim);
+		if (internalTransform) lines = lines.map((line, index) => internalTransform(line, index));
+		const needLineOffsets = bgSegments.length > 0 || childSpans.length > 0;
+		lineOffsets = needLineOffsets ? mapLinesToCharOffsets(text, lines, ctx) : [];
+		if (!internalTransform) setCachedFormat(node, width, props.wrap, trim, lines, lineOffsets, needLineOffsets);
+	}
+	for (let lineIdx = 0; lineIdx < lines.length && lineIdx < height; lineIdx++) {
+		const lineY = y + lineIdx;
+		if (clipBounds && (lineY < clipBounds.top || lineY >= clipBounds.bottom)) continue;
+		const line = lines[lineIdx];
+		const layoutRight = internalTransform ? buffer.width : x + width;
+		const maxCol = clipBounds && "right" in clipBounds && clipBounds.right !== void 0 ? Math.min(layoutRight, clipBounds.right) : layoutRight;
+		const minCol = clipBounds && "left" in clipBounds && clipBounds.left !== void 0 ? clipBounds.left : void 0;
+		const endCol = renderTextLineReturn(buffer, x, lineY, line, style, maxCol, inheritedBg, ctx, minCol);
+		const clearStart = minCol !== void 0 ? Math.max(endCol, minCol) : endCol;
+		if (clearStart < maxCol) {
+			const clearBg = inheritedBg ?? null;
+			for (let cx = clearStart; cx < maxCol && cx < buffer.width; cx++) buffer.setCell(cx, lineY, {
+				char: " ",
+				fg: style.fg,
+				bg: clearBg,
+				underlineColor: null,
+				attrs: {
+					bold: false,
+					dim: false,
+					italic: false,
+					underline: false,
+					inverse: false,
+					strikethrough: false,
+					blink: false,
+					hidden: false
+				},
+				wide: false,
+				continuation: false
+			});
+		}
+		if (bgSegments.length > 0 && lineIdx < lineOffsets.length) {
+			const { start, end } = lineOffsets[lineIdx];
+			applyBgSegmentsToLine(buffer, x, lineY, line, start, end, bgSegments, ctx);
+		}
+	}
+	if (childSpans.length > 0 && lineOffsets.length > 0) computeInlineRects(childSpans, lineOffsets, x, y, lines.length, height);
+}
+/**
+* Compute inlineRects for virtual text children based on their display-width spans
+* and the formatted line offsets. For wrapped text, a child may span multiple lines,
+* producing one rect per line fragment.
+*
+* @param childSpans - Virtual text children with their display-width ranges
+* @param lineOffsets - Display-width offset ranges for each formatted line
+* @param parentX - Screen X of the parent Text node
+* @param parentY - Screen Y of the parent Text node (after scroll offset)
+* @param lineCount - Number of formatted lines
+* @param maxHeight - Maximum height (layout height) of the parent Text node
+*/
+function computeInlineRects(childSpans, lineOffsets, parentX, parentY, lineCount, maxHeight) {
+	for (const span of childSpans) {
+		const rects = [];
+		for (let lineIdx = 0; lineIdx < lineCount && lineIdx < maxHeight; lineIdx++) {
+			const lineOffset = lineOffsets[lineIdx];
+			if (!lineOffset) continue;
+			const overlapStart = Math.max(span.start, lineOffset.start);
+			const overlapEnd = Math.min(span.end, lineOffset.end);
+			if (overlapStart >= overlapEnd) continue;
+			const rectX = parentX + (overlapStart - lineOffset.start);
+			const rectY = parentY + lineIdx;
+			const rectWidth = overlapEnd - overlapStart;
+			rects.push({
+				x: rectX,
+				y: rectY,
+				width: rectWidth,
+				height: 1
+			});
+		}
+		span.node.inlineRects = rects.length > 0 ? rects : null;
+	}
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/render-box.ts
+/**
+* Get the effective background color string for a Box.
+* Returns explicit backgroundColor if set, otherwise theme.bg if theme is set.
+* Used by both renderBox (paint fill) and render-phase (cascade logic).
+*/
+function getEffectiveBg(props) {
+	if (props.backgroundColor) return props.backgroundColor;
+	if (props.theme) return props.theme.bg;
+}
+/**
+* Render a Box node.
+*/
+function renderBox(_node, buffer, layout, props, nodeState, skipBgFill = false, inheritedBg, bgOnlyChange = false) {
+	const { scrollOffset, clipBounds } = nodeState;
+	const { x, width, height } = layout;
+	const y = layout.y - scrollOffset;
+	if (clipBounds) {
+		if (y + height <= clipBounds.top || y >= clipBounds.bottom) return;
+		if (clipBounds.left !== void 0 && clipBounds.right !== void 0) {
+			if (x + width <= clipBounds.left || x >= clipBounds.right) return;
+		}
+	}
+	const effectiveBgStr = getEffectiveBg(props);
+	if (effectiveBgStr && !skipBgFill) {
+		const bg = parseColor(effectiveBgStr);
+		if (clipBounds) {
+			const clippedY = Math.max(y, clipBounds.top);
+			const clippedHeight = Math.min(y + height, clipBounds.bottom) - clippedY;
+			let clippedX = x;
+			let clippedWidth = width;
+			if (clipBounds.left !== void 0 && clipBounds.right !== void 0) {
+				clippedX = Math.max(x, clipBounds.left);
+				clippedWidth = Math.min(x + width, clipBounds.right) - clippedX;
+			}
+			if (clippedHeight > 0 && clippedWidth > 0) if (bgOnlyChange) buffer.fillBg(clippedX, clippedY, clippedWidth, clippedHeight, bg);
+			else buffer.fill(clippedX, clippedY, clippedWidth, clippedHeight, { bg });
+		} else if (bgOnlyChange) buffer.fillBg(x, y, width, height, bg);
+		else buffer.fill(x, y, width, height, { bg });
+	}
+	if (props.borderStyle) renderBorder(buffer, x, y, width, height, props, clipBounds, inheritedBg);
+}
+/**
+* Render a border around a box.
+*/
+function renderBorder(buffer, x, y, width, height, props, clipBounds, inheritedBg) {
+	const chars = getBorderChars(props.borderStyle ?? "single");
+	const color = props.borderColor ? parseColor(props.borderColor) : null;
+	const baseBg = props.backgroundColor ? parseColor(props.backgroundColor) : inheritedBg ?? null;
+	const borderBgStr = props.borderBackgroundColor;
+	const borderBgBase = borderBgStr ? parseColor(borderBgStr) : baseBg;
+	const topBorderBgStr = props.borderTopBackgroundColor;
+	const bottomBorderBgStr = props.borderBottomBackgroundColor;
+	const leftBorderBgStr = props.borderLeftBackgroundColor;
+	const rightBorderBgStr = props.borderRightBackgroundColor;
+	const topBg = topBorderBgStr ? parseColor(topBorderBgStr) : borderBgBase;
+	const bottomBg = bottomBorderBgStr ? parseColor(bottomBorderBgStr) : borderBgBase;
+	const leftBg = leftBorderBgStr ? parseColor(leftBorderBgStr) : borderBgBase;
+	const rightBg = rightBorderBgStr ? parseColor(rightBorderBgStr) : borderBgBase;
+	const showTop = props.borderTop !== false;
+	const showBottom = props.borderBottom !== false;
+	const showLeft = props.borderLeft !== false;
+	const showRight = props.borderRight !== false;
+	const isRowVisible = (row) => {
+		if (!clipBounds) return row >= 0 && row < buffer.height;
+		return row >= clipBounds.top && row < clipBounds.bottom && row < buffer.height;
+	};
+	const isColVisible = (col) => {
+		if (clipBounds?.left === void 0 || clipBounds.right === void 0) return col >= 0 && col < buffer.width;
+		return col >= clipBounds.left && col < clipBounds.right && col < buffer.width;
+	};
+	if (showTop && isRowVisible(y)) {
+		if (showLeft && isColVisible(x)) buffer.setCell(x, y, {
+			char: chars.topLeft,
+			fg: color,
+			bg: topBg
+		});
+		const hStart = showLeft ? x + 1 : x;
+		const hEnd = showRight ? x + width - 1 : x + width;
+		for (let col = hStart; col < hEnd && col < buffer.width; col++) if (isColVisible(col)) buffer.setCell(col, y, {
+			char: chars.horizontal,
+			fg: color,
+			bg: topBg
+		});
+		if (showRight && x + width - 1 < buffer.width && isColVisible(x + width - 1)) buffer.setCell(x + width - 1, y, {
+			char: chars.topRight,
+			fg: color,
+			bg: topBg
+		});
+	}
+	const rightVertical = chars.rightVertical ?? chars.vertical;
+	const sideStart = showTop ? y + 1 : y;
+	const sideEnd = showBottom ? y + height - 1 : y + height;
+	for (let row = sideStart; row < sideEnd; row++) {
+		if (!isRowVisible(row)) continue;
+		if (showLeft && isColVisible(x)) buffer.setCell(x, row, {
+			char: chars.vertical,
+			fg: color,
+			bg: leftBg
+		});
+		if (showRight && x + width - 1 < buffer.width && isColVisible(x + width - 1)) buffer.setCell(x + width - 1, row, {
+			char: rightVertical,
+			fg: color,
+			bg: rightBg
+		});
+	}
+	const bottomHorizontal = chars.bottomHorizontal ?? chars.horizontal;
+	const bottomY = y + height - 1;
+	if (showBottom && isRowVisible(bottomY)) {
+		if (showLeft && isColVisible(x)) buffer.setCell(x, bottomY, {
+			char: chars.bottomLeft,
+			fg: color,
+			bg: bottomBg
+		});
+		const bStart = showLeft ? x + 1 : x;
+		const bEnd = showRight ? x + width - 1 : x + width;
+		for (let col = bStart; col < bEnd && col < buffer.width; col++) if (isColVisible(col)) buffer.setCell(col, bottomY, {
+			char: bottomHorizontal,
+			fg: color,
+			bg: bottomBg
+		});
+		if (showRight && x + width - 1 < buffer.width && isColVisible(x + width - 1)) buffer.setCell(x + width - 1, bottomY, {
+			char: chars.bottomRight,
+			fg: color,
+			bg: bottomBg
+		});
+	}
+}
+/**
+* Render an outline around a box.
+*
+* Unlike borders, outlines do NOT affect layout dimensions. They draw border
+* characters that OVERLAP the content area at the node's screen rect edges.
+* This is the CSS `outline` equivalent for terminal UI.
+*/
+function renderOutline(buffer, x, y, width, height, props, clipBounds, inheritedBg) {
+	const chars = getBorderChars(props.outlineStyle ?? "single");
+	const color = props.outlineColor ? parseColor(props.outlineColor) : null;
+	const bg = props.backgroundColor ? parseColor(props.backgroundColor) : inheritedBg ?? null;
+	const attrs = props.outlineDimColor ? { dim: true } : {};
+	const isRowVisible = (row) => {
+		if (!clipBounds) return row >= 0 && row < buffer.height;
+		return row >= clipBounds.top && row < clipBounds.bottom && row < buffer.height;
+	};
+	const isColVisible = (col) => {
+		if (clipBounds?.left === void 0 || clipBounds.right === void 0) return col >= 0 && col < buffer.width;
+		return col >= clipBounds.left && col < clipBounds.right && col < buffer.width;
+	};
+	const showTop = props.outlineTop !== false;
+	const showBottom = props.outlineBottom !== false;
+	const showLeft = props.outlineLeft !== false;
+	const showRight = props.outlineRight !== false;
+	if (showTop && isRowVisible(y)) {
+		if (showLeft && isColVisible(x)) buffer.setCell(x, y, {
+			char: chars.topLeft,
+			fg: color,
+			bg,
+			attrs
+		});
+		for (let col = x + 1; col < x + width - 1 && col < buffer.width; col++) if (isColVisible(col)) buffer.setCell(col, y, {
+			char: chars.horizontal,
+			fg: color,
+			bg,
+			attrs
+		});
+		if (showRight && x + width - 1 < buffer.width && isColVisible(x + width - 1)) buffer.setCell(x + width - 1, y, {
+			char: chars.topRight,
+			fg: color,
+			bg,
+			attrs
+		});
+	}
+	const outlineRightVertical = chars.rightVertical ?? chars.vertical;
+	const sideStart = showTop ? y + 1 : y;
+	const sideEnd = showBottom ? y + height - 1 : y + height;
+	for (let row = sideStart; row < sideEnd; row++) {
+		if (!isRowVisible(row)) continue;
+		if (showLeft && isColVisible(x)) buffer.setCell(x, row, {
+			char: chars.vertical,
+			fg: color,
+			bg,
+			attrs
+		});
+		if (showRight && x + width - 1 < buffer.width && isColVisible(x + width - 1)) buffer.setCell(x + width - 1, row, {
+			char: outlineRightVertical,
+			fg: color,
+			bg,
+			attrs
+		});
+	}
+	const outlineBottomHorizontal = chars.bottomHorizontal ?? chars.horizontal;
+	const bottomY = y + height - 1;
+	if (showBottom && isRowVisible(bottomY)) {
+		if (showLeft && isColVisible(x)) buffer.setCell(x, bottomY, {
+			char: chars.bottomLeft,
+			fg: color,
+			bg,
+			attrs
+		});
+		for (let col = x + 1; col < x + width - 1 && col < buffer.width; col++) if (isColVisible(col)) buffer.setCell(col, bottomY, {
+			char: outlineBottomHorizontal,
+			fg: color,
+			bg,
+			attrs
+		});
+		if (showRight && x + width - 1 < buffer.width && isColVisible(x + width - 1)) buffer.setCell(x + width - 1, bottomY, {
+			char: chars.bottomRight,
+			fg: color,
+			bg,
+			attrs
+		});
+	}
+}
+/**
+* Render scroll indicators showing hidden items above/below viewport.
+*
+* Two rendering modes:
+* 1. Bordered containers: Indicators appear on the border (e.g., "───▲42───")
+* 2. Borderless containers with overflowIndicator: Indicators appear directly
+*    after the last visible child (not at the viewport bottom)
+*
+* Uses ▲N for items hidden above, ▼N for items hidden below.
+*/
+function renderScrollIndicators(_node, buffer, layout, props, ss, ctx) {
+	const border = props.borderStyle ? getBorderSize(props) : {
+		top: 0,
+		bottom: 0,
+		left: 0,
+		right: 0
+	};
+	const indicatorStyle = {
+		fg: 15,
+		bg: 8,
+		attrs: {}
+	};
+	const showBorderless = props.overflowIndicator === true;
+	if (ss.hiddenAbove > 0) {
+		const indicator = `\u25b2${ss.hiddenAbove}`;
+		if (border.top > 0) {
+			const contentWidth = layout.width - border.left - border.right;
+			const bar = padCenter(indicator, contentWidth);
+			const x = layout.x + border.left;
+			const y = layout.y;
+			renderTextLine(buffer, x, y, bar, indicatorStyle, x + contentWidth, void 0, ctx);
+		} else if (showBorderless) {
+			const padding = getPadding(props);
+			const contentWidth = layout.width - padding.left - padding.right;
+			const bar = padCenter(indicator, contentWidth);
+			const x = layout.x + padding.left;
+			renderTextLine(buffer, x, layout.y + padding.top, bar, indicatorStyle, x + contentWidth, void 0, ctx);
+		}
+	}
+	if (ss.hiddenBelow > 0) {
+		const indicator = `\u25bc${ss.hiddenBelow}`;
+		if (border.bottom > 0) {
+			const contentWidth = layout.width - border.left - border.right;
+			const bar = padCenter(indicator, contentWidth);
+			const x = layout.x + border.left;
+			renderTextLine(buffer, x, layout.y + layout.height - 1, bar, indicatorStyle, x + contentWidth, void 0, ctx);
+		} else if (showBorderless) {
+			const padding = getPadding(props);
+			const contentWidth = layout.width - padding.left - padding.right;
+			const bar = padCenter(indicator, contentWidth);
+			const x = layout.x + padding.left;
+			renderTextLine(buffer, x, layout.y + layout.height - padding.bottom - 1, bar, indicatorStyle, x + contentWidth, void 0, ctx);
+		}
+	}
+}
+/** Center text within a fixed width, padding with spaces on both sides.
+*  Truncates from the right if text exceeds available width. */
+function padCenter(text, width) {
+	if (width <= 0) return "";
+	if (text.length > width) return text.slice(0, width);
+	if (text.length === width) return text;
+	const leftPad = Math.floor((width - text.length) / 2);
+	const rightPad = width - text.length - leftPad;
+	return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/cascade-predicates.ts
+/**
+* Compute all cascade predicate values from boolean inputs.
+*
+* This is a pure function — no side effects, no node dependencies.
+* The formulas exactly match those in render-phase.ts renderNodeToBuffer.
+*/
+function computeCascade(inputs) {
+	const { hasPrevBuffer, contentDirty, stylePropsDirty, layoutChanged, subtreeDirty, childrenDirty, childPositionChanged, ancestorLayoutChanged, ancestorCleared, bgDirty, isTextNode, hasBgColor, absoluteChildMutated, descendantOverflowChanged } = inputs;
+	const canSkipEntireSubtree = hasPrevBuffer && !contentDirty && !stylePropsDirty && !layoutChanged && !subtreeDirty && !childrenDirty && !childPositionChanged && !ancestorLayoutChanged;
+	const contentAreaAffected = contentDirty || layoutChanged || childPositionChanged || childrenDirty || bgDirty || isTextNode && stylePropsDirty || absoluteChildMutated || descendantOverflowChanged;
+	const bgOnlyChange = false;
+	const bgRefillNeeded = hasPrevBuffer && !contentAreaAffected && subtreeDirty && hasBgColor;
+	return {
+		canSkipEntireSubtree,
+		contentAreaAffected,
+		bgRefillNeeded,
+		contentRegionCleared: (hasPrevBuffer || ancestorCleared) && contentAreaAffected && !hasBgColor,
+		skipBgFill: hasPrevBuffer && !ancestorCleared && !contentAreaAffected && !bgRefillNeeded,
+		childrenNeedFreshRender: (hasPrevBuffer || ancestorCleared) && (contentAreaAffected || bgRefillNeeded) && true,
+		bgOnlyChange
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/alien-signals@3.1.2/node_modules/alien-signals/esm/system.mjs
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	function link(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	function unlink(link, sub = link.sub) {
+		const dep = link.dep;
+		const prevDep = link.prevDep;
+		const nextDep = link.nextDep;
+		const nextSub = link.nextSub;
+		const prevSub = link.prevSub;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	function propagate(link) {
+		let next = link.nextSub;
+		let stack;
+		top: do {
+			const sub = link.sub;
+			let flags = sub.flags;
+			if (!(flags & 60)) sub.flags = flags | 32;
+			else if (!(flags & 12)) flags = 0;
+			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
+			else if (!(flags & 48) && isValidLink(link, sub)) {
+				sub.flags = flags | 40;
+				flags &= 1;
+			} else flags = 0;
+			if (flags & 2) notify(sub);
+			if (flags & 1) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link = next) !== void 0) {
+				next = link.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link = stack.value;
+				stack = stack.prev;
+				if (link !== void 0) {
+					next = link.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	function checkDirty(link, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link.dep;
+			const flags = dep.flags;
+			if (sub.flags & 16) dirty = true;
+			else if ((flags & 17) === 17) {
+				if (update(dep)) {
+					const subs = dep.subs;
+					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					dirty = true;
+				}
+			} else if ((flags & 33) === 33) {
+				if (link.nextSub !== void 0 || link.prevSub !== void 0) stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				const firstSub = sub.subs;
+				const hasMultipleSubs = firstSub.nextSub !== void 0;
+				if (hasMultipleSubs) {
+					link = stack.value;
+					stack = stack.prev;
+				} else link = firstSub;
+				if (dirty) {
+					if (update(sub)) {
+						if (hasMultipleSubs) shallowPropagate(firstSub);
+						sub = link.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= -33;
+				sub = link.sub;
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue top;
+				}
+			}
+			return dirty;
+		} while (true);
+	}
+	function shallowPropagate(link) {
+		do {
+			const sub = link.sub;
+			const flags = sub.flags;
+			if ((flags & 48) === 32) {
+				sub.flags = flags | 16;
+				if ((flags & 6) === 2) notify(sub);
+			}
+		} while ((link = link.nextSub) !== void 0);
+	}
+	function isValidLink(checkLink, sub) {
+		let link = sub.depsTail;
+		while (link !== void 0) {
+			if (link === checkLink) return true;
+			link = link.prevDep;
+		}
+		return false;
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/alien-signals@3.1.2/node_modules/alien-signals/esm/index.mjs
+let cycle = 0;
+let notifyIndex = 0;
+let queuedLength = 0;
+let activeSub;
+const queued = [];
+const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	update(node) {
+		if (node.depsTail !== void 0) return updateComputed(node);
+		else return updateSignal(node);
+	},
+	notify(effect) {
+		let insertIndex = queuedLength;
+		let firstInsertedIndex = insertIndex;
+		do {
+			queued[insertIndex++] = effect;
+			effect.flags &= -3;
+			effect = effect.subs?.sub;
+			if (effect === void 0 || !(effect.flags & 2)) break;
+		} while (true);
+		queuedLength = insertIndex;
+		while (firstInsertedIndex < --insertIndex) {
+			const left = queued[firstInsertedIndex];
+			queued[firstInsertedIndex++] = queued[insertIndex];
+			queued[insertIndex] = left;
+		}
+	},
+	unwatched(node) {
+		if (!(node.flags & 1)) effectScopeOper.call(node);
+		else if (node.depsTail !== void 0) {
+			node.depsTail = void 0;
+			node.flags = 17;
+			purgeDeps(node);
+		}
+	}
+});
+function setActiveSub(sub) {
+	const prevSub = activeSub;
+	activeSub = sub;
+	return prevSub;
+}
+function signal(initialValue) {
+	return signalOper.bind({
+		currentValue: initialValue,
+		pendingValue: initialValue,
+		subs: void 0,
+		subsTail: void 0,
+		flags: 1
+	});
+}
+function computed(getter) {
+	return computedOper.bind({
+		value: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: 0,
+		getter
+	});
+}
+function updateComputed(c) {
+	++cycle;
+	c.depsTail = void 0;
+	c.flags = 5;
+	const prevSub = setActiveSub(c);
+	try {
+		const oldValue = c.value;
+		return oldValue !== (c.value = c.getter(oldValue));
+	} finally {
+		activeSub = prevSub;
+		c.flags &= -5;
+		purgeDeps(c);
+	}
+}
+function updateSignal(s) {
+	s.flags = 1;
+	return s.currentValue !== (s.currentValue = s.pendingValue);
+}
+function run(e) {
+	const flags = e.flags;
+	if (flags & 16 || flags & 32 && checkDirty(e.deps, e)) {
+		++cycle;
+		e.depsTail = void 0;
+		e.flags = 6;
+		const prevSub = setActiveSub(e);
+		try {
+			e.fn();
+		} finally {
+			activeSub = prevSub;
+			e.flags &= -5;
+			purgeDeps(e);
+		}
+	} else e.flags = 2;
+}
+function flush() {
+	try {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			run(effect);
+		}
+	} finally {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			effect.flags |= 10;
+		}
+		notifyIndex = 0;
+		queuedLength = 0;
+	}
+}
+function computedOper() {
+	const flags = this.flags;
+	if (flags & 16 || flags & 32 && (checkDirty(this.deps, this) || (this.flags = flags & -33, false))) {
+		if (updateComputed(this)) {
+			const subs = this.subs;
+			if (subs !== void 0) shallowPropagate(subs);
+		}
+	} else if (!flags) {
+		this.flags = 5;
+		const prevSub = setActiveSub(this);
+		try {
+			this.value = this.getter();
+		} finally {
+			activeSub = prevSub;
+			this.flags &= -5;
+		}
+	}
+	const sub = activeSub;
+	if (sub !== void 0) link(this, sub, cycle);
+	return this.value;
+}
+function signalOper(...value) {
+	if (value.length) {
+		if (this.pendingValue !== (this.pendingValue = value[0])) {
+			this.flags = 17;
+			const subs = this.subs;
+			if (subs !== void 0) {
+				propagate(subs);
+				flush();
+			}
+		}
+	} else {
+		if (this.flags & 16) {
+			if (updateSignal(this)) {
+				const subs = this.subs;
+				if (subs !== void 0) shallowPropagate(subs);
+			}
+		}
+		let sub = activeSub;
+		while (sub !== void 0) {
+			if (sub.flags & 3) {
+				link(this, sub, cycle);
+				break;
+			}
+			sub = sub.subs?.sub;
+		}
+		return this.currentValue;
+	}
+}
+function effectScopeOper() {
+	this.depsTail = void 0;
+	this.flags = 0;
+	purgeDeps(this);
+	const sub = this.subs;
+	if (sub !== void 0) unlink(sub);
+}
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/reactive-node.ts
+/**
+* Reactive Node State — alien-signals wrappers for cascade derivations.
+*
+* E+ Phase 2: Replace manual cascade formula computation with reactive
+* computeds. The cascade-predicates.ts `computeCascade()` function is the
+* oracle — this module must produce identical outputs.
+*
+* Incremental approach:
+*   1. Writable signals mirror epoch-stamped dirty flags
+*   2. Computeds derive cascade outputs (isDirty, contentAreaAffected, etc.)
+*   3. `syncToSignals()` bridges epoch flags → signals at render-phase entry
+*   4. Dev-mode assertions verify reactive === oracle
+*
+* alien-signals computeds are lazy (pull-based): reading a computed re-evaluates
+* only if a dependency changed. No batching needed for correctness — the
+* reconciler's synchronous commit writes epoch stamps, and the render phase
+* reads computeds after all commits are done.
+*/
+/**
+* Create a reactive state wrapper for a node.
+*
+* The computed formulas exactly replicate cascade-predicates.ts `computeCascade()`.
+* They are NOT a replacement — the oracle function remains authoritative.
+* In dev mode, assertions verify equivalence.
+*/
+function createReactiveNodeState() {
+	const contentDirty = signal(false);
+	const stylePropsDirty = signal(false);
+	const bgDirty = signal(false);
+	const childrenDirty = signal(false);
+	const subtreeDirty = signal(false);
+	const layoutChanged = signal(false);
+	const hasPrevBuffer = signal(false);
+	const childPositionChanged = signal(false);
+	const ancestorLayoutChanged = signal(false);
+	const ancestorCleared = signal(false);
+	const isTextNode = signal(false);
+	const hasBgColor = signal(false);
+	const absoluteChildMutated = signal(false);
+	const descendantOverflowChanged = signal(false);
+	const canSkipEntireSubtree = computed(() => hasPrevBuffer() && !contentDirty() && !stylePropsDirty() && !layoutChanged() && !subtreeDirty() && !childrenDirty() && !childPositionChanged() && !ancestorLayoutChanged());
+	const textPaintDirty = computed(() => isTextNode() && stylePropsDirty());
+	const contentAreaAffected = computed(() => contentDirty() || layoutChanged() || childPositionChanged() || childrenDirty() || bgDirty() || textPaintDirty() || absoluteChildMutated() || descendantOverflowChanged());
+	const bgOnlyChange = computed(() => false);
+	const bgRefillNeeded = computed(() => hasPrevBuffer() && !contentAreaAffected() && subtreeDirty() && hasBgColor());
+	return {
+		contentDirty,
+		stylePropsDirty,
+		bgDirty,
+		childrenDirty,
+		subtreeDirty,
+		layoutChanged,
+		hasPrevBuffer,
+		childPositionChanged,
+		ancestorLayoutChanged,
+		ancestorCleared,
+		isTextNode,
+		hasBgColor,
+		absoluteChildMutated,
+		descendantOverflowChanged,
+		canSkipEntireSubtree,
+		textPaintDirty,
+		contentAreaAffected,
+		bgRefillNeeded,
+		contentRegionCleared: computed(() => (hasPrevBuffer() || ancestorCleared()) && contentAreaAffected() && !hasBgColor()),
+		skipBgFill: computed(() => hasPrevBuffer() && !ancestorCleared() && !contentAreaAffected() && !bgRefillNeeded()),
+		childrenNeedFreshRender: computed(() => (hasPrevBuffer() || ancestorCleared()) && (contentAreaAffected() || bgRefillNeeded()) && !bgOnlyChange()),
+		bgOnlyChange
+	};
+}
+/**
+* Sync a node's epoch-stamped dirty flags into the reactive signals.
+*
+* Called once per node at the start of renderNodeToBuffer, BEFORE reading
+* any computed. Context-dependent inputs (hasPrevBuffer, ancestorCleared, etc.)
+* are also set here since they vary per tree-traversal position.
+*/
+function syncToSignals(state, node, ctx) {
+	state.contentDirty(isDirty(node.dirtyBits, node.dirtyEpoch, 1));
+	state.stylePropsDirty(isDirty(node.dirtyBits, node.dirtyEpoch, 2));
+	state.bgDirty(isDirty(node.dirtyBits, node.dirtyEpoch, 4));
+	state.childrenDirty(isDirty(node.dirtyBits, node.dirtyEpoch, 8));
+	state.subtreeDirty(isDirty(node.dirtyBits, node.dirtyEpoch, 16));
+	state.layoutChanged(ctx.layoutChanged);
+	state.hasPrevBuffer(ctx.hasPrevBuffer);
+	state.childPositionChanged(ctx.childPositionChanged);
+	state.ancestorLayoutChanged(ctx.ancestorLayoutChanged);
+	state.ancestorCleared(ctx.ancestorCleared);
+	state.isTextNode(node.type === "silvery-text");
+	state.hasBgColor(ctx.hasBgColor);
+	state.absoluteChildMutated(ctx.absoluteChildMutated);
+	state.descendantOverflowChanged(ctx.descendantOverflowChanged);
+}
+/**
+* Read all cascade outputs from the reactive computeds.
+* Call AFTER `syncToSignals()`. Returns the same CascadeOutputs shape
+* as `computeCascade()` but derived from the signal graph.
+*/
+function readReactiveCascade(state) {
+	return {
+		canSkipEntireSubtree: state.canSkipEntireSubtree(),
+		contentAreaAffected: state.contentAreaAffected(),
+		bgRefillNeeded: state.bgRefillNeeded(),
+		contentRegionCleared: state.contentRegionCleared(),
+		skipBgFill: state.skipBgFill(),
+		childrenNeedFreshRender: state.childrenNeedFreshRender(),
+		bgOnlyChange: state.bgOnlyChange()
+	};
+}
+/**
+* Verify that reactive computeds match the cascade oracle.
+*
+* Call in dev mode (SILVERY_STRICT=1) after syncToSignals + computeCascade.
+* Throws on mismatch with a detailed diff.
+*/
+function assertReactiveMatchesOracle(state, oracle, nodeId) {
+	const fields = [
+		"canSkipEntireSubtree",
+		"contentAreaAffected",
+		"bgRefillNeeded",
+		"contentRegionCleared",
+		"skipBgFill",
+		"childrenNeedFreshRender",
+		"bgOnlyChange"
+	];
+	const mismatches = [];
+	for (const field of fields) {
+		const reactiveValue = state[field]();
+		const oracleValue = oracle[field];
+		if (reactiveValue !== oracleValue) mismatches.push(`  ${field}: reactive=${reactiveValue}, oracle=${oracleValue}`);
+	}
+	if (mismatches.length > 0) throw new Error(`ReactiveNodeState mismatch for ${nodeId || "(unnamed)"}:\n${mismatches.join("\n")}`);
+}
+/**
+* WeakMap from AgNode to its reactive state.
+*
+* Lazily created on first access. Automatically garbage-collected when the
+* node is removed from the tree (WeakMap semantics).
+*/
+const nodeStates = /* @__PURE__ */ new WeakMap();
+/**
+* Get or create the reactive state for a node.
+*
+* Uses a WeakMap so states are automatically cleaned up when nodes are GC'd.
+*/
+function getReactiveState(node) {
+	let state = nodeStates.get(node);
+	if (!state) {
+		state = createReactiveNodeState();
+		nodeStates.set(node, state);
+	}
+	return state;
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/render-phase.ts
+/**
+* Phase 3: Render Phase
+*
+* Render all nodes to a terminal buffer.
+*
+* This module orchestrates the rendering process by traversing the node tree
+* and delegating to specialized rendering functions for boxes and text.
+*
+* Layout (top-down):
+*   renderPhase → renderNodeToBuffer → buildCascadeInputs + computeCascade (oracle)
+*                                     → traceRenderDecision (diagnostics)
+*                                     → executeRegionClearing
+*                                     → renderOwnContent
+*                                     → renderScrollContainerChildren / renderNormalChildren
+*   Helpers: clearDirtyFlags, hasChildPositionChanged, computeChildClipBounds
+*   Region clearing: clearNodeRegion, clearExcessArea, clippedFill
+*/
+init_buffer();
+init_state();
+const contentLog = createLogger("silvery:content");
+const traceLog = createLogger("silvery:content:trace");
+const cellLog = createLogger("silvery:content:cell");
+/**
+* Render all nodes to a terminal buffer.
+*
+* @param root The root SilveryNode
+* @param prevBuffer Previous buffer for incremental rendering (optional)
+* @returns A TerminalBuffer with the rendered content
+*/
+function renderPhase(root, prevBuffer, ctx) {
+	const layout = root.boxRect;
+	if (!layout) throw new Error("renderPhase called before layout phase");
+	const instr = resolveInstrumentation(ctx);
+	const hasPrevBuffer = prevBuffer && prevBuffer.width === layout.width && prevBuffer.height === layout.height;
+	if (hasPrevBuffer && !isAnyDirty(root.dirtyBits, root.dirtyEpoch) && !isCurrentEpoch(root.layoutChangedThisFrame)) {
+		if (instr.enabled) instr.stats._noopSkip = 1;
+		advanceRenderEpoch();
+		return prevBuffer;
+	}
+	if (instr.enabled) {
+		instr.stats._prevBufferNull = prevBuffer == null ? 1 : 0;
+		instr.stats._prevBufferDimMismatch = prevBuffer && !hasPrevBuffer ? 1 : 0;
+		instr.stats._hasPrevBuffer = hasPrevBuffer ? 1 : 0;
+		instr.stats._layoutW = layout.width;
+		instr.stats._layoutH = layout.height;
+		instr.stats._prevW = prevBuffer?.width ?? 0;
+		instr.stats._prevH = prevBuffer?.height ?? 0;
+	}
+	const t0 = instr.enabled ? performance.now() : 0;
+	const buffer = hasPrevBuffer ? prevBuffer.clone() : new TerminalBuffer(layout.width, layout.height);
+	const tClone = instr.enabled ? performance.now() - t0 : 0;
+	buffer.setSelectableMode(true);
+	const t1 = instr.enabled ? performance.now() : 0;
+	renderNodeToBuffer(root, buffer, {
+		scrollOffset: 0,
+		clipBounds: void 0,
+		hasPrevBuffer: !!hasPrevBuffer,
+		ancestorCleared: false,
+		bufferIsCloned: !!hasPrevBuffer,
+		ancestorLayoutChanged: false,
+		inheritedBg: {
+			color: null,
+			ancestorRect: null
+		},
+		inheritedFg: null
+	}, ctx);
+	const tRender = instr.enabled ? performance.now() - t1 : 0;
+	if (instr.enabled) emitRenderPhaseStats(instr.stats, instr.nodeTrace, instr.nodeTraceEnabled, tClone, tRender);
+	syncPrevLayout(root, isCurrentEpoch(root.layoutChangedThisFrame) || isDirty(root.dirtyBits, root.dirtyEpoch, 16) || !hasPrevBuffer);
+	advanceRenderEpoch();
+	return buffer;
+}
+/**
+* Sync prevLayout to boxRect for all nodes in the tree.
+*
+* Called at the end of each renderPhase pass. This prevents:
+* 1. The O(N) staleness bug where prevLayout drifts from boxRect
+*    causing !rectEqual to always be true on subsequent frames.
+* 2. Stale old-bounds references in clearExcessArea on doRender iteration 2+.
+* 3. Asymmetry between incremental and fresh renders — doFreshRender's layout
+*    phase syncs prevLayout before content, so without this, the real render
+*    has null/stale prevLayout while fresh has synced prevLayout, causing
+*    different cascade behavior (layoutChanged true vs false).
+*/
+/**
+* Sync prevLayout = boxRect for nodes whose layout changed.
+*
+* Previously walked ALL nodes O(N) every frame. Now only visits nodes
+* with layoutChangedThisFrame (set by propagateLayout in layout phase).
+* Falls back to full walk when layout phase ran (dimensions changed or
+* layoutDirty) since any node may have moved.
+*
+* For cursor move (no layout change): O(1) — no nodes to sync.
+* For resize: O(N) — all nodes may have moved (same as before).
+*/
+function syncPrevLayout(root, layoutPhaseRan) {
+	if (!layoutPhaseRan) return;
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		node.prevLayout = node.boxRect;
+		const children = node.children;
+		for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+	}
+}
+/** Check if an env var is truthy (treats "0" and "false" as disabled). */
+function envTruthy(val) {
+	return !!val && val !== "0" && val !== "false";
+}
+/** Instrumentation enabled when SILVERY_STRICT or SILVERY_INSTRUMENT is set */
+const _instrumentEnabled = typeof process !== "undefined" && (envTruthy(process.env?.SILVERY_STRICT) || envTruthy(process.env?.SILVERY_INSTRUMENT));
+/** Mutable stats counters — reset after each renderPhase call */
+const _renderPhaseStats = {
+	nodesVisited: 0,
+	nodesRendered: 0,
+	nodesSkipped: 0,
+	textNodes: 0,
+	boxNodes: 0,
+	clearOps: 0,
+	noPrevBuffer: 0,
+	flagContentDirty: 0,
+	flagStylePropsDirty: 0,
+	flagLayoutChanged: 0,
+	flagSubtreeDirty: 0,
+	flagChildrenDirty: 0,
+	flagChildPositionChanged: 0,
+	flagAncestorLayoutChanged: 0,
+	scrollContainerCount: 0,
+	scrollViewportCleared: 0,
+	scrollClearReason: "",
+	normalChildrenRepaint: 0,
+	normalRepaintReason: "",
+	cascadeMinDepth: 999,
+	cascadeNodes: "",
+	_noopSkip: 0,
+	_prevBufferNull: 0,
+	_prevBufferDimMismatch: 0,
+	_hasPrevBuffer: 0,
+	_layoutW: 0,
+	_layoutH: 0,
+	_prevW: 0,
+	_prevH: 0,
+	_callCount: 0
+};
+let _renderPhaseCallCount = 0;
+/** Module-level node trace (fallback when ctx.nodeTrace is not provided) */
+const _nodeTrace = [];
+const _nodeTraceEnabled = typeof process !== "undefined" && envTruthy(process.env?.SILVERY_STRICT);
+/**
+* Reactive cascade: alien-signals computeds drive rendering (production path).
+* SILVERY_REACTIVE=0: fall back to imperative computeCascade() (bench only).
+* SILVERY_STRICT=1: oracle verifies reactive output matches imperative.
+*/
+let _reactiveEnabled = typeof process === "undefined" || process.env?.SILVERY_REACTIVE !== "0";
+let _reactiveVerifyEnabled = _reactiveEnabled && typeof process !== "undefined" && envTruthy(process.env?.SILVERY_STRICT);
+/** Resolve instrumentation from PipelineContext or module-level defaults. */
+function resolveInstrumentation(ctx) {
+	return {
+		enabled: ctx?.instrumentEnabled ?? _instrumentEnabled,
+		stats: ctx?.stats ?? _renderPhaseStats,
+		nodeTrace: ctx?.nodeTrace ?? _nodeTrace,
+		nodeTraceEnabled: ctx?.nodeTraceEnabled ?? _nodeTraceEnabled
+	};
+}
+/** Read the cell debug target (set by SILVERY_CELL_DEBUG env var). */
+function getCellDebug() {
+	return globalThis.__silvery_cell_debug;
+}
+/** Check if a rect covers the cell debug target point. */
+function cellCoversPoint(cellDbg, x, y, width, height) {
+	return x <= cellDbg.x && x + width > cellDbg.x && y <= cellDbg.y && y + height > cellDbg.y;
+}
+/** DIAG: compute node depth in tree */
+function _getNodeDepth(node) {
+	let depth = 0;
+	let n = node.parent;
+	while (n) {
+		depth++;
+		n = n.parent;
+	}
+	return depth;
+}
+/**
+* Emit render-phase stats to globalThis + loggily, then reset counters.
+* Called at end of renderPhase when instrumentation is active.
+*/
+function emitRenderPhaseStats(stats, nodeTrace, nodeTraceEnabled, tClone, tRender) {
+	_renderPhaseCallCount++;
+	stats._callCount = _renderPhaseCallCount;
+	const snap = {
+		clone: tClone,
+		render: tRender,
+		...structuredClone(stats)
+	};
+	globalThis.__silvery_content_detail = snap;
+	(globalThis.__silvery_content_all ??= []).push(snap);
+	contentLog.debug?.(`frame ${snap._callCount}: ${snap.nodesRendered}/${snap.nodesVisited} rendered, ${snap.nodesSkipped} skipped (${tClone.toFixed(1)}ms clone, ${tRender.toFixed(1)}ms render)`);
+	for (const key of Object.keys(stats)) stats[key] = 0;
+	stats.cascadeMinDepth = 999;
+	stats.cascadeNodes = "";
+	stats.scrollClearReason = "";
+	stats.normalRepaintReason = "";
+	if (nodeTraceEnabled && nodeTrace.length > 0) {
+		(globalThis.__silvery_node_trace ??= []).push([...nodeTrace]);
+		traceLog.debug?.(`${nodeTrace.length} nodes traced`);
+		nodeTrace.length = 0;
+	}
+}
+/**
+* Render a single node to the buffer.
+*/
+function renderNodeToBuffer(node, buffer, nodeState, ctx) {
+	const { scrollOffset, clipBounds, hasPrevBuffer, ancestorCleared, bufferIsCloned, ancestorLayoutChanged = false } = nodeState;
+	const instr = resolveInstrumentation(ctx);
+	if (instr.enabled) instr.stats.nodesVisited++;
+	const layout = node.boxRect;
+	if (!layout) return;
+	if (!node.layoutNode) {
+		clearVirtualTextFlags(node);
+		return;
+	}
+	if (node.hidden) {
+		clearDirtyFlags(node);
+		return;
+	}
+	const props = node.props;
+	const prevSelectableMode = buffer.getSelectableMode();
+	const userSelect = props.userSelect;
+	if (userSelect === "none") buffer.setSelectableMode(false);
+	else if (userSelect === "text" || userSelect === "contain") buffer.setSelectableMode(true);
+	if (props.display === "none") {
+		clearDirtyFlags(node);
+		buffer.setSelectableMode(prevSelectableMode);
+		return;
+	}
+	const screenY = layout.y - scrollOffset;
+	if (screenY >= buffer.height || screenY + layout.height <= 0) {
+		buffer.setSelectableMode(prevSelectableMode);
+		return;
+	}
+	const layoutChanged = isCurrentEpoch(node.layoutChangedThisFrame);
+	const childPositionChanged = !!(hasPrevBuffer && !layoutChanged && hasChildPositionChanged(node));
+	const scrollOffsetChanged = !!(node.scrollState && node.scrollState.offset !== node.scrollState.prevOffset);
+	const canSkipEntireSubtree = hasPrevBuffer && !isDirty(node.dirtyBits, node.dirtyEpoch, 1) && !isDirty(node.dirtyBits, node.dirtyEpoch, 2) && !layoutChanged && !isDirty(node.dirtyBits, node.dirtyEpoch, 16) && !isDirty(node.dirtyBits, node.dirtyEpoch, 8) && !childPositionChanged && !ancestorLayoutChanged && !scrollOffsetChanged;
+	const _nodeId = instr.enabled ? props.id ?? "" : "";
+	const _traceThis = instr.enabled && instr.nodeTraceEnabled && _nodeId;
+	const _cellDbg = getCellDebug();
+	const _coversCellNow = _cellDbg && cellCoversPoint(_cellDbg, layout.x, screenY, layout.width, layout.height);
+	const _coversCellPrev = _cellDbg && node.prevLayout && cellCoversPoint(_cellDbg, node.prevLayout.x, node.prevLayout.y - scrollOffset, node.prevLayout.width, node.prevLayout.height);
+	if (canSkipEntireSubtree) {
+		if (_cellDbg && (_coversCellNow || _coversCellPrev)) {
+			const id = props.id ?? node.type;
+			const depth = _getNodeDepth(node);
+			const prev = node.prevLayout;
+			const msg = `SKIP ${id}@${depth} rect=${layout.x},${screenY} ${layout.width}x${layout.height} prev=${prev ? `${prev.x},${prev.y - scrollOffset} ${prev.width}x${prev.height}` : "null"} coversNow=${_coversCellNow} coversPrev=${_coversCellPrev}`;
+			_cellDbg.log.push(msg);
+			cellLog.debug?.(msg);
+		}
+		if (instr.enabled) {
+			instr.stats.nodesSkipped++;
+			if (_traceThis) instr.nodeTrace.push({
+				id: _nodeId,
+				type: node.type,
+				depth: _getNodeDepth(node),
+				rect: `${layout.x},${layout.y} ${layout.width}x${layout.height}`,
+				prevLayout: node.prevLayout ? `${node.prevLayout.x},${node.prevLayout.y} ${node.prevLayout.width}x${node.prevLayout.height}` : "null",
+				hasPrev: hasPrevBuffer,
+				ancestorCleared,
+				flags: "",
+				decision: "SKIPPED",
+				layoutChanged
+			});
+		}
+		clearDirtyFlags(node);
+		buffer.setSelectableMode(prevSelectableMode);
+		return;
+	}
+	if (instr.enabled) {
+		instr.stats.nodesRendered++;
+		if (!hasPrevBuffer) instr.stats.noPrevBuffer++;
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 1)) instr.stats.flagContentDirty++;
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 2)) instr.stats.flagStylePropsDirty++;
+		if (layoutChanged) instr.stats.flagLayoutChanged++;
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 16)) instr.stats.flagSubtreeDirty++;
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 8)) instr.stats.flagChildrenDirty++;
+		if (childPositionChanged) instr.stats.flagChildPositionChanged++;
+		if (ancestorLayoutChanged) instr.stats.flagAncestorLayoutChanged++;
+	}
+	const nodeTheme = props.theme;
+	if (nodeTheme) pushContextTheme(nodeTheme);
+	try {
+		const isScrollContainer = props.overflow === "scroll" && node.scrollState;
+		const { absoluteChildMutated, descendantOverflowChanged } = buildCascadeInputs(node, hasPrevBuffer);
+		const cascadeInputs = {
+			hasPrevBuffer,
+			contentDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 1),
+			stylePropsDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 2),
+			layoutChanged,
+			subtreeDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 16),
+			childrenDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 8),
+			childPositionChanged,
+			ancestorLayoutChanged,
+			ancestorCleared,
+			bgDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 4),
+			isTextNode: node.type === "silvery-text",
+			hasBgColor: !!getEffectiveBg(props),
+			absoluteChildMutated,
+			descendantOverflowChanged
+		};
+		let cascade;
+		if (_reactiveEnabled) {
+			const reactiveState = getReactiveState(node);
+			syncToSignals(reactiveState, node, {
+				hasPrevBuffer,
+				layoutChanged,
+				childPositionChanged,
+				ancestorLayoutChanged,
+				ancestorCleared,
+				absoluteChildMutated,
+				descendantOverflowChanged,
+				hasBgColor: cascadeInputs.hasBgColor
+			});
+			cascade = readReactiveCascade(reactiveState);
+			if (_reactiveVerifyEnabled) assertReactiveMatchesOracle(reactiveState, computeCascade(cascadeInputs), props.id ?? node.type);
+		} else cascade = computeCascade(cascadeInputs);
+		if (cascade.bgOnlyChange && hasDescendantWithBg(node)) {
+			const childrenNeedFreshRender = (hasPrevBuffer || ancestorCleared) && (cascade.contentAreaAffected || cascade.bgRefillNeeded);
+			cascade = {
+				...cascade,
+				bgOnlyChange: false,
+				childrenNeedFreshRender
+			};
+		}
+		const { contentRegionCleared, skipBgFill, childrenNeedFreshRender } = cascade;
+		if (instr.enabled || _cellDbg && (_coversCellNow || _coversCellPrev)) traceRenderDecision(node, props, layout, screenY, scrollOffset, hasPrevBuffer, ancestorCleared, layoutChanged, childPositionChanged, cascade, _nodeId, _traceThis, _cellDbg, _coversCellNow, _coversCellPrev, instr.enabled, instr.stats, instr.nodeTrace);
+		const useTextStyleFastPath = false;
+		executeRegionClearing(node, buffer, layout, scrollOffset, clipBounds, bufferIsCloned, layoutChanged, contentRegionCleared, descendantOverflowChanged, instr.enabled, instr.stats, nodeState.inheritedBg);
+		const needsOwnRepaint = !hasPrevBuffer || ancestorCleared || ancestorLayoutChanged || cascade.contentAreaAffected || isDirty(node.dirtyBits, node.dirtyEpoch, 2) || cascade.bgRefillNeeded;
+		const boxInheritedBg = node.type === "silvery-box" && !getEffectiveBg(props) ? nodeState.inheritedBg.color : void 0;
+		if (needsOwnRepaint) renderOwnContent(node, buffer, layout, props, nodeState, skipBgFill, instr.enabled, instr.stats, ctx, cascade.bgOnlyChange, useTextStyleFastPath);
+		const effectiveBg = getEffectiveBg(props);
+		const childInheritedBg = effectiveBg ? {
+			color: parseColor(effectiveBg),
+			ancestorRect: node.boxRect
+		} : nodeTheme ? {
+			color: parseColor(nodeTheme.bg),
+			ancestorRect: node.boxRect
+		} : nodeState.inheritedBg;
+		const childInheritedFg = props.color ? parseColor(props.color) : nodeTheme ? parseColor(nodeTheme.fg) : nodeState.inheritedFg;
+		const childState = {
+			...nodeState,
+			inheritedBg: childInheritedBg,
+			inheritedFg: childInheritedFg
+		};
+		if (isScrollContainer) {
+			renderScrollContainerChildren(node, buffer, props, childState, contentRegionCleared, childrenNeedFreshRender, ctx);
+			renderScrollIndicators(node, buffer, layout, props, node.scrollState, ctx);
+		} else renderNormalChildren(node, buffer, props, childState, childPositionChanged, contentRegionCleared, childrenNeedFreshRender, ctx);
+		if (node.type === "silvery-box" && props.outlineStyle) {
+			const { x, width, height } = layout;
+			renderOutline(buffer, x, layout.y - scrollOffset, width, height, props, clipBounds, boxInheritedBg);
+		}
+		clearNodeDirtyFlags(node);
+	} finally {
+		if (nodeTheme) popContextTheme();
+		buffer.setSelectableMode(prevSelectableMode);
+	}
+}
+/**
+* Build tree-dependent cascade inputs that require child traversal.
+*
+* These feed into computeCascade() alongside the node's own dirty flags.
+* Separated from renderNodeToBuffer to keep the main function focused on
+* the rendering flow rather than child traversal details.
+*/
+function buildCascadeInputs(node, hasPrevBuffer) {
+	if (!hasPrevBuffer || !isDirty(node.dirtyBits, node.dirtyEpoch, 16) || node.children === void 0) return {
+		absoluteChildMutated: false,
+		descendantOverflowChanged: false
+	};
+	return {
+		absoluteChildMutated: isDirty(node.dirtyBits, node.dirtyEpoch, 32),
+		descendantOverflowChanged: isDirty(node.dirtyBits, node.dirtyEpoch, 64)
+	};
+}
+/**
+* Log per-node trace, cascade tracking, and cell debug info.
+*
+* Gated on instrumentation or cell debug being active. Separated from
+* renderNodeToBuffer to keep the main function focused on rendering logic.
+*/
+function traceRenderDecision(node, props, layout, screenY, scrollOffset, hasPrevBuffer, ancestorCleared, layoutChanged, childPositionChanged, cascade, _nodeId, _traceThis, _cellDbg, _coversCellNow, _coversCellPrev, instrumentEnabled, stats, nodeTrace) {
+	const { contentAreaAffected, contentRegionCleared, skipBgFill, childrenNeedFreshRender } = cascade;
+	if (instrumentEnabled) {
+		if (_traceThis) {
+			const flagStr = [
+				isDirty(node.dirtyBits, node.dirtyEpoch, 1) && "C",
+				isDirty(node.dirtyBits, node.dirtyEpoch, 2) && "P",
+				isDirty(node.dirtyBits, node.dirtyEpoch, 4) && "B",
+				isDirty(node.dirtyBits, node.dirtyEpoch, 16) && "S",
+				isDirty(node.dirtyBits, node.dirtyEpoch, 8) && "Ch",
+				childPositionChanged && "CP"
+			].filter(Boolean).join(",");
+			const childHasPrev_ = isDirty(node.dirtyBits, node.dirtyEpoch, 8) || childPositionChanged || childrenNeedFreshRender ? false : hasPrevBuffer;
+			const childAncestorCleared_ = contentRegionCleared || ancestorCleared && !getEffectiveBg(props);
+			nodeTrace.push({
+				id: _nodeId,
+				type: node.type,
+				depth: _getNodeDepth(node),
+				rect: `${layout.x},${layout.y} ${layout.width}x${layout.height}`,
+				prevLayout: node.prevLayout ? `${node.prevLayout.x},${node.prevLayout.y} ${node.prevLayout.width}x${node.prevLayout.height}` : "null",
+				hasPrev: hasPrevBuffer,
+				ancestorCleared,
+				flags: flagStr,
+				decision: "RENDER",
+				layoutChanged,
+				contentAreaAffected,
+				contentRegionCleared,
+				childrenNeedFreshRender,
+				childHasPrev: childHasPrev_,
+				childAncestorCleared: childAncestorCleared_,
+				skipBgFill,
+				bgColor: props.backgroundColor
+			});
+		}
+		if (childrenNeedFreshRender && node.children.length > 0) {
+			const depth = _getNodeDepth(node);
+			if (depth < stats.cascadeMinDepth) stats.cascadeMinDepth = depth;
+			const entry = `${node.props.id ?? node.type}@${depth}[${[
+				isDirty(node.dirtyBits, node.dirtyEpoch, 1) && "C",
+				isDirty(node.dirtyBits, node.dirtyEpoch, 2) && "P",
+				isDirty(node.dirtyBits, node.dirtyEpoch, 8) && "Ch",
+				layoutChanged && "L",
+				childPositionChanged && "CP"
+			].filter(Boolean).join("")}:${node.children.length}ch]`;
+			stats.cascadeNodes += (stats.cascadeNodes ? " " : "") + entry;
+		}
+	}
+	if (_cellDbg && (_coversCellNow || _coversCellPrev)) {
+		const id = props.id ?? node.type;
+		const depth = _getNodeDepth(node);
+		const prev = node.prevLayout;
+		const flags = [
+			isDirty(node.dirtyBits, node.dirtyEpoch, 1) && "C",
+			isDirty(node.dirtyBits, node.dirtyEpoch, 2) && "P",
+			layoutChanged && "L",
+			isDirty(node.dirtyBits, node.dirtyEpoch, 16) && "S",
+			isDirty(node.dirtyBits, node.dirtyEpoch, 8) && "Ch",
+			childPositionChanged && "CP",
+			isDirty(node.dirtyBits, node.dirtyEpoch, 4) && "B"
+		].filter(Boolean).join(",");
+		const msg = `RENDER ${id}@${depth} rect=${layout.x},${screenY} ${layout.width}x${layout.height} prev=${prev ? `${prev.x},${prev.y - scrollOffset} ${prev.width}x${prev.height}` : "null"} flags=[${flags}] hasPrev=${hasPrevBuffer} ancClr=${ancestorCleared} caa=${contentAreaAffected} prc=${contentRegionCleared} prm=${childrenNeedFreshRender} coversNow=${_coversCellNow} coversPrev=${_coversCellPrev} bg=${props.backgroundColor ?? "none"}`;
+		_cellDbg.log.push(msg);
+		cellLog.debug?.(msg);
+	}
+}
+/**
+* Handle all region clearing before rendering own content.
+*
+* Three clearing paths:
+* 1. contentRegionCleared: clear the node's region with inherited bg (no own bg)
+* 2. Excess area: clear stale pixels when a node shrank (even without contentRegionCleared)
+* 3. Descendant overflow: clear areas where descendants previously overflowed this node's rect
+*
+* All clearing runs BEFORE renderBox/renderText so borders drawn later are not overwritten.
+*/
+function executeRegionClearing(node, buffer, layout, scrollOffset, clipBounds, bufferIsCloned, layoutChanged, contentRegionCleared, descendantOverflowChanged, instrumentEnabled, stats, threadedInheritedBg) {
+	if (contentRegionCleared) {
+		if (instrumentEnabled) stats.clearOps++;
+		clearNodeRegion(node, buffer, layout, scrollOffset, clipBounds, layoutChanged, threadedInheritedBg);
+	} else if (bufferIsCloned && layoutChanged && node.prevLayout) clearExcessArea(node, buffer, layout, scrollOffset, clipBounds, layoutChanged, threadedInheritedBg);
+	if (descendantOverflowChanged) clearDescendantOverflowRegions(node, buffer, layout, scrollOffset, clipBounds, threadedInheritedBg);
+}
+/**
+* Render this node's own content (box background/border or text).
+*
+* For boxes: computes inherited bg for border rendering and calls renderBox.
+* For text: computes inherited bg/fg for text rendering and calls renderText.
+*
+* @returns The boxInheritedBg color (needed by outline rendering after children).
+*/
+function renderOwnContent(node, buffer, layout, props, nodeState, skipBgFill, instrumentEnabled, stats, ctx, bgOnlyChange = false, useTextStyleFastPath = false) {
+	const boxInheritedBg = node.type === "silvery-box" && !getEffectiveBg(props) ? nodeState.inheritedBg.color : void 0;
+	if (node.type === "silvery-box") {
+		if (instrumentEnabled) stats.boxNodes++;
+		renderBox(node, buffer, layout, props, nodeState, skipBgFill, boxInheritedBg, bgOnlyChange);
+	} else if (node.type === "silvery-text") {
+		if (instrumentEnabled) stats.textNodes++;
+		const textInheritedBg = nodeState.inheritedBg.color;
+		const textInheritedFg = nodeState.inheritedFg;
+		if (useTextStyleFastPath) {
+			const style = getTextStyle(props);
+			if (style.fg === null && textInheritedFg !== void 0) style.fg = textInheritedFg;
+			const effectiveBg = style.bg !== null ? style.bg : textInheritedBg ?? null;
+			const { x, width, height } = layout;
+			const y = layout.y - nodeState.scrollOffset;
+			buffer.restyleRegion(x, y, width, height, {
+				fg: style.fg,
+				bg: effectiveBg,
+				underlineColor: style.underlineColor ?? null,
+				attrs: style.attrs
+			});
+		} else renderText(node, buffer, layout, props, nodeState, textInheritedBg, textInheritedFg, ctx);
+	}
+	return boxInheritedBg;
+}
+/**
+* Determine the scroll tier strategy for this frame.
+*
+* Pure function -- no side effects, no node access beyond the inputs.
+*
+* Three-tier strategy:
+* 1. **shift**: Only scroll offset changed, no sticky children. Buffer contents
+*    shifted by scroll delta; only newly visible edges re-render.
+* 2. **clear**: Children restructured, visible range changed with scroll, or
+*    parent region changed. Entire viewport cleared and all children re-render.
+* 3. **subtree-only**: Only some descendants changed. Children use hasPrevBuffer=true
+*    and skip via fast-path if clean. With sticky children, forces all first-pass
+*    items to re-render (stickyForceRefresh).
+*/
+function planScrollRender(inputs) {
+	const { scrollOffsetChanged, visibleRangeChanged, hasStickyChildren, childrenNeedFreshRender, childrenDirty, hasPrevBuffer, ancestorCleared, contentRegionCleared, scrollBg } = inputs;
+	const scrollOnly = hasPrevBuffer && scrollOffsetChanged && !childrenDirty && !childrenNeedFreshRender && !hasStickyChildren && !visibleRangeChanged;
+	const needsViewportClear = hasPrevBuffer && !scrollOnly && (scrollOffsetChanged || childrenDirty || childrenNeedFreshRender || visibleRangeChanged);
+	const stickyForceRefresh = hasStickyChildren && hasPrevBuffer && !needsViewportClear;
+	const reasons = [];
+	if (scrollOnly) reasons.push("SHIFT");
+	if (needsViewportClear) {
+		if (scrollOffsetChanged) reasons.push("scrollOffset");
+		if (childrenDirty) reasons.push("childrenDirty");
+		if (childrenNeedFreshRender) reasons.push("childrenNeedFreshRender");
+		if (visibleRangeChanged) reasons.push("visibleRangeChanged");
+	}
+	if (stickyForceRefresh) reasons.push("stickyForceRefresh");
+	return {
+		tier: scrollOnly ? "shift" : needsViewportClear ? "clear" : "subtree-only",
+		clearBg: scrollOnly || needsViewportClear ? scrollBg : null,
+		childHasPrev: needsViewportClear ? false : hasPrevBuffer,
+		childAncestorCleared: needsViewportClear ? true : ancestorCleared || contentRegionCleared,
+		stickyForceRefresh,
+		reasons
+	};
+}
+/**
+* Render children of a scroll container with proper clipping and offset.
+*/
+function renderScrollContainerChildren(node, buffer, props, nodeState, contentRegionCleared = false, childrenNeedFreshRender = false, ctx) {
+	const { clipBounds, hasPrevBuffer, ancestorCleared, bufferIsCloned, ancestorLayoutChanged, inheritedBg, inheritedFg } = nodeState;
+	const instr = resolveInstrumentation(ctx);
+	const layout = node.boxRect;
+	const ss = node.scrollState;
+	if (!layout || !ss) return;
+	const border = props.borderStyle ? getBorderSize(props) : {
+		top: 0,
+		bottom: 0,
+		left: 0,
+		right: 0
+	};
+	const padding = getPadding(props);
+	const childClipBounds = computeChildClipBounds(layout, props, clipBounds, 0, false, true);
+	const scrollOffsetChanged = ss.offset !== ss.prevOffset;
+	const hasStickyChildren = !!(ss.stickyChildren && ss.stickyChildren.length > 0);
+	const visibleRangeChanged = ss.firstVisibleChild !== ss.prevFirstVisibleChild || ss.lastVisibleChild !== ss.prevLastVisibleChild;
+	const clearY = childClipBounds.top;
+	const clearHeight = childClipBounds.bottom - childClipBounds.top;
+	const contentX = layout.x + border.left + padding.left;
+	const contentWidth = layout.width - border.left - border.right - padding.left - padding.right;
+	const scrollBg = scrollOffsetChanged || isDirty(node.dirtyBits, node.dirtyEpoch, 8) || childrenNeedFreshRender || visibleRangeChanged ? getEffectiveBg(props) ? parseColor(getEffectiveBg(props)) : inheritedBg.color : null;
+	const plan = planScrollRender({
+		scrollOffsetChanged,
+		visibleRangeChanged,
+		hasStickyChildren,
+		childrenNeedFreshRender,
+		childrenDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 8),
+		hasPrevBuffer,
+		ancestorCleared,
+		contentRegionCleared,
+		scrollBg
+	});
+	const { tier, stickyForceRefresh } = plan;
+	const defaultChildHasPrev = plan.childHasPrev;
+	const defaultChildAncestorCleared = plan.childAncestorCleared;
+	if (instr.enabled) {
+		instr.stats.scrollContainerCount++;
+		if (tier !== "subtree-only" || stickyForceRefresh) {
+			instr.stats.scrollViewportCleared++;
+			const reasons = [...plan.reasons];
+			if (scrollOffsetChanged) reasons.push(`scrollOffset(${ss.prevOffset}->${ss.offset})`);
+			reasons.push(`vp=${ss.viewportHeight} content=${ss.contentHeight} vis=${ss.firstVisibleChild}-${ss.lastVisibleChild}`);
+			instr.stats.scrollClearReason = reasons.join("+");
+		}
+	}
+	if (process?.env?.SILVERY_STRICT && tier === "shift" && hasStickyChildren) throw new Error(`[SILVERY_STRICT] Scroll Tier 1 (buffer shift) activated with sticky children (node: ${props.id ?? node.type}, stickyCount: ${ss.stickyChildren?.length ?? 0})`);
+	const scrollDelta = ss.offset - (ss.prevOffset ?? ss.offset);
+	if (tier === "shift" && clearHeight > 0) {
+		if (props.overflowIndicator === true && !border.top && !border.bottom) {
+			const topIndicatorY = clearY;
+			const bottomIndicatorY = clearY + clearHeight - 1;
+			if (ss.prevOffset != null && ss.prevOffset > 0) buffer.fill(contentX, topIndicatorY, contentWidth, 1, {
+				char: " ",
+				bg: plan.clearBg
+			});
+			buffer.fill(contentX, bottomIndicatorY, contentWidth, 1, {
+				char: " ",
+				bg: plan.clearBg
+			});
+		}
+		buffer.scrollRegion(contentX, clearY, contentWidth, clearHeight, scrollDelta, {
+			char: " ",
+			bg: plan.clearBg
+		});
+	}
+	if (tier === "clear" && clearHeight > 0) buffer.fill(contentX, clearY, contentWidth, clearHeight, {
+		char: " ",
+		bg: plan.clearBg
+	});
+	if (stickyForceRefresh && clearHeight > 0) buffer.fill(contentX, clearY, contentWidth, clearHeight, {
+		char: " ",
+		bg: null
+	});
+	const childAncestorLayoutChanged = isCurrentEpoch(node.layoutChangedThisFrame) || !!ancestorLayoutChanged;
+	const prevVisTop = ss.prevOffset ?? ss.offset;
+	const prevVisBottom = prevVisTop + ss.viewportHeight;
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (!child) continue;
+		if (child.props.position === "sticky") continue;
+		if (i < ss.firstVisibleChild || i > ss.lastVisibleChild) continue;
+		let thisChildHasPrev = defaultChildHasPrev;
+		let thisChildAncestorCleared = defaultChildAncestorCleared;
+		if (tier === "shift") {
+			const childRect = child.boxRect;
+			if (childRect) {
+				const childTop = childRect.y - layout.y - border.top - padding.top;
+				const childBottom = childTop + childRect.height;
+				const wasFullyVisible = childTop >= prevVisTop && childBottom <= prevVisBottom;
+				thisChildHasPrev = wasFullyVisible;
+				thisChildAncestorCleared = wasFullyVisible ? ancestorCleared || contentRegionCleared : true;
+			}
+		}
+		if (stickyForceRefresh && thisChildHasPrev) {
+			thisChildHasPrev = false;
+			thisChildAncestorCleared = false;
+		}
+		if (canSkipChildSubtree(child, thisChildHasPrev, childAncestorLayoutChanged)) continue;
+		renderNodeToBuffer(child, buffer, {
+			scrollOffset: ss.offset,
+			clipBounds: childClipBounds,
+			hasPrevBuffer: thisChildHasPrev,
+			ancestorCleared: thisChildAncestorCleared,
+			bufferIsCloned,
+			ancestorLayoutChanged: childAncestorLayoutChanged,
+			inheritedBg,
+			inheritedFg
+		}, ctx);
+	}
+	if (ss.stickyChildren) for (const sticky of ss.stickyChildren) {
+		const child = node.children[sticky.index];
+		if (!child?.boxRect) continue;
+		renderNodeToBuffer(child, buffer, {
+			scrollOffset: sticky.naturalTop - sticky.renderOffset,
+			clipBounds: childClipBounds,
+			hasPrevBuffer: false,
+			ancestorCleared: false,
+			bufferIsCloned,
+			ancestorLayoutChanged: childAncestorLayoutChanged,
+			inheritedBg,
+			inheritedFg
+		}, ctx);
+	}
+}
+/**
+* Render children of a normal (non-scroll) container.
+*/
+function renderNormalChildren(node, buffer, props, nodeState, childPositionChanged = false, contentRegionCleared = false, childrenNeedFreshRender = false, ctx) {
+	const { scrollOffset, clipBounds, hasPrevBuffer, ancestorCleared, bufferIsCloned, ancestorLayoutChanged, inheritedBg, inheritedFg } = nodeState;
+	const instr = resolveInstrumentation(ctx);
+	const layout = node.boxRect;
+	if (!layout) return;
+	const clipX = (props.overflowX ?? props.overflow) === "hidden";
+	const clipY = (props.overflowY ?? props.overflow) === "hidden";
+	const effectiveClipBounds = clipX || clipY ? computeChildClipBounds(layout, props, clipBounds, scrollOffset, clipX, clipY) : clipBounds;
+	const hasStickyChildren = !!(node.stickyChildren && node.stickyChildren.length > 0);
+	const stickyForceRefresh = hasStickyChildren && hasPrevBuffer;
+	if (stickyForceRefresh) {
+		const border = props.borderStyle ? getBorderSize(props) : {
+			top: 0,
+			bottom: 0,
+			left: 0,
+			right: 0
+		};
+		const padding = getPadding(props);
+		let clearX = layout.x + border.left + padding.left;
+		let clearY = layout.y - scrollOffset + border.top + padding.top;
+		let clearW = layout.width - border.left - border.right - padding.left - padding.right;
+		let clearH = layout.height - border.top - border.bottom - padding.top - padding.bottom;
+		if (clipBounds) {
+			const clipTop = clipBounds.top;
+			const clipBottom = clipBounds.bottom;
+			if (clearY < clipTop) {
+				clearH -= clipTop - clearY;
+				clearY = clipTop;
+			}
+			if (clearY + clearH > clipBottom) clearH = clipBottom - clearY;
+			if (clipBounds.left !== void 0 && clearX < clipBounds.left) {
+				clearW -= clipBounds.left - clearX;
+				clearX = clipBounds.left;
+			}
+			if (clipBounds.right !== void 0 && clearX + clearW > clipBounds.right) clearW = clipBounds.right - clearX;
+		}
+		if (clearW > 0 && clearH > 0) buffer.fill(clearX, clearY, clearW, clearH, {
+			char: " ",
+			bg: null
+		});
+	}
+	const childrenNeedRepaint = isDirty(node.dirtyBits, node.dirtyEpoch, 8) || childPositionChanged || childrenNeedFreshRender;
+	if (instr.enabled && childrenNeedRepaint && hasPrevBuffer) {
+		instr.stats.normalChildrenRepaint++;
+		const reasons = [];
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 8)) reasons.push("childrenDirty");
+		if (childPositionChanged) reasons.push("childPositionChanged");
+		if (childrenNeedFreshRender) reasons.push("childrenNeedFreshRender");
+		instr.stats.normalRepaintReason = reasons.join("+");
+	}
+	let childHasPrev = childrenNeedRepaint ? false : hasPrevBuffer;
+	let childAncestorCleared = contentRegionCleared || ancestorCleared && !getEffectiveBg(props);
+	const childAncestorLayoutChanged = isCurrentEpoch(node.layoutChangedThisFrame) || !!ancestorLayoutChanged;
+	if (stickyForceRefresh) {
+		childHasPrev = false;
+		childAncestorCleared = false;
+	}
+	let hasAbsoluteChildren = false;
+	for (const child of node.children) {
+		const childProps = child.props;
+		if (childProps.position === "absolute") {
+			hasAbsoluteChildren = true;
+			continue;
+		}
+		if (hasStickyChildren && childProps.position === "sticky") continue;
+		if (canSkipChildSubtree(child, childHasPrev, childAncestorLayoutChanged)) continue;
+		renderNodeToBuffer(child, buffer, {
+			scrollOffset,
+			clipBounds: effectiveClipBounds,
+			hasPrevBuffer: childHasPrev,
+			ancestorCleared: childAncestorCleared,
+			bufferIsCloned,
+			ancestorLayoutChanged: childAncestorLayoutChanged,
+			inheritedBg,
+			inheritedFg
+		}, ctx);
+	}
+	if (node.stickyChildren) for (const sticky of node.stickyChildren) {
+		const child = node.children[sticky.index];
+		if (!child?.boxRect) continue;
+		renderNodeToBuffer(child, buffer, {
+			scrollOffset: sticky.naturalTop - sticky.renderOffset,
+			clipBounds: effectiveClipBounds,
+			hasPrevBuffer: false,
+			ancestorCleared: false,
+			bufferIsCloned,
+			ancestorLayoutChanged: childAncestorLayoutChanged,
+			inheritedBg,
+			inheritedFg
+		}, ctx);
+	}
+	if (hasAbsoluteChildren) for (const child of node.children) {
+		if (child.props.position !== "absolute") continue;
+		renderNodeToBuffer(child, buffer, {
+			scrollOffset,
+			clipBounds: effectiveClipBounds,
+			hasPrevBuffer: false,
+			ancestorCleared: false,
+			bufferIsCloned,
+			ancestorLayoutChanged: childAncestorLayoutChanged,
+			inheritedBg,
+			inheritedFg
+		}, ctx);
+	}
+}
+/**
+* O(1) pre-check: can we skip calling renderNodeToBuffer() on this child entirely?
+*
+* This is the Phase 4 "dirty set rendering" optimization. Instead of calling
+* renderNodeToBuffer() on every child (which checks canSkipEntireSubtree and
+* returns early for clean nodes), we skip the function call entirely for
+* subtrees with no dirty descendants.
+*
+* The pre-check is CONSERVATIVE: it only skips when we're certain the subtree
+* is clean. False negatives (calling renderNodeToBuffer unnecessarily) are
+* harmless — the existing canSkipEntireSubtree check inside handles them.
+*
+* Key insight: subtreeDirtyEpoch is propagated from every dirty node to the
+* root by markSubtreeDirty (reconciler) and propagateLayout (layout phase).
+* If subtreeDirtyEpoch !== currentEpoch, no descendant is dirty. Combined
+* with layoutChangedThisFrame (set by layout phase but NOT included in
+* subtreeDirtyEpoch on self — only on parent), this covers all dirty paths.
+*/
+function canSkipChildSubtree(child, childHasPrev, childAncestorLayoutChanged) {
+	if (!childHasPrev) return false;
+	if (childAncestorLayoutChanged) return false;
+	if (isDirty(child.dirtyBits, child.dirtyEpoch, 16)) return false;
+	if (isCurrentEpoch(child.layoutChangedThisFrame)) return false;
+	if (child.scrollState && child.scrollState.offset !== child.scrollState.prevOffset) return false;
+	return true;
+}
+/**
+* Clear dirty flags on the current node only (no recursion).
+* Used after rendering a node to reset its flags.
+*
+* With epoch-stamped flags, this is only needed when a subtree is SKIPPED
+* by the fast path (clearDirtyFlags on skipped subtrees) or for the
+* render-phase-adapter. The normal render path relies on advanceRenderEpoch()
+* to expire all flags at once — O(1) instead of O(N).
+*/
+function clearNodeDirtyFlags(node) {
+	node.dirtyBits = 0;
+	node.dirtyEpoch = -1;
+	node.layoutChangedThisFrame = -1;
+}
+/**
+* Clear dirty flags on a subtree that was skipped during incremental rendering.
+*/
+function clearDirtyFlags(node) {
+	clearNodeDirtyFlags(node);
+	for (const child of node.children) if (child.layoutNode) clearDirtyFlags(child);
+	else clearVirtualTextFlags(child);
+}
+/**
+* Clear dirty flags on a virtual text node and its descendants.
+* Virtual text nodes (no layoutNode) are rendered by their parent layout
+* ancestor via collectTextContent(). Their dirty flags must be cleared
+* after the parent renders, otherwise stale subtreeDirty blocks
+* markSubtreeDirty() propagation on future updates.
+*/
+function clearVirtualTextFlags(node) {
+	clearNodeDirtyFlags(node);
+	for (const child of node.children) clearVirtualTextFlags(child);
+}
+/**
+* Check if any child's position changed since last render (sibling shift).
+* Checked even when subtreeDirty=true because subtreeDirty only means
+* descendants are dirty, not that this container's gap regions need clearing.
+*/
+function hasChildPositionChanged(node) {
+	for (const child of node.children) if (child.boxRect && child.prevLayout) {
+		if (child.boxRect.x !== child.prevLayout.x || child.boxRect.y !== child.prevLayout.y) return true;
+	}
+	return false;
+}
+/**
+* Check if any descendant has an explicit backgroundColor.
+*
+* Used by the bgOnlyChange fast path: fillBg() updates ALL cells in the region
+* with the parent's bg. If a descendant has its own bg, those cells would be
+* incorrectly overwritten (the descendant is clean and won't re-render to fix it).
+*
+* Only checks Box nodes with explicit backgroundColor or effective bg from theme.
+* Text nodes with backgroundColor are also checked since they render their own bg.
+* Stops at first match (early exit).
+*
+* Performance: walks the child tree, but only runs when bgOnlyChange is true
+* (bg changed, no other flags). This is the cursor-move hot path where trees
+* are typically small (card contents: ~5-20 nodes).
+*/
+function hasDescendantWithBg(node) {
+	for (const child of node.children) {
+		if (getEffectiveBg(child.props)) return true;
+		if (child.children.length > 0 && hasDescendantWithBg(child)) return true;
+	}
+	return false;
+}
+/**
+* Compute clip bounds for a container's children by insetting for border+padding,
+* then intersecting with parent clip bounds.
+*/
+function computeChildClipBounds(layout, props, parentClip, scrollOffset = 0, horizontal = true, vertical = true) {
+	const border = props.borderStyle ? getBorderSize(props) : {
+		top: 0,
+		bottom: 0,
+		left: 0,
+		right: 0
+	};
+	const padding = getPadding(props);
+	const adjustedY = layout.y - scrollOffset;
+	const nodeClip = vertical ? {
+		top: adjustedY + border.top + padding.top,
+		bottom: adjustedY + layout.height - border.bottom - padding.bottom
+	} : {
+		top: -Infinity,
+		bottom: Infinity
+	};
+	if (horizontal) {
+		nodeClip.left = layout.x + border.left + padding.left;
+		nodeClip.right = layout.x + layout.width - border.right - padding.right;
+	}
+	if (!parentClip) return nodeClip;
+	const result = {
+		top: vertical ? Math.max(parentClip.top, nodeClip.top) : parentClip.top,
+		bottom: vertical ? Math.min(parentClip.bottom, nodeClip.bottom) : parentClip.bottom
+	};
+	if (horizontal && nodeClip.left !== void 0 && nodeClip.right !== void 0) {
+		result.left = Math.max(parentClip.left ?? 0, nodeClip.left);
+		result.right = Math.min(parentClip.right ?? Infinity, nodeClip.right);
+	} else if (parentClip.left !== void 0 && parentClip.right !== void 0) {
+		result.left = parentClip.left;
+		result.right = parentClip.right;
+	}
+	return result;
+}
+/**
+* Clear overflow regions: areas where children's prevLayouts extended beyond
+* this node's rect. Called when childOverflowChanged detected stale overflow.
+*
+* clearNodeRegion handles the node's own rect. This function handles the
+* overflow area — pixels that a child rendered OUTSIDE the parent's rect
+* in a previous frame (via overflow:visible behavior). When the child shrinks,
+* those pixels become stale in the cloned buffer.
+*
+* Clears each child's overflow extent, clipped to buffer bounds.
+*/
+/**
+* Clear areas where descendants' previous layouts overflowed beyond THIS node's rect.
+* Only clears OUTSIDE the node's rect — interior clearing is handled by clearNodeRegion
+* and renderBox. Recursive: follows subtreeDirty paths to find all overflowing descendants.
+*/
+function clearDescendantOverflowRegions(node, buffer, layout, scrollOffset, clipBounds, threadedInheritedBg) {
+	const clearBg = threadedInheritedBg.color;
+	const nodeRight = layout.x + layout.width;
+	const nodeBottom = layout.y - scrollOffset + layout.height;
+	const nodeLeft = layout.x;
+	const nodeTop = layout.y - scrollOffset;
+	_clearDescendantOverflow(node.children, buffer, nodeLeft, nodeTop, nodeRight, nodeBottom, scrollOffset, clipBounds, clearBg);
+}
+function _clearDescendantOverflow(children, buffer, nodeLeft, nodeTop, nodeRight, nodeBottom, scrollOffset, clipBounds, clearBg) {
+	for (const child of children) {
+		if (child.prevLayout && isCurrentEpoch(child.layoutChangedThisFrame)) {
+			const prev = child.prevLayout;
+			const prevRight = prev.x + prev.width;
+			const prevBottom = prev.y - scrollOffset + prev.height;
+			const prevTop = prev.y - scrollOffset;
+			if (prevRight > nodeRight) {
+				const overflowX = nodeRight;
+				const overflowWidth = Math.min(prevRight, buffer.width) - overflowX;
+				const overflowTop = Math.max(prevTop, clipBounds?.top ?? 0);
+				const overflowBottom = Math.min(prevBottom, clipBounds?.bottom ?? buffer.height);
+				if (overflowWidth > 0 && overflowBottom > overflowTop) buffer.fill(overflowX, overflowTop, overflowWidth, overflowBottom - overflowTop, {
+					char: " ",
+					bg: clearBg
+				});
+			}
+			if (prevBottom > nodeBottom) {
+				const overflowTop = Math.max(nodeBottom, clipBounds?.top ?? 0);
+				const overflowBottom = Math.min(prevBottom, clipBounds?.bottom ?? buffer.height);
+				const overflowX = Math.max(prev.x, clipBounds?.left ?? 0);
+				const overflowWidth = Math.min(prevRight, clipBounds?.right ?? buffer.width) - overflowX;
+				if (overflowWidth > 0 && overflowBottom > overflowTop) buffer.fill(overflowX, overflowTop, overflowWidth, overflowBottom - overflowTop, {
+					char: " ",
+					bg: clearBg
+				});
+			}
+			if (prev.x < nodeLeft) {
+				const overflowX = Math.max(prev.x, 0);
+				const overflowWidth = Math.min(nodeLeft, buffer.width) - overflowX;
+				const overflowTop = Math.max(prevTop, clipBounds?.top ?? 0);
+				const overflowBottom = Math.min(prevBottom, clipBounds?.bottom ?? buffer.height);
+				if (overflowWidth > 0 && overflowBottom > overflowTop) buffer.fill(overflowX, overflowTop, overflowWidth, overflowBottom - overflowTop, {
+					char: " ",
+					bg: clearBg
+				});
+			}
+			if (prevTop < nodeTop) {
+				const overflowTop = Math.max(prevTop, clipBounds?.top ?? 0);
+				const overflowBottom = Math.min(nodeTop, clipBounds?.bottom ?? buffer.height);
+				const overflowX = Math.max(prev.x, clipBounds?.left ?? 0);
+				const overflowWidth = Math.min(prevRight, clipBounds?.right ?? buffer.width) - overflowX;
+				if (overflowWidth > 0 && overflowBottom > overflowTop) buffer.fill(overflowX, overflowTop, overflowWidth, overflowBottom - overflowTop, {
+					char: " ",
+					bg: clearBg
+				});
+			}
+		}
+		if (isDirty(child.dirtyBits, child.dirtyEpoch, 16) && child.children !== void 0) _clearDescendantOverflow(child.children, buffer, nodeLeft, nodeTop, nodeRight, nodeBottom, scrollOffset, clipBounds, clearBg);
+	}
+}
+/**
+* Clear a node's region with inherited bg when it has no backgroundColor.
+* Also clears excess area when the node shrank (previous layout was larger).
+*
+* Clipping: clips to parent's boxRect (prevents overflow) and to the
+* colored ancestor's bounds (prevents bg color bleeding into siblings).
+*/
+function clearNodeRegion(node, buffer, layout, scrollOffset, clipBounds, layoutChanged, threadedInheritedBg) {
+	const inherited = threadedInheritedBg;
+	const clearBg = inherited.color;
+	const screenY = layout.y - scrollOffset;
+	const parentRect = node.parent?.boxRect;
+	const parentBottom = parentRect ? parentRect.y - scrollOffset + parentRect.height : void 0;
+	const clearY = clipBounds ? Math.max(screenY, clipBounds.top) : screenY;
+	let clearBottom = clipBounds ? Math.min(screenY + layout.height, clipBounds.bottom) : screenY + layout.height;
+	if (parentBottom !== void 0) clearBottom = Math.min(clearBottom, parentBottom);
+	let clearX = layout.x;
+	let clearWidth = layout.width;
+	if (clipBounds?.left !== void 0 && clipBounds.right !== void 0) {
+		if (clearX < clipBounds.left) {
+			clearWidth -= clipBounds.left - clearX;
+			clearX = clipBounds.left;
+		}
+		if (clearX + clearWidth > clipBounds.right) clearWidth = Math.max(0, clipBounds.right - clearX);
+	}
+	if (inherited.ancestorRect) {
+		const ancestorRight = inherited.ancestorRect.x + inherited.ancestorRect.width;
+		const ancestorLeft = inherited.ancestorRect.x;
+		if (clearX < ancestorLeft) {
+			clearWidth -= ancestorLeft - clearX;
+			clearX = ancestorLeft;
+		}
+		if (clearX + clearWidth > ancestorRight) clearWidth = Math.max(0, ancestorRight - clearX);
+	}
+	const clearHeight = clearBottom - clearY;
+	if (clearHeight > 0 && clearWidth > 0) {
+		const _cellDbg2 = getCellDebug();
+		if (_cellDbg2 && cellCoversPoint(_cellDbg2, clearX, clearY, clearWidth, clearHeight)) {
+			const msg = `CLEAR_REGION ${node.props.id ?? node.type} fill=${clearX},${clearY} ${clearWidth}x${clearHeight} bg=${String(clearBg)} COVERS TARGET`;
+			_cellDbg2.log.push(msg);
+			cellLog.debug?.(msg);
+		}
+		buffer.fill(clearX, clearY, clearWidth, clearHeight, {
+			char: " ",
+			bg: clearBg
+		});
+	}
+	clearExcessArea(node, buffer, layout, scrollOffset, clipBounds, layoutChanged, inherited);
+}
+/**
+* Clear the excess area when a node shrinks (old bounds were larger than new).
+*
+* This is separated from clearNodeRegion because excess area clearing must happen
+* even when contentRegionCleared is false. Key scenario: absolute-positioned overlays
+* (e.g., search dialog) that shrink while normal-flow siblings are dirty. The
+* forceRepaint path sets hasPrevBuffer=false + ancestorCleared=false, making
+* contentRegionCleared=false — but the cloned buffer still has stale pixels from
+* the old larger layout that must be cleared.
+*
+* Clips to the COLORED ANCESTOR's content area (not immediate parent's full rect)
+* to prevent inherited color from bleeding into sibling areas with different bg.
+*
+* IMPORTANT: Uses content area (inside border/padding), not full boxRect.
+* Without this, excess clearing of a child that previously filled the parent's
+* content area will extend into the parent's border row, overwriting border chars.
+*/
+function clearExcessArea(node, buffer, layout, scrollOffset, clipBounds, layoutChanged, inherited) {
+	if (!layoutChanged || !node.prevLayout) return;
+	const prev = node.prevLayout;
+	const _cellDbg3 = getCellDebug();
+	const _prevCoversCell3 = _cellDbg3 && cellCoversPoint(_cellDbg3, prev.x, prev.y - scrollOffset, prev.width, prev.height);
+	if (prev.width <= layout.width && prev.height <= layout.height) {
+		if (_cellDbg3 && _prevCoversCell3) {
+			const msg = `EXCESS_SKIP_NO_SHRINK ${node.props.id ?? node.type} prev=${prev.x},${prev.y - scrollOffset} ${prev.width}x${prev.height} now=${layout.x},${layout.y - scrollOffset} ${layout.width}x${layout.height}`;
+			_cellDbg3.log.push(msg);
+			cellLog.debug?.(msg);
+		}
+		return;
+	}
+	if (prev.x !== layout.x || prev.y !== layout.y) {
+		if (_cellDbg3 && _prevCoversCell3) {
+			const msg = `EXCESS_SKIP_MOVED ${node.props.id ?? node.type} prev=${prev.x},${prev.y - scrollOffset} ${prev.width}x${prev.height} now=${layout.x},${layout.y - scrollOffset} ${layout.width}x${layout.height} (dx=${layout.x - prev.x} dy=${layout.y - prev.y})`;
+			_cellDbg3.log.push(msg);
+			cellLog.debug?.(msg);
+		}
+		return;
+	}
+	const clearBg = inherited.color;
+	const screenY = layout.y - scrollOffset;
+	const prevScreenY = prev.y - scrollOffset;
+	const clipRect = inherited.ancestorRect ?? node.parent?.boxRect;
+	if (!clipRect) return;
+	let clipRectBottom = clipRect.y - scrollOffset + clipRect.height;
+	let clipRectRight = clipRect.x + clipRect.width;
+	const parent = node.parent;
+	if (parent?.boxRect) {
+		const parentProps = parent.props;
+		const border = getBorderSize(parentProps);
+		const padding = getPadding(parentProps);
+		const parentRight = parent.boxRect.x + parent.boxRect.width - border.right - padding.right;
+		const parentBottom = parent.boxRect.y - scrollOffset + parent.boxRect.height - border.bottom - padding.bottom;
+		clipRectRight = Math.min(clipRectRight, parentRight);
+		clipRectBottom = Math.min(clipRectBottom, parentBottom);
+	}
+	if (prev.width > layout.width) {
+		const excessX = layout.x + layout.width;
+		let excessWidth = prev.width - layout.width;
+		if (excessX + excessWidth > clipRectRight) excessWidth = Math.max(0, clipRectRight - excessX);
+		if (excessWidth > 0) clippedFill(buffer, excessX, excessWidth, prevScreenY, prevScreenY + prev.height, clipBounds, clipRectBottom, clearBg);
+	}
+	if (prev.height > layout.height) {
+		let bottomWidth = prev.width;
+		if (layout.x + bottomWidth > clipRectRight) bottomWidth = Math.max(0, clipRectRight - layout.x);
+		clippedFill(buffer, layout.x, bottomWidth, screenY + layout.height, prevScreenY + prev.height, clipBounds, clipRectBottom, clearBg);
+	}
+}
+/** Fill a rectangular region, clipping to clipBounds and an outer bottom limit. */
+function clippedFill(buffer, x, width, top, bottom, clipBounds, outerBottom, bg) {
+	const clippedTop = clipBounds ? Math.max(top, clipBounds.top) : top;
+	const clippedBottom = Math.min(clipBounds ? Math.min(bottom, clipBounds.bottom) : bottom, outerBottom);
+	let clippedX = x;
+	let clippedWidth = width;
+	if (clipBounds?.left !== void 0 && clipBounds.right !== void 0) {
+		if (clippedX < clipBounds.left) {
+			clippedWidth -= clipBounds.left - clippedX;
+			clippedX = clipBounds.left;
+		}
+		if (clippedX + clippedWidth > clipBounds.right) clippedWidth = Math.max(0, clipBounds.right - clippedX);
+	}
+	const height = clippedBottom - clippedTop;
+	if (height > 0 && clippedWidth > 0) buffer.fill(clippedX, clippedTop, clippedWidth, height, {
+		char: " ",
+		bg
+	});
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region packages/ag-term/src/ag.ts
+/**
+* Ag — tree + layout engine + renderer.
+*
+* Decomposes the opaque executeRender() into two independent phases:
+* - ag.layout(dims) — measure + flexbox → positions/sizes
+* - ag.render() — positioned tree → cell grid → TextFrame
+*
+* The output phase (buffer → ANSI) is NOT part of ag — it lives in term.paint().
+*
+* @example
+* ```ts
+* const ag = createAg(root, { measurer })
+* ag.layout({ cols: 80, rows: 24 })
+* const { frame, buffer } = ag.render()
+* const output = term.paint(buffer, prevBuffer)
+* ```
+*/
+init_buffer();
+const log$1 = createLogger("silvery:render");
+const baseLog$1 = createLogger("@silvery/ag-react");
+function createAg(root, options) {
+	const measurer = options?.measurer;
+	const ctx = measurer ? { measurer } : void 0;
+	let _prevBuffer = null;
+	let hasScroll = false;
+	let hasSticky = false;
+	function doLayout(cols, rows, opts) {
+		try {
+			var _usingCtx$2 = _usingCtx();
+			const prevRootLayout = root.boxRect;
+			if (!(prevRootLayout && (prevRootLayout.width !== cols || prevRootLayout.height !== rows)) && !hasLayoutDirty() && !hasScrollDirty()) {
+				log$1.debug?.("layout: skipped (no layoutDirty, no scrollDirty, dimensions unchanged)");
+				return {
+					tMeasure: 0,
+					tLayout: 0,
+					tScroll: 0,
+					tScrollRect: 0,
+					tNotify: 0
+				};
+			}
+			const render = _usingCtx$2.u(baseLog$1.span("pipeline", {
+				width: cols,
+				height: rows
+			}));
+			let tMeasure;
+			try {
+				var _usingCtx3 = _usingCtx();
+				_usingCtx3.u(render.span("measure"));
+				const t = performance.now();
+				measurePhase(root, ctx);
+				tMeasure = performance.now() - t;
+				log$1.debug?.(`measure: ${tMeasure.toFixed(2)}ms`);
+			} catch (_) {
+				_usingCtx3.e = _;
+			} finally {
+				_usingCtx3.d();
+			}
+			let tLayout;
+			try {
+				var _usingCtx4 = _usingCtx();
+				_usingCtx4.u(render.span("layout"));
+				const t = performance.now();
+				layoutPhase(root, cols, rows);
+				tLayout = performance.now() - t;
+				log$1.debug?.(`layout: ${tLayout.toFixed(2)}ms`);
+			} catch (_) {
+				_usingCtx4.e = _;
+			} finally {
+				_usingCtx4.d();
+			}
+			if (!hasScroll || !hasSticky) {
+				const features = detectPipelineFeatures(root);
+				if (features.hasScroll) hasScroll = true;
+				if (features.hasSticky) hasSticky = true;
+			}
+			let tScroll;
+			if (hasScroll) try {
+				var _usingCtx5 = _usingCtx();
+				_usingCtx5.u(render.span("scroll"));
+				const t = performance.now();
+				scrollPhase(root, { skipStateUpdates: opts?.skipScrollStateUpdates });
+				tScroll = performance.now() - t;
+			} catch (_) {
+				_usingCtx5.e = _;
+			} finally {
+				_usingCtx5.d();
+			}
+			else tScroll = 0;
+			if (hasSticky) stickyPhase(root);
+			let tScrollRect;
+			try {
+				var _usingCtx6 = _usingCtx();
+				_usingCtx6.u(render.span("scrollRect"));
+				const t = performance.now();
+				if (hasScroll || hasSticky) scrollrectPhase(root);
+				else scrollrectPhaseSimple(root);
+				tScrollRect = performance.now() - t;
+			} catch (_) {
+				_usingCtx6.e = _;
+			} finally {
+				_usingCtx6.d();
+			}
+			let tNotify = 0;
+			if (!opts?.skipLayoutNotifications) try {
+				var _usingCtx7 = _usingCtx();
+				_usingCtx7.u(render.span("notify"));
+				const t = performance.now();
+				notifyLayoutSubscribers(root);
+				tNotify = performance.now() - t;
+			} catch (_) {
+				_usingCtx7.e = _;
+			} finally {
+				_usingCtx7.d();
+			}
+			const acc = globalThis.__silvery_bench_phases;
+			if (acc) {
+				acc.measure += tMeasure;
+				acc.layout += tLayout;
+				acc.scroll += tScroll;
+				acc.scrollRect += tScrollRect;
+				acc.notify += tNotify;
+				acc.layoutTotal += tMeasure + tLayout + tScroll + tScrollRect + tNotify;
+			}
+			return {
+				tMeasure,
+				tLayout,
+				tScroll,
+				tScrollRect,
+				tNotify
+			};
+		} catch (_) {
+			_usingCtx$2.e = _;
+		} finally {
+			_usingCtx$2.d();
+		}
+	}
+	function doRender(opts) {
+		clearBgConflictWarnings();
+		const prevBuffer = opts?.fresh ? null : opts?.prevBuffer !== void 0 ? opts.prevBuffer : _prevBuffer;
+		let tContent;
+		let buffer;
+		{
+			const t = performance.now();
+			buffer = renderPhase(root, prevBuffer, ctx);
+			tContent = performance.now() - t;
+			log$1.debug?.(`content: ${tContent.toFixed(2)}ms`);
+		}
+		if (!opts?.fresh) _prevBuffer = buffer;
+		clearDirtyTracking();
+		const acc = globalThis.__silvery_bench_phases;
+		if (acc) {
+			acc.content += tContent;
+			acc.renderCalls += 1;
+		}
+		return {
+			frame: createTextFrame(buffer),
+			buffer,
+			prevBuffer,
+			tContent
+		};
+	}
+	function agCreateNode(type, props) {
+		return {
+			type,
+			props,
+			children: [],
+			parent: null,
+			layoutNode: getLayoutEngine().createNode(),
+			boxRect: null,
+			scrollRect: null,
+			screenRect: null,
+			prevLayout: null,
+			prevScrollRect: null,
+			prevScreenRect: null,
+			layoutChangedThisFrame: -1,
+			layoutDirty: true,
+			dirtyBits: 31,
+			dirtyEpoch: getRenderEpoch(),
+			layoutSubscribers: /* @__PURE__ */ new Set()
+		};
+	}
+	function agInsertChild(parent, child, index) {
+		if (child.parent) agRemoveChild(child.parent, child);
+		parent.children.splice(index, 0, child);
+		child.parent = parent;
+		if (parent.layoutNode && child.layoutNode) {
+			const layoutIndex = parent.children.slice(0, index).filter((c) => c.layoutNode !== null).length;
+			parent.layoutNode.insertChild(child.layoutNode, layoutIndex);
+		}
+	}
+	function agRemoveChild(parent, child) {
+		const index = parent.children.indexOf(child);
+		if (index === -1) return;
+		parent.children.splice(index, 1);
+		if (parent.layoutNode && child.layoutNode) {
+			parent.layoutNode.removeChild(child.layoutNode);
+			child.layoutNode.free();
+		}
+		child.parent = null;
+	}
+	return {
+		root,
+		layout(dims, options) {
+			if (measurer) runWithMeasurer(measurer, () => doLayout(dims.cols, dims.rows, options));
+			else doLayout(dims.cols, dims.rows, options);
+		},
+		render(options) {
+			const result = measurer ? runWithMeasurer(measurer, () => doRender(options)) : doRender(options);
+			return {
+				frame: result.frame,
+				buffer: result.buffer,
+				prevBuffer: result.prevBuffer
+			};
+		},
+		resetBuffer() {
+			_prevBuffer = null;
+		},
+		createNode: agCreateNode,
+		insertChild: agInsertChild,
+		removeChild: agRemoveChild,
+		updateProps(node, props, oldProps) {
+			node.props = props;
+			if (node.layoutNode) node.layoutNode.markDirty();
+		},
+		setText(node, text) {
+			node.textContent = text;
+			const epoch = getRenderEpoch();
+			const bits = 3;
+			node.dirtyBits = node.dirtyEpoch !== epoch ? bits : node.dirtyBits | bits;
+			node.dirtyEpoch = epoch;
+			if (node.layoutNode) node.layoutNode.markDirty();
+		},
+		toString() {
+			return `[Ag root=${root.type} children=${root.children.length}]`;
+		}
+	};
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/index.ts
+/**
+* Silvery Render Pipeline
+*
+* The 5-phase rendering architecture:
+*
+* Phase 0: RECONCILIATION (React)
+*   React reconciliation builds the SilveryNode tree.
+*   Components register layout constraints via props.
+*
+* Phase 1: MEASURE (for fit-content nodes)
+*   Traverse nodes with width/height="fit-content"
+*   Measure intrinsic content size
+*   Set Yoga constraints based on measurement
+*
+* Phase 2: LAYOUT
+*   Run yoga.calculateLayout()
+*   Propagate computed dimensions to all nodes
+*   Notify useBoxRect() subscribers
+*
+* Phase 3: CONTENT RENDER
+*   Render each node to the TerminalBuffer
+*   Handle text truncation, styling, borders
+*
+* Phase 4: DIFF & OUTPUT
+*   Compare current buffer with previous
+*   Emit minimal ANSI sequences for changes
+*/
+const log = createLogger("silvery:render");
+createLogger("@silvery/ag-react");
+/**
+* Execute the full render pipeline.
+*
+* Pass null for prevBuffer on the first render; pass the returned buffer on
+* subsequent renders to enable incremental content rendering (<1ms vs 20-30ms).
+* SILVERY_DEV=1 warns at runtime if prevBuffer is null after the first frame.
+*/
+function executeRender(root, width, height, prevBuffer, options = "fullscreen", config) {
+	if (config?.measurer) return runWithMeasurer(config.measurer, () => {
+		return executeRenderCore(root, width, height, prevBuffer, options, config);
+	});
+	return executeRenderCore(root, width, height, prevBuffer, options, config);
+}
+/** Internal: runs the full pipeline, delegating layout + render to createAg. */
+function executeRenderCore(root, width, height, prevBuffer, options = "fullscreen", config) {
+	const { mode = "fullscreen", skipLayoutNotifications = false, skipScrollStateUpdates = false, scrollbackOffset = 0, termRows, cursorPos } = typeof options === "string" ? { mode: options } : options;
+	if (process?.env?.SILVERY_DEV && prevBuffer === null && root.prevLayout !== null && !skipLayoutNotifications) log.warn?.("executeRender called with prevBuffer=null on frame 2+ — incremental content rendering is disabled (full render every frame). Track the returned buffer and pass it as prevBuffer on subsequent renders.");
+	const start = performance.now();
+	const ag = createAg(root, { measurer: config?.measurer });
+	ag.layout({
+		cols: width,
+		rows: height
+	}, {
+		skipLayoutNotifications,
+		skipScrollStateUpdates
+	});
+	const { buffer } = ag.render({ prevBuffer });
+	const tLayout = performance.now() - start;
+	let output;
+	let tOutput;
+	{
+		const t4 = performance.now();
+		const outputFn = config?.outputPhaseFn ?? outputPhase;
+		try {
+			output = outputFn(prevBuffer, buffer, mode, scrollbackOffset, termRows, cursorPos);
+		} catch (e) {
+			if (e instanceof Error) e.__silvery_buffer = buffer;
+			throw e;
+		}
+		tOutput = performance.now() - t4;
+		log.debug?.(`output: ${tOutput.toFixed(2)}ms (${output.length} bytes)`);
+	}
+	const total = performance.now() - start;
+	globalThis.__silvery_last_pipeline = {
+		layout: tLayout,
+		output: tOutput,
+		total,
+		incremental: prevBuffer !== null
+	};
+	globalThis.__silvery_render_count = (globalThis.__silvery_render_count ?? 0) + 1;
+	const acc = globalThis.__silvery_bench_phases;
+	if (acc) {
+		acc.output += tOutput;
+		acc.total += total;
+		acc.pipelineCalls += 1;
+	}
+	log.debug?.(`pipeline: layout+render=${tLayout.toFixed(1)}ms output=${tOutput.toFixed(1)}ms total=${total.toFixed(1)}ms`);
+	return {
+		output,
+		buffer
+	};
+}
+//#endregion
+export { signal as i, createAg as n, _usingCtx as r, executeRender as t };
+
+//# sourceMappingURL=pipeline-DDOPrjuY.mjs.map