@garygentry/feature-forge 0.2.14 → 0.3.1

package/adapters/pi/extensions/ask-user-question/view/components/preview/markdown-content-cache.ts

@@ -0,0 +1,79 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/components/preview/markdown-content-cache.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Markdown, type MarkdownTheme, visibleWidth } from "@earendil-works/pi-tui";
+import { t } from "../../../state/i18n-bridge.js";
+import type { QuestionData } from "../../../tool/types.js";
+import { stripFenceMarkers } from "./preview-box-renderer.js";
+
+/** CC parity in side-by-side layout. */
+export const MAX_PREVIEW_HEIGHT_SIDE_BY_SIDE = 20;
+/** Preserves narrow-terminal protection in stacked layout. */
+export const MAX_PREVIEW_HEIGHT_STACKED = 15;
+export const NO_PREVIEW_TEXT = "No preview available";
+/** 1 blank separator + 1 affordance text row reserved when `hasAnyPreview` (height stability of the affordance row's offset relative to the box). */
+export const NOTES_AFFORDANCE_OVERHEAD = 2;
+
+/**
+ * Per-question cache for rendered markdown previews. Width-keyed: switching the
+ * inner width invalidates every cached `Markdown`'s render output (pi-tui's
+ * `Markdown.render(width)` re-wraps when width changes).
+ *
+ * Replaces the inline `previewTexts`, `markdownCache`, `cachedWidth` triple from
+ * the previous monolithic `preview-pane.ts`. One Markdown per option, lazy on
+ * first request, never re-constructed — count semantics frozen by tests.
+ */
+export class MarkdownContentCache {
+	private readonly previewTexts: Map<number, string>;
+	private readonly markdownCache: Map<number, Markdown>;
+	private cachedWidth: number | undefined;
+	private readonly theme: Theme;
+	private readonly markdownTheme: MarkdownTheme;
+
+	constructor(question: QuestionData, theme: Theme, markdownTheme: MarkdownTheme) {
+		this.theme = theme;
+		this.markdownTheme = markdownTheme;
+		this.previewTexts = new Map();
+		for (let i = 0; i < question.options.length; i++) {
+			const raw = question.options[i]?.preview;
+			if (raw && raw.length > 0) this.previewTexts.set(i, raw);
+		}
+		this.markdownCache = new Map();
+	}
+
+	hasAnyPreview(): boolean {
+		return this.previewTexts.size > 0;
+	}
+
+	has(optionIndex: number): boolean {
+		return this.previewTexts.has(optionIndex);
+	}
+
+	/**
+	 * Compute the body lines for a given option at a given inner width. Width changes
+	 * invalidate the per-Markdown render cache.
+	 */
+	bodyFor(optionIndex: number, innerWidth: number): string[] {
+		if (this.cachedWidth !== innerWidth) {
+			for (const md of this.markdownCache.values()) md.invalidate();
+			this.cachedWidth = innerWidth;
+		}
+		const text = this.previewTexts.get(optionIndex);
+		if (!text) {
+			const placeholder = this.theme.fg("dim", t("preview.no_preview", NO_PREVIEW_TEXT));
+			const pad = Math.max(0, innerWidth - visibleWidth(placeholder));
+			return [placeholder + " ".repeat(pad)];
+		}
+		let md = this.markdownCache.get(optionIndex);
+		if (!md) {
+			md = new Markdown(text, 0, 0, this.markdownTheme);
+			this.markdownCache.set(optionIndex, md);
+		}
+		return stripFenceMarkers(md.render(innerWidth));
+	}
+
+	invalidate(): void {
+		for (const md of this.markdownCache.values()) md.invalidate();
+		this.cachedWidth = undefined;
+	}
+}

package/adapters/pi/extensions/ask-user-question/view/components/preview/preview-block-renderer.ts

@@ -0,0 +1,111 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/components/preview/preview-block-renderer.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { MarkdownTheme } from "@earendil-works/pi-tui";
+import { t } from "../../../state/i18n-bridge.js";
+import type { QuestionData } from "../../../tool/types.js";
+import {
+	MAX_PREVIEW_HEIGHT_SIDE_BY_SIDE,
+	MAX_PREVIEW_HEIGHT_STACKED,
+	MarkdownContentCache,
+	NOTES_AFFORDANCE_OVERHEAD,
+} from "./markdown-content-cache.js";
+import {
+	BORDER_HORIZONTAL_OVERHEAD,
+	BORDER_INNER_PADDING_HORIZONTAL,
+	BORDER_VERTICAL_OVERHEAD,
+	computeBoxDimensions,
+	renderBorderedBox,
+} from "./preview-box-renderer.js";
+import type { PreviewLayoutMode } from "./preview-layout-decider.js";
+
+/**
+ * Affordance text shown below the bordered preview when focused on a preview-bearing option.
+ * Re-exported by `preview-pane.ts` for the existing test surface.
+ */
+export const NOTES_AFFORDANCE_TEXT = "Notes: press n to add notes";
+
+export interface PreviewBlockRendererConfig {
+	question: QuestionData;
+	theme: Theme;
+	markdownTheme: MarkdownTheme;
+}
+
+/**
+ * Renders the bordered markdown preview block for a single question (one block per render call,
+ * for the option at `optionIndex`). Owns a per-question `MarkdownContentCache`.
+ *
+ * NOT a `Component` — pure render-and-measure helper consumed by `PreviewPane`. The layout mode
+ * is threaded as an explicit param (never re-derived from column width post-split).
+ *
+ * The affordance row is always emitted (visually empty when gated) so the preview block's row
+ * count is height-stable across affordance-state transitions.
+ */
+export class PreviewBlockRenderer {
+	private readonly theme: Theme;
+	private readonly cache: MarkdownContentCache;
+
+	constructor(config: PreviewBlockRendererConfig) {
+		this.theme = config.theme;
+		this.cache = new MarkdownContentCache(config.question, config.theme, config.markdownTheme);
+	}
+
+	hasAnyPreview(): boolean {
+		return this.cache.hasAnyPreview();
+	}
+
+	has(optionIndex: number): boolean {
+		return this.cache.has(optionIndex);
+	}
+
+	invalidate(): void {
+		this.cache.invalidate();
+	}
+
+	/**
+	 * Height contribution of the preview block: `BORDER_VERTICAL_OVERHEAD + contentRows +
+	 * NOTES_AFFORDANCE_OVERHEAD`. Always returns the same value as `renderBlock(...).length`
+	 * — the affordance overhead is constant, not gated by `focused`/`notesVisible`.
+	 */
+	blockHeight(width: number, optionIndex: number, mode: PreviewLayoutMode): number {
+		const cap = mode === "side-by-side" ? MAX_PREVIEW_HEIGHT_SIDE_BY_SIDE : MAX_PREVIEW_HEIGHT_STACKED;
+		const contentBudget = Math.max(1, cap - BORDER_VERTICAL_OVERHEAD - NOTES_AFFORDANCE_OVERHEAD);
+		const innerWidth = Math.max(1, width - BORDER_HORIZONTAL_OVERHEAD - 2 * BORDER_INNER_PADDING_HORIZONTAL);
+		const rawRows = this.cache.bodyFor(optionIndex, innerWidth).length;
+		const contentRows = Math.min(rawRows, contentBudget);
+		return BORDER_VERTICAL_OVERHEAD + contentRows + NOTES_AFFORDANCE_OVERHEAD;
+	}
+
+	/**
+	 * Render the full preview block at `width`: bordered box + blank separator + affordance row.
+	 * `focused` and `notesVisible` together gate the affordance text (visible only when the
+	 * focused option carries a preview AND notes mode is inactive). The affordance row is ALWAYS
+	 * emitted (as an empty string when gated) so the row count is invariant.
+	 */
+	renderBlock(
+		width: number,
+		optionIndex: number,
+		mode: PreviewLayoutMode,
+		focused: boolean,
+		notesVisible: boolean,
+	): string[] {
+		const cap = mode === "side-by-side" ? MAX_PREVIEW_HEIGHT_SIDE_BY_SIDE : MAX_PREVIEW_HEIGHT_STACKED;
+		const contentBudget = Math.max(1, cap - BORDER_VERTICAL_OVERHEAD - NOTES_AFFORDANCE_OVERHEAD);
+		const maxInnerWidth = Math.max(1, width - BORDER_HORIZONTAL_OVERHEAD - 2 * BORDER_INNER_PADDING_HORIZONTAL);
+
+		const raw = this.cache.bodyFor(optionIndex, maxInnerWidth);
+		const truncated = raw.length > contentBudget;
+		const hidden = truncated ? raw.length - contentBudget : 0;
+		const contentLines = truncated ? raw.slice(0, contentBudget) : raw;
+
+		const { boxWidth } = computeBoxDimensions(contentLines, maxInnerWidth);
+		const colorFn = (s: string) => this.theme.fg("accent", s);
+		const boxedLines = renderBorderedBox(contentLines, boxWidth, colorFn, hidden);
+
+		const showAffordance = focused && !notesVisible && this.cache.has(optionIndex);
+		const affordance = showAffordance
+			? this.theme.fg("muted", t("preview.notes_affordance", NOTES_AFFORDANCE_TEXT))
+			: "";
+		return [...boxedLines, "", affordance];
+	}
+}

package/adapters/pi/extensions/ask-user-question/view/components/preview/preview-box-renderer.ts

@@ -0,0 +1,88 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/components/preview/preview-box-renderer.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+const ANSI_SGR_RE = /\x1b\[[0-9;]*m/g;
+const ANSI_OSC8_RE = /\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)/g;
+const FENCE_MARKER_RE = /^`{3}/;
+
+/** Top + bottom border rows consumed by `renderBorderedBox`. */
+export const BORDER_VERTICAL_OVERHEAD = 2;
+/** Left + right vertical bar columns (`│ ... │`) consumed by `renderBorderedBox`. */
+export const BORDER_HORIZONTAL_OVERHEAD = 2;
+/** Inner horizontal padding (1 col) between each border bar and content area. */
+export const BORDER_INNER_PADDING_HORIZONTAL = 1;
+/** Floor for the preview box's inner content width — CC parity (`PreviewBox.minWidth`). */
+export const BOX_MIN_CONTENT_WIDTH = 40;
+
+/**
+ * Drops fenced-code-block marker lines (` ``` ` opener/closer) from rendered markdown.
+ * pi-tui's Markdown emits literal opening ` ```lang ` and closing ` ``` ` lines around
+ * code blocks; this strip leaves only the highlighted code body. Inline code
+ * (`codespan`) is unaffected — pi-tui already renders it without backticks.
+ */
+export function stripFenceMarkers(lines: readonly string[]): string[] {
+	return lines.filter((line) => {
+		const clean = line.replace(ANSI_SGR_RE, "").replace(ANSI_OSC8_RE, "");
+		return !FENCE_MARKER_RE.test(clean);
+	});
+}
+
+/**
+ * Wraps `lines` in a 4-sided ASCII border with 1 col of inner horizontal padding.
+ * Layout per content row: `│` + ` ` + content padded to `contentInner` + ` ` + `│`,
+ * where `contentInner = width - BORDER_HORIZONTAL_OVERHEAD - 2 * BORDER_INNER_PADDING_HORIZONTAL`.
+ * Top/bottom dash runs span corner-to-corner (`width - BORDER_HORIZONTAL_OVERHEAD`). When
+ * `hidden > 0`, the bottom-row dash run is replaced with ` ✂ ── N lines hidden ── ` (corners stay).
+ */
+export function renderBorderedBox(
+	lines: readonly string[],
+	width: number,
+	colorFn: (s: string) => string,
+	hidden = 0,
+): string[] {
+	const dashSpan = Math.max(1, width - BORDER_HORIZONTAL_OVERHEAD);
+	const contentInner = Math.max(1, dashSpan - 2 * BORDER_INNER_PADDING_HORIZONTAL);
+	const pad = " ".repeat(BORDER_INNER_PADDING_HORIZONTAL);
+	const top = colorFn(`┌${"─".repeat(dashSpan)}┐`);
+	const out: string[] = [top];
+	for (const line of lines) {
+		const padded = truncateToWidth(line, contentInner, "", true);
+		out.push(`${colorFn("│")}${pad}${padded}${pad}${colorFn("│")}`);
+	}
+	if (hidden > 0) {
+		const indicator = ` ✂ ── ${hidden} lines hidden ── `;
+		const space = dashSpan - indicator.length;
+		const leftFill = "─".repeat(Math.max(0, Math.floor(space / 2)));
+		const rightFill = "─".repeat(Math.max(0, dashSpan - leftFill.length - indicator.length));
+		out.push(colorFn(`└${leftFill}${indicator}${rightFill}┘`));
+	} else {
+		out.push(colorFn(`└${"─".repeat(dashSpan)}┘`));
+	}
+	return out;
+}
+
+/**
+ * Compute box dimensions from content lines. Pure of args.
+ *
+ * CC parity:
+ *   contentWidth = max(minWidth, widestRenderedLine)
+ *   boxWidth     = min(contentWidth + 4, effectiveMaxWidth)
+ *
+ * Trailing whitespace is stripped before measuring because pi-tui's
+ * `Markdown.render(width)` pads every line to `width`, which would otherwise force
+ * the box to fill the whole column allocation.
+ */
+export function computeBoxDimensions(
+	contentLines: readonly string[],
+	maxInnerWidth: number,
+): { innerWidth: number; boxWidth: number } {
+	let widest = Math.min(BOX_MIN_CONTENT_WIDTH, maxInnerWidth);
+	for (const line of contentLines) {
+		const w = visibleWidth(line.replace(/\s+$/, ""));
+		if (w > widest) widest = w;
+	}
+	const innerWidth = Math.min(widest, maxInnerWidth);
+	const boxWidth = innerWidth + BORDER_HORIZONTAL_OVERHEAD + 2 * BORDER_INNER_PADDING_HORIZONTAL;
+	return { innerWidth, boxWidth };
+}

package/adapters/pi/extensions/ask-user-question/view/components/preview/preview-layout-decider.ts

@@ -0,0 +1,202 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/components/preview/preview-layout-decider.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import { visibleWidth } from "@earendil-works/pi-tui";
+import type { QuestionData } from "../../../tool/types.js";
+import type { WrappingSelectItem } from "../wrapping-select.js";
+import { BORDER_HORIZONTAL_OVERHEAD, BORDER_INNER_PADDING_HORIZONTAL } from "./preview-box-renderer.js";
+
+/** Min terminal/pane width for the side-by-side layout to engage. */
+export const PREVIEW_MIN_WIDTH = 100;
+/** Visual gap between options column and preview column in side-by-side. */
+export const PREVIEW_COLUMN_GAP = 2;
+/** 1 col padding inside the preview column (between gap and `│`). */
+export const PREVIEW_PADDING_LEFT = 1;
+/** Empty rows between options and preview blocks in stacked (narrow) layout. */
+export const STACKED_GAP_ROWS = 1;
+
+/** Floor for the adaptive left column width — prevents collapse on short labels. */
+export const MIN_LEFT = 30;
+/** Ceiling ratio: left column never exceeds this fraction of pane width. */
+export const MAX_LEFT_RATIO = 0.5;
+/** Floor for the preview column width — prevents right-side collapse on narrow terminals. */
+export const MIN_PREVIEW_WIDTH = 45;
+/** visibleWidth(" ✔") = 2 (space + ✔ codepoint). Reserved on the longest-label measurement
+ *  so a confirmed row never gets truncated when MIN_LEFT clamps the column. */
+export const CONFIRMED_OVERHEAD = 2;
+
+export type PreviewLayoutMode = "side-by-side" | "stacked";
+
+/**
+ * Decide layout mode from terminal + pane widths. Pure of inputs.
+ *
+ * The terminal-width gate is the AND check from the previous `preview-pane.ts` —
+ * lifted here so the decision is computed ONCE per render and threaded explicitly
+ * through `previewBlockHeight`. Removes the bug class where `previewBlockHeight`
+ * re-derived `sideBySide` from a column width (already < pane width post-split),
+ * capping height too short.
+ */
+export function decideLayout(terminalWidth: number, paneWidth: number): PreviewLayoutMode {
+	return terminalWidth >= PREVIEW_MIN_WIDTH && paneWidth >= PREVIEW_MIN_WIDTH ? "side-by-side" : "stacked";
+}
+
+/**
+ * Compute the adaptive left column width from option labels.
+ * Pure function — deterministic for a given (items, totalForNumbering, paneWidth).
+ *
+ * Pipeline:
+ *   1. Measure: longest visible label width + prefix overhead + confirmed-mark overhead
+ *   2. Clamp: floor MIN_LEFT, ceiling paneWidth * MAX_LEFT_RATIO
+ *   3. Safety net: never exceed available = paneWidth - GAP - MIN_PREVIEW_WIDTH
+ */
+export function adaptiveLeftWidth(
+	items: readonly WrappingSelectItem[],
+	totalForNumbering: number,
+	paneWidth: number,
+): number {
+	const prefixW = String(Math.max(1, totalForNumbering)).length + 4; // digits + "❯ " + ". "
+	const confirmedOverhead = CONFIRMED_OVERHEAD; // visibleWidth(" ✔") = 2 (space + ✔ codepoint)
+	let maxLabel = 0;
+	for (const item of items) {
+		const w = visibleWidth(item.label);
+		if (w > maxLabel) maxLabel = w;
+	}
+	const desired = maxLabel + prefixW + confirmedOverhead;
+	const ratioCapped = Math.min(desired, Math.floor(paneWidth * MAX_LEFT_RATIO));
+	const available = paneWidth - PREVIEW_COLUMN_GAP - MIN_PREVIEW_WIDTH;
+	return Math.max(MIN_LEFT, Math.min(ratioCapped, Math.max(1, available)));
+}
+
+/**
+ * Cross-tab maximum left-column width. Aggregates `adaptiveLeftWidth` over every tab
+ * and returns the widest result, so the options column stays stable on tab switch.
+ *
+ * Pure function — `tabs.length` MUST equal `itemsByTab.length`. Numbering uses
+ * `items.length` for every tab (the chat row slot that once added +1 on single-select
+ * has been removed).
+ * Floor is `MIN_LEFT` so an all-empty input still produces a usable column.
+ */
+export function crossTabMaxLeftWidth(
+	tabs: ReadonlyArray<{ multiSelect?: boolean }>,
+	itemsByTab: ReadonlyArray<readonly WrappingSelectItem[]>,
+	paneWidth: number,
+): number {
+	let max = MIN_LEFT;
+	for (let i = 0; i < tabs.length; i++) {
+		const items = itemsByTab[i] ?? [];
+		const totalForNumbering = items.length;
+		const tabWidth = adaptiveLeftWidth(items, totalForNumbering, paneWidth);
+		if (tabWidth > max) max = tabWidth;
+	}
+	return max;
+}
+
+/**
+ * Source-line probe: measures the widest source line across all options' previews.
+ * Returns 0 when no option carries a preview.
+ *
+ * V1 heuristic — works well for tree/table/heading/list content where source-line
+ * width ≈ rendered width. Paragraphs overstate (source width "wants" the full pane);
+ * the worst case is "donation does nothing useful" — fallback to the label-driven path.
+ * Upgrade path: replace with a render-width probe that invokes Markdown at a probe width.
+ *
+ * Pure function — O(total chars) per question; no Markdown invocation, no cache interaction.
+ */
+export function previewSourceWidth(question: QuestionData): number {
+	let max = 0;
+	for (const option of question.options) {
+		const text = option.preview;
+		if (!text) continue;
+		for (const line of text.split("\n")) {
+			const w = visibleWidth(line);
+			if (w > max) max = w;
+		}
+	}
+	return max;
+}
+
+/**
+ * Cross-tab/cross-option preview budget. Iterates all questions, computes each question's
+ * preview appetite via `previewSourceWidth`, adds box + padding overhead (5 cols), and
+ * returns the widest result. Floor is `MIN_PREVIEW_WIDTH` so a previewless question still
+ * reserves a usable column. Ceiling ensures the left column retains its `MIN_LEFT` floor.
+ *
+ * Pure function — same cross-tab max pattern as `crossTabMaxLeftWidth`.
+ */
+export function crossTabPreviewBudget(questions: readonly QuestionData[], paneWidth: number): number {
+	let max = MIN_PREVIEW_WIDTH;
+	for (const question of questions) {
+		const rawWidth = previewSourceWidth(question);
+		const capped = Math.min(rawWidth, paneWidth - PREVIEW_COLUMN_GAP - MIN_LEFT);
+		const budget = capped + BORDER_HORIZONTAL_OVERHEAD + 2 * BORDER_INNER_PADDING_HORIZONTAL + PREVIEW_PADDING_LEFT;
+		if (budget > max) max = budget;
+	}
+	return max;
+}
+
+/**
+ * Cross-tab left-column width with slack donation. Combines the label-driven width
+ * (from `crossTabMaxLeftWidth`) with the slack donated by narrow previews.
+ *
+ * Pipeline:
+ *   1. `labelDriven` = `crossTabMaxLeftWidth(tabs, itemsByTab, paneWidth)`
+ *   2. `previewBudget` = `crossTabPreviewBudget(questions, paneWidth)`
+ *   3. `slackDonation` = `paneWidth − GAP − previewBudget`
+ *   4. Return `min(max(labelDriven, slackDonation), ceiling)` where `ceiling = paneWidth − GAP − MIN_PREVIEW_WIDTH`
+ *
+ * Invariants:
+ *   - Floor: result ≥ MIN_LEFT (labelDriven ≥ MIN_LEFT)
+ *   - Preview floor: right column ≥ MIN_PREVIEW_WIDTH (ceiling enforces this)
+ *   - Cross-tab stability: both reductions are tab-independent
+ *   - Determinism: pure of (questions, itemsByTab, paneWidth)
+ *
+ * `crossTabMaxLeftWidth` is NOT replaced — it continues to exist as the primitive.
+ * `MAX_LEFT_RATIO` caps the label-driven path inside `adaptiveLeftWidth`; donation
+ * operates above the cap when preview slack is available.
+ */
+export function crossTabLeftWidthWithDonation(
+	tabs: ReadonlyArray<{ multiSelect?: boolean }>,
+	itemsByTab: ReadonlyArray<readonly WrappingSelectItem[]>,
+	questions: readonly QuestionData[],
+	paneWidth: number,
+): number {
+	const labelDriven = crossTabMaxLeftWidth(tabs, itemsByTab, paneWidth);
+	// Compact-content guard: labels at MIN_LEFT fit below the floor, so widening
+	// the column would only inject dead space between the option list and the
+	// preview box. Skip donation and preserve the compact intent.
+	if (labelDriven <= MIN_LEFT) return labelDriven;
+	const previewBudget = crossTabPreviewBudget(questions, paneWidth);
+	const slackDonation = paneWidth - PREVIEW_COLUMN_GAP - previewBudget;
+	const ceiling = paneWidth - PREVIEW_COLUMN_GAP - MIN_PREVIEW_WIDTH;
+	return Math.min(Math.max(labelDriven, slackDonation), Math.max(1, ceiling));
+}
+
+/**
+ * Width allocation for side-by-side mode.
+ * `adaptiveLeft` is the pre-computed left column width (from `adaptiveLeftWidth`,
+ * cross-tab aggregated). The Math.max(1, ...) calls keep both columns >= 1 col on
+ * extreme inputs.
+ */
+export function columnWidths(
+	paneWidth: number,
+	adaptiveLeft: number,
+): { leftWidth: number; rightWidth: number; gap: number } {
+	const gap = PREVIEW_COLUMN_GAP;
+	const leftWidth = Math.min(adaptiveLeft, Math.max(1, paneWidth - gap - 1));
+	const rightWidth = Math.max(1, paneWidth - leftWidth - gap);
+	return { leftWidth, rightWidth, gap };
+}
+
+/**
+ * Returns the widths actually passed to `options.render` and `previewLines` inside
+ * `render()`. Stacked uses the full pane width for both; side-by-side splits via
+ * `columnWidths`, with the preview column offset by `PREVIEW_PADDING_LEFT`.
+ */
+export function bodyWidths(
+	paneWidth: number,
+	mode: PreviewLayoutMode,
+	adaptiveLeft: number,
+): { optionsWidth: number; previewWidth: number } {
+	if (mode === "stacked") return { optionsWidth: paneWidth, previewWidth: paneWidth };
+	const { leftWidth, rightWidth } = columnWidths(paneWidth, adaptiveLeft);
+	return { optionsWidth: leftWidth, previewWidth: Math.max(1, rightWidth - PREVIEW_PADDING_LEFT) };
+}