@oh-my-pi/pi-tui 18.7.0 → 18.8.0

package/src/overlays/usage-dashboard.ts

@@ -463,16 +463,14 @@ function detailWindowLabel(label: string, limit: UsageLimit): string | undefined
 	return sanitizeDisplayLine(windowLabel);
 }
 
+const WHOLE_DOLLARS = new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 });
+const COMPACT_COUNT = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 });
+
 /** `$1,234 · 5.6K requests` totals for the activity summary. */
 function formatActivityTotals(layout: HeatmapLayout): string {
 	const cost =
-		layout.totalCost >= 1
-			? `$${new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 }).format(layout.totalCost)}`
-			: `$${layout.totalCost.toFixed(2)}`;
-	const requests = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 }).format(
-		layout.totalRequests,
-	);
-	return `${cost} · ${requests} requests`;
+		layout.totalCost >= 1 ? `$${WHOLE_DOLLARS.format(layout.totalCost)}` : `$${layout.totalCost.toFixed(2)}`;
+	return `${cost} · ${COMPACT_COUNT.format(layout.totalRequests)} requests`;
 }
 
 // =============================================================================
@@ -547,6 +545,8 @@ export class UsageDashboardComponent implements Component {
 	#activityError: string | null = null;
 	#syncing = true;
 	#detailCache: { width: number; lines: string[] } | null = null;
+	/** ANSI overview rows; rebuilt when the revision or width changes. */
+	#overviewCache: { revision: number; width: number; lines: string[] } | null = null;
 	#lastViewportRows = 10;
 	#closed = false;
 	readonly #panel: OverlayPanel;
@@ -592,6 +592,7 @@ export class UsageDashboardComponent implements Component {
 
 	invalidate(): void {
 		this.#detailCache = null;
+		this.#overviewCache = null;
 		this.#panel.invalidate();
 	}
 
@@ -836,15 +837,8 @@ export class UsageDashboardComponent implements Component {
 		const ramp = this.#heatRamp();
 		const reset = "\x1b[39m";
 
-		const cost =
-			layout.totalCost >= 1
-				? `$${new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 }).format(layout.totalCost)}`
-				: `$${layout.totalCost.toFixed(2)}`;
-		const requests = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 }).format(
-			layout.totalRequests,
-		);
 		summary.push(
-			`${theme.bold(theme.fg("accent", "Activity"))} ${theme.fg("dim", `${cost} · ${requests} requests · last ${weeks} weeks`)}${this.#syncing ? theme.fg("dim", " · syncing…") : ""}`,
+			`${theme.bold(theme.fg("accent", "Activity"))} ${theme.fg("dim", `${formatActivityTotals(layout)} · last ${weeks} weeks`)}${this.#syncing ? theme.fg("dim", " · syncing…") : ""}`,
 		);
 		summary.push("");
 
@@ -876,10 +870,13 @@ export class UsageDashboardComponent implements Component {
 	// ---------------------------------------------------------------------------
 
 	#overviewLines(innerWidth: number): string[] {
+		const cached = this.#overviewCache;
+		if (cached?.revision === this.#revision && cached.width === innerWidth) return cached.lines;
 		const lines: string[] = [];
 		lines.push(...this.#renderCardsGrid(innerWidth));
 		lines.push("");
 		lines.push(...this.#renderHeatmap(innerWidth));
+		this.#overviewCache = { revision: this.#revision, width: innerWidth, lines };
 		return lines;
 	}
 

package/src/prompt/attachment-chips.ts

@@ -249,7 +249,8 @@ export class AttachmentChipsBand implements Component {
 
 	/** Leading 4 rows x 12 cols of the pasted text, muted. */
 	#textInterior(entry: TextAttachment): string[] {
-		const lines = entry.content.split("\n");
+		// Only the leading rows are drawn; don't split a multi-KB paste every frame.
+		const lines = entry.content.split("\n", INNER_ROWS);
 		const rows: string[] = [];
 		for (let r = 0; r < INNER_ROWS; r++) {
 			const cut = truncateToWidth(replaceTabs(lines[r] ?? ""), INNER_COLS);

package/src/prompt/composer-attachments.ts

@@ -165,6 +165,9 @@ export const COMPOSER_TOKEN_REGEX = new RegExp(
 	"gu",
 );
 
+/** Last compiled {@link referencedAttachments} scanner, keyed by its source (labels and glyphs rarely change). */
+let cachedScanner: { source: string; scanner: RegExp } | undefined;
+
 /**
  * Attachment indices referenced by a composer buffer, per kind. Image/video count compact chips
  * and expanded markers; paste counts compact chips only, since `[Paste #N]` markers number the
@@ -182,10 +185,9 @@ export function referencedAttachments(
 	const icons = [...kindByIcon.keys()].sort((a, b) => b.length - a.length).map(glyphSource);
 	const labels = [...recorded.keys()].sort((a, b) => b.length - a.length).map(label => RegExp.escape(label));
 	const recordedSource = labels.length > 0 ? labels.join("|") : "(?!)";
-	const scanner = new RegExp(
-		`${PLACEHOLDER_REGEX.source}|(${recordedSource})(?!\\d)|(${icons.join("|")}) #([1-9]\\d*)`,
-		"gu",
-	);
+	const source = `${PLACEHOLDER_REGEX.source}|(${recordedSource})(?!\\d)|(${icons.join("|")}) #([1-9]\\d*)`;
+	if (cachedScanner?.source !== source) cachedScanner = { source, scanner: new RegExp(source, "gu") };
+	const { scanner } = cachedScanner;
 
 	const refs: Record<ChipKind, Set<number>> = { image: new Set(), video: new Set(), paste: new Set() };
 	for (const match of text.matchAll(scanner)) {

package/src/prompt/custom-editor.ts

@@ -41,7 +41,7 @@ import {
 } from "./composer-attachments";
 import { type MacOSSpellingFeatures, MacOSSpellingProvider } from "./macos-spelling";
 import { hasMagicKeyword, highlightMagicKeywords, magicKeywordRanges } from "./magic-keywords";
-import type { TspEditorDecoration } from "@oh-my-pi/pi-wire";
+import type { TspEditorDecoration, TspText } from "@oh-my-pi/pi-wire";
 import { isNativeRendering } from "../native/state";
 import { isQueuedMessageList, parseQueueShorthand, QUEUE_LIST_MARKER_RE } from "./queue-input";
 import { type WordCompletionMethod, WordCompletionProvider } from "./word-completion";
@@ -50,8 +50,8 @@ import { fgOrPlain, theme } from "../theme/theme";
 /** A shell-mode draft's sigil (`!`, `!!`, `$`, `$$`) with its surrounding blanks; the mode chip stands in for it natively. */
 const SHELL_SIGIL_RE = /^\s*(?:!!?|\$\$?)[ \t]?/;
 
-/** The composer's TSP placeholder; the rotating ANSI hints (thinking effort, …) move into control tooltips. */
-const NATIVE_COMPOSER_PLACEHOLDER = "Ask omp — / commands · @ files · ! bash";
+/** The untitled session's TSP placeholder; the rotating ANSI hints (thinking effort, …) move into control tooltips. */
+const NATIVE_COMPOSER_PLACEHOLDER = "What are we cooking?";
 
 /** Live composer state the TSP layout shows; the interactive host wires {@link CustomEditor.composerState}. */
 export interface ComposerNativeState {
@@ -67,6 +67,8 @@ export interface ComposerNativeState {
 	readonly running: boolean;
 	/** The viewed subagent's lineage, outermost first and the viewed agent last; undefined on the main session. */
 	readonly viewing?: readonly string[];
+	/** The session's title, quoted in italics as the TSP placeholder; undefined until it has one. */
+	readonly title?: string;
 }
 
 /** Action code prefix of the viewing header's links: `focus:<agent id>`, {@link MAIN_AGENT_ID} for the main session. */
@@ -220,7 +222,7 @@ function normalizePastedPath(path: string): string {
 			}
 		}
 	}
-	return unquoted.replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");
+	return (unquoted.startsWith("\\~/") ? unquoted.slice(1) : unquoted).replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");
 }
 
 function isExplicitPastedPath(path: string): boolean {
@@ -798,10 +800,21 @@ export class CustomEditor extends Editor {
 	 *  indivisible: a stray backspace deletes the whole token instead of corrupting it. */
 	override atomicTokenPattern = COMPOSER_TOKEN_REGEX;
 
+	/** Atom-table revision and pattern the composer token matcher was last built for. */
+	#tokenPatternAtomsRevision = -1;
+	#tokenPattern: RegExp | undefined;
+
 	#syncComposerTokenPattern(): void {
-		const labels = [...this.atoms].filter(([, expansion]) => expansion.startsWith("^")).map(([label]) => label);
+		// Rebuild only when the atom table changed or someone replaced the pattern since the last sync.
+		if (this.#tokenPatternAtomsRevision === this.atomsRevision && this.#tokenPattern === this.atomicTokenPattern) {
+			return;
+		}
+		const labels: string[] = [];
+		for (const [label, expansion] of this.atoms) if (expansion.startsWith("^")) labels.push(label);
 		const next = composerTokenRegex(labels);
 		if (next.source !== this.atomicTokenPattern.source) this.atomicTokenPattern = next;
+		this.#tokenPatternAtomsRevision = this.atomsRevision;
+		this.#tokenPattern = this.atomicTokenPattern;
 	}
 
 	/** Magic-keyword shimmer cadence — drives one editor repaint every 70 ms while
@@ -819,27 +832,35 @@ export class CustomEditor extends Editor {
 	 *  timer to request the next animation frame. Undefined when nobody is
 	 *  listening (tests, headless callers); the timer chain still self-cleans. */
 	#requestShimmerRepaint: (() => void) | undefined;
-	#queueDecorationText: string | undefined;
+	/** Text revision the per-revision decoration inputs below were computed for. */
+	#decorationRevision = -1;
+	#decorationText = "";
 	#decorationLines: readonly string[] = [""];
 	#queueShorthandActive = false;
 	#queueListActive = false;
 
 	/** Decorate magic keywords, attachments, and the queue-composer header/list markers.
 	 *  Queue shorthand reserves its first logical line as a dim `Queueing` label; sequential
-	 *  item markers use the accent color so separate follow-ups remain visible while composing. */
+	 *  item markers use the accent color so separate follow-ups remain visible while composing.
+	 *  Called once per layout segment, so whole-buffer inputs are computed once per text revision. */
 	override decorateText = (text: string, context: EditorTextDecorationContext): string => {
 		this.#syncComposerTokenPattern();
-		const editorText = this.getText();
+		if (this.#decorationRevision !== this.textRevision) {
+			this.#decorationRevision = this.textRevision;
+			const editorText = this.getText();
+			if (this.#decorationText !== editorText) {
+				this.#decorationText = editorText;
+				this.#decorationLines = this.getLines();
+				const queueBody = parseQueueShorthand(editorText);
+				this.#queueShorthandActive = queueBody !== undefined;
+				this.#queueListActive = queueBody !== undefined && isQueuedMessageList(queueBody);
+			}
+		}
+		// One string instance per revision: whole-buffer memos downstream hit on identity.
+		const editorText = this.#decorationText;
 		const animated = this.focused && this.#shimmerEnabled() && hasMagicKeyword(editorText);
 		const phase = animated ? (Date.now() % CustomEditor.SHIMMER_PERIOD_MS) / CustomEditor.SHIMMER_PERIOD_MS : 0;
 		if (animated) this.#scheduleShimmerFrame();
-		if (this.#queueDecorationText !== editorText) {
-			this.#queueDecorationText = editorText;
-			this.#decorationLines = this.getLines();
-			const queueBody = parseQueueShorthand(editorText);
-			this.#queueShorthandActive = queueBody !== undefined;
-			this.#queueListActive = queueBody !== undefined && isQueuedMessageList(queueBody);
-		}
 		let sourceSearchOffset = 0;
 		const locateSource = (value: string): number => {
 			const offset = text.indexOf(value, sourceSearchOffset);
@@ -1018,10 +1039,18 @@ export class CustomEditor extends Editor {
 	protected override get nativeSendable(): boolean {
 		return this.onSubmit !== undefined && !this.disableSubmit;
 	}
-	/** Viewing a subagent, the draft goes to it: the placeholder names it. */
-	override describePlaceholder = (): string => {
-		const agent = this.composerState().viewing?.at(-1);
-		return agent === undefined ? NATIVE_COMPOSER_PLACEHOLDER : `Message ${agent}`;
+	/** The quoted-title placeholder, kept while the title stands so the editor node stays reused. */
+	#titlePlaceholder: { title: string; text: TspText } | undefined;
+	/** Viewing a subagent, the draft goes to it: the placeholder names it; else the session's title, quoted in italics. */
+	override describePlaceholder = (): TspText => {
+		const { viewing, title } = this.composerState();
+		const agent = viewing?.at(-1);
+		if (agent !== undefined) return `Message ${agent}`;
+		if (!title) return NATIVE_COMPOSER_PLACEHOLDER;
+		if (this.#titlePlaceholder?.title !== title) {
+			this.#titlePlaceholder = { title, text: [{ t: `“${title}”`, s: "em" }] };
+		}
+		return this.#titlePlaceholder.text;
 	};
 	/** A shell-mode draft highlights as its language. */
 	override describeLanguage = (): string | undefined => this.composerState().shell?.kind;

package/src/prompt/interactive-context-helpers.ts

@@ -1,5 +1,5 @@
 /** Shared assistant transcript construction and model-authored link caching. */
-import type { AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, Model, TextContent } from "@oh-my-pi/pi-ai";
 import { getMarkdownLinkUrls } from "../index";
 import { EMPTY_LINK_TARGETS } from "../render/render-utils";
 import type { ImageBudget } from "../components/image";
@@ -23,7 +23,8 @@ export interface AssistantMessageHost {
 	readonly hideToolActivity: boolean;
 	readonly toolOutputExpanded: boolean;
 	readonly ui: { requestRender(): void; readonly imageBudget: ImageBudget };
-	resolveAssistantMessageLinks(texts: readonly string[]): Promise<ReadonlyMap<string, string>>;
+	/** Resolve already-extracted Markdown link destinations to local targets. */
+	resolveAssistantMessageLinkHrefs(hrefs: readonly string[]): Promise<ReadonlyMap<string, string>>;
 }
 
 const kMarkdownLinkTargets = Symbol("markdownLinkTargets");
@@ -31,14 +32,26 @@ type SessionWithMarkdownLinkTargets = AssistantMessageSession & {
 	[kMarkdownLinkTargets]?: ReadonlyMap<string, string>;
 };
 
-function assistantTextBlocks(messages: readonly AssistantMessage[]): string[] {
-	const texts: string[] = [];
-	for (const message of messages) {
-		for (const content of message.content) {
-			if (content.type === "text") texts.push(content.text);
+/** Link destinations per text block, revalidated against the block's text (streaming blocks grow in place). */
+const textBlockHrefs = new WeakMap<TextContent, { text: string; hrefs: readonly string[] }>();
+
+/**
+ * Distinct Markdown link destinations authored in `message`'s text blocks.
+ * Each block is lexed once per text revision; transcript rebuilds and the
+ * message_end refresh reuse the result.
+ */
+function assistantMessageLinkHrefs(message: AssistantMessage): string[] {
+	const hrefs = new Set<string>();
+	for (const content of message.content) {
+		if (content.type !== "text") continue;
+		let memo = textBlockHrefs.get(content);
+		if (memo?.text !== content.text) {
+			memo = { text: content.text, hrefs: getMarkdownLinkUrls(content.text) };
+			textBlockHrefs.set(content, memo);
 		}
+		for (const href of memo.hrefs) hrefs.add(href);
 	}
-	return texts;
+	return [...hrefs];
 }
 
 /**
@@ -53,13 +66,12 @@ export async function refreshAssistantMessageLinkTargets(
 ): Promise<ReadonlyMap<string, string>> {
 	const session: SessionWithMarkdownLinkTargets = ctx.viewSession;
 	const previous = session[kMarkdownLinkTargets] ?? EMPTY_LINK_TARGETS;
-	const texts = assistantTextBlocks(messages);
 	const hrefs = new Set<string>();
-	for (const text of texts) {
-		for (const href of getMarkdownLinkUrls(text)) hrefs.add(href);
+	for (const message of messages) {
+		for (const href of assistantMessageLinkHrefs(message)) hrefs.add(href);
 	}
 	if (hrefs.size === 0) return previous;
-	const resolved = await ctx.resolveAssistantMessageLinks(texts);
+	const resolved = await ctx.resolveAssistantMessageLinkHrefs([...hrefs]);
 	let changed = false;
 	for (const href of hrefs) {
 		if (previous.get(href) !== resolved.get(href)) {
@@ -87,12 +99,9 @@ export function assistantMessageLinkTargets(
 	targets: ReadonlyMap<string, string>,
 ): ReadonlyMap<string, string> {
 	const selected = new Map<string, string>();
-	for (const content of message.content) {
-		if (content.type !== "text") continue;
-		for (const href of getMarkdownLinkUrls(content.text)) {
-			const target = targets.get(href);
-			if (target) selected.set(href, target);
-		}
+	for (const href of assistantMessageLinkHrefs(message)) {
+		const target = targets.get(href);
+		if (target) selected.set(href, target);
 	}
 	return selected;
 }

package/src/prompt/macos-spelling.ts

@@ -56,6 +56,8 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 	#availabilityChecked = false;
 	#cacheGeneration = 0;
 	#typoCache = new Map<string, readonly native.SpellingRange[]>();
+	/** {@link #projectTypoRanges} answers for the current {@link #typoCache}; segments re-ask every frame. */
+	#projectionMemo = new Map<string, readonly native.SpellingRange[] | undefined>();
 	#typoInFlight = new Map<string, Promise<readonly native.SpellingRange[]>>();
 	#automaticTypoActive = false;
 	#automaticTypoQueue = new Map<string, string>();
@@ -237,6 +239,7 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 		return request;
 	}
 	#projectTypoRanges(text: string): readonly native.SpellingRange[] | undefined {
+		if (this.#projectionMemo.has(text)) return this.#projectionMemo.get(text);
 		let projected: native.SpellingRange[] | undefined;
 		let matchLength = -1;
 		for (const [previous, ranges] of this.#typoCache) {
@@ -265,6 +268,8 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 			});
 			matchLength = prefix + suffix;
 		}
+		if (this.#projectionMemo.size >= CACHE_LIMIT) this.#projectionMemo.clear();
+		this.#projectionMemo.set(text, projected);
 		return projected;
 	}
 
@@ -316,6 +321,7 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 		const hadProjectedRanges = (this.#projectTypoRanges(text)?.length ?? 0) > 0;
 		if (this.#typoCache.size >= CACHE_LIMIT) this.#typoCache.clear();
 		this.#typoCache.set(text, ranges);
+		this.#projectionMemo.clear();
 		if (ranges.length > 0 || hadProjectedRanges) this.onUpdate?.();
 		return ranges;
 	}
@@ -323,6 +329,7 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 	#clearCaches(): void {
 		this.#cacheGeneration++;
 		this.#typoCache.clear();
+		this.#projectionMemo.clear();
 		this.#typoInFlight.clear();
 		this.#automaticTypoQueue.clear();
 	}

package/src/prompt/magic-keywords.ts

@@ -131,6 +131,9 @@ export function magicKeywordRanges(text: string): { from: number; to: number }[]
 	return ranges.sort((a, b) => a.from - b.from);
 }
 
+/** Last {@link hasMagicKeyword} answer: the live editor asks once per layout segment with the same buffer. */
+let lastProbe: { text: string; registry: readonly RegisteredKeyword[]; found: boolean } | undefined;
+
 /**
  * Cheap test for "does this text contain any registered keyword as standalone
  * prose?". Short-circuits on a substring probe before paying for the
@@ -138,8 +141,14 @@ export function magicKeywordRanges(text: string): { from: number; to: number }[]
  * `String#includes` per word. Used by the live editor to gate the shimmer timer.
  */
 export function hasMagicKeyword(text: string): boolean {
+	if (lastProbe?.text === text && lastProbe.registry === registry) return lastProbe.found;
+	let found = false;
 	for (const keyword of registry) {
-		if (text.includes(keyword.word) && containsMagicKeyword(text, keyword.word)) return true;
+		if (text.includes(keyword.word) && containsMagicKeyword(text, keyword.word)) {
+			found = true;
+			break;
+		}
 	}
-	return false;
+	lastProbe = { text, registry, found };
+	return found;
 }

package/src/prompt/word-completion.ts

@@ -56,9 +56,20 @@ interface WordQuery extends WordCompletionQuery {
 
 /** Editor text before the word starting at `start`, truncated to its last {@link BEFORE_LIMIT} code units. */
 function textBefore(lines: readonly string[], cursorLine: number, start: number): string {
-	let text = (lines[cursorLine] ?? "").slice(0, start);
-	for (let line = cursorLine - 1; line >= 0 && text.length < BEFORE_LIMIT; line--) {
-		text = `${lines[line] ?? ""}\n${text}`;
+	const head = (lines[cursorLine] ?? "").slice(0, start);
+	// Find the first line the capped tail reaches, then join once.
+	let length = head.length;
+	let first = cursorLine;
+	while (first > 0 && length < BEFORE_LIMIT) {
+		first--;
+		length += (lines[first] ?? "").length + 1;
+	}
+	let text = head;
+	if (first < cursorLine) {
+		const parts: string[] = [];
+		for (let line = first; line < cursorLine; line++) parts.push(lines[line] ?? "");
+		parts.push(head);
+		text = parts.join("\n");
 	}
 	if (text.length <= BEFORE_LIMIT) return text;
 	let cut = text.length - BEFORE_LIMIT;
@@ -111,6 +122,16 @@ export class WordCompletionProvider implements EditorTextAssistProvider {
 	#lastShown: { before: string; word: string } | undefined;
 	/** What the last `getWordCompletion` returned, so a fetch repaints only when it changes that. */
 	#displayed: { key: string; suffix: string | null } | undefined;
+	/** Last {@link #query} input snapshot (lines are copied: the editor mutates its array in place). */
+	#queryMemo:
+		| {
+				method: WordCompletionMethod;
+				lines: readonly string[];
+				cursorLine: number;
+				cursorCol: number;
+				query: WordQuery | undefined;
+		  }
+		| undefined;
 
 	/** Invoked when an asynchronous answer changes the rendered ghost text. */
 	onUpdate: (() => void) | undefined;
@@ -171,11 +192,23 @@ export class WordCompletionProvider implements EditorTextAssistProvider {
 
 	#query(lines: readonly string[], cursorLine: number, cursorCol: number): WordQuery | undefined {
 		if (this.#method === "off") return undefined;
+		// Rendering asks every frame; reuse the answer until the buffer, caret, or engine changes.
+		const memo = this.#queryMemo;
+		if (
+			memo?.method === this.#method &&
+			memo.cursorLine === cursorLine &&
+			memo.cursorCol === cursorCol &&
+			memo.lines.length === lines.length &&
+			memo.lines.every((line, index) => line === lines[index])
+		) {
+			return memo.query;
+		}
 		const query = wordCompletionQuery(lines, cursorLine, cursorCol, this.#prose);
-		if (!query) return undefined;
 		// The method keeps a request still in flight for the previous engine from
 		// shadowing the same word state on the new one.
-		return { key: `${this.#method}\u0000${query.prefix}\u0000${query.before}`, ...query };
+		const result = query && { key: `${this.#method}\u0000${query.prefix}\u0000${query.before}`, ...query };
+		this.#queryMemo = { method: this.#method, lines: lines.slice(), cursorLine, cursorCol, query: result };
+		return result;
 	}
 
 	#project(query: WordQuery): string | null {

package/src/setup/scenes/splash.ts

@@ -31,14 +31,6 @@ function skipHint(): string {
 	return `press ${formatKeyHint("enter")} to skip`;
 }
 
-/** Density ramp for the rippling water, lightest → heaviest. */
-const WATER_RAMP = [
-	{ min: 0.62, char: "█" },
-	{ min: 0.5, char: "▓" },
-	{ min: 0.36, char: "▒" },
-	{ min: 0.24, char: "░" },
-];
-
 function starAt(x: number, y: number, frame: number): string {
 	const hash = (x * 73856093) ^ (y * 19349663) ^ (frame * 83492791);
 	const bucket = Math.abs(hash) % 97;
@@ -85,33 +77,86 @@ function waterJitter(x: number, y: number): number {
 }
 
 /**
- * Rippling water amplitude in [0,1] at (x, y): three travelling sine waves
- * interfere, then a radial edge falloff and a downward fade concentrate the
- * ripples beneath the mark and dissolve them toward the edges/bottom. `t`
- * advances each tick, so the surface drifts.
+ * Time-invariant terms of the rippling water for one screen size: three
+ * travelling sine waves interfere, then a radial edge falloff and a downward
+ * fade concentrate the ripples beneath the mark and dissolve them toward the
+ * edges/bottom. Only the sine phases move per tick, so everything else is
+ * computed once per size.
  */
-function waterAmplitude(
-	x: number,
-	y: number,
-	cx: number,
-	waterTop: number,
-	waterHeight: number,
-	width: number,
-	t: number,
-): number {
-	const dx = (x - cx) / 2;
-	const dy = y - waterTop;
-	const dist = Math.sqrt(dx * dx + dy * dy);
-	const wave =
-		0.5 * Math.sin(dist * 0.55 - t) +
-		0.3 * Math.sin(x * 0.22 + y * 0.45 - t * 0.7) +
-		0.2 * Math.sin(Math.abs(dx) * 0.8 + dy * 0.5 - t * 1.4);
-	const level = 0.5 + 0.5 * wave;
-	const edge = Math.max(0, 1 - Math.abs(x - cx) / (width * 0.5));
-	const fade = Math.max(0, 1 - (dy / Math.max(1, waterHeight)) * 0.55);
-	return level * edge ** 0.7 * fade;
+interface WaterField {
+	readonly width: number;
+	readonly height: number;
+	readonly waterTop: number;
+	/** Per cell (row-major from `waterTop`): `dist * 0.55`. */
+	readonly radial: Float64Array;
+	/** Per cell: `x * 0.22 + y * 0.45`. */
+	readonly diagonal: Float64Array;
+	/** Per cell: `|dx| * 0.8 + dy * 0.5`. */
+	readonly cross: Float64Array;
+	/** Per cell: `(waterJitter(x, y) - 0.5) * 0.06`. */
+	readonly jitter: Float64Array;
+	/** Per column: `edge ** 0.7`. */
+	readonly edge: Float64Array;
+	/** Per water row: downward fade. */
+	readonly fade: Float64Array;
+}
+
+let waterField: WaterField | undefined;
+
+function getWaterField(width: number, height: number, cx: number, waterTop: number): WaterField {
+	const cached = waterField;
+	if (cached && cached.width === width && cached.height === height && cached.waterTop === waterTop) return cached;
+	const waterHeight = Math.max(1, height - waterTop);
+	const rows = Math.max(0, height - waterTop);
+	const radial = new Float64Array(rows * width);
+	const diagonal = new Float64Array(rows * width);
+	const cross = new Float64Array(rows * width);
+	const jitter = new Float64Array(rows * width);
+	const edge = new Float64Array(width);
+	const fade = new Float64Array(rows);
+	for (let x = 0; x < width; x++) edge[x] = Math.max(0, 1 - Math.abs(x - cx) / (width * 0.5)) ** 0.7;
+	for (let row = 0; row < rows; row++) {
+		const y = waterTop + row;
+		const dy = y - waterTop;
+		fade[row] = Math.max(0, 1 - (dy / waterHeight) * 0.55);
+		for (let x = 0; x < width; x++) {
+			const i = row * width + x;
+			const dx = (x - cx) / 2;
+			radial[i] = Math.sqrt(dx * dx + dy * dy) * 0.55;
+			diagonal[i] = x * 0.22 + y * 0.45;
+			cross[i] = Math.abs(dx) * 0.8 + dy * 0.5;
+			jitter[i] = (waterJitter(x, y) - 0.5) * 0.06;
+		}
+	}
+	waterField = { width, height, waterTop, radial, diagonal, cross, jitter, edge, fade };
+	return waterField;
+}
+
+/** Water glyph for an amplitude, lightest → heaviest density ramp; undefined below the floor. */
+function waterChar(amp: number): string | undefined {
+	if (amp > 0.62) return "█";
+	if (amp > 0.5) return "▓";
+	if (amp > 0.36) return "▒";
+	if (amp > 0.24) return "░";
+	return undefined;
+}
+
+/** Reused cell grid; resized when the screen changes. */
+let splashCells: string[][] = [];
+
+function resetCells(width: number, height: number): string[][] {
+	if (splashCells.length !== height || splashCells[0]?.length !== width) {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
+		splashCells = Array.from({ length: height }, () => new Array<string>(width).fill(" "));
+	} else {
+		for (const row of splashCells) row.fill(" ");
+	}
+	return splashCells;
 }
 
+/** Per-frame gradient escapes, one per screen diagonal (the gradient only varies along it). */
+let diagonalEscapes: (string | undefined)[] = [];
+
 /**
  * Animated setup splash, in the spirit of the omp landing page: the brand π
  * mark rendered with the live diagonal gradient + shine sweep, rising out of a
@@ -132,23 +177,46 @@ export function renderSetupSplash(width: number, height: number, elapsedMs: numb
 	const cx = Math.floor(w / 2);
 	const surfaceTime = frame * 0.13;
 
-	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
-	const cells: string[][] = Array.from({ length: h }, () => new Array<string>(w).fill(" "));
+	const cells = resetCells(w, h);
 	const put = (x: number, y: number, glyph: string): void => {
 		if (y >= 0 && y < h && x >= 0 && x < w) cells[y][x] = glyph;
 	};
+	// Every cell on a diagonal shares one gradient position, so resolve each
+	// escape once per frame instead of once per cell.
+	const diagonals = w + h - 1;
+	if (diagonalEscapes.length !== diagonals) diagonalEscapes = Array.from({ length: diagonals });
+	else diagonalEscapes.fill(undefined);
+	const escapes = diagonalEscapes;
+	const gradient = (x: number, y: number): string => {
+		const d = x + (h - 1 - y);
+		let escape = escapes[d];
+		if (escape === undefined) {
+			escape = gradientEscape(screenGradientT(x, y, w, h, phase), shine);
+			escapes[d] = escape;
+		}
+		return escape;
+	};
 
 	const hx = Math.floor((w - LOGO_WIDTH) / 2);
 	const hy = Math.max(2, Math.floor(h * 0.16));
 	const waterTop = hy + LOGO_HEIGHT;
-	const waterHeight = Math.max(1, h - waterTop);
 
 	// 1. rippling water surface (shares the screen-wide gradient with the mark)
+	const field = getWaterField(w, h, cx, waterTop);
+	const tDiagonal = surfaceTime * 0.7;
+	const tCross = surfaceTime * 1.4;
 	for (let y = waterTop; y < h; y++) {
+		const row = y - waterTop;
+		const fade = field.fade[row];
 		for (let x = 0; x < w; x++) {
-			const amp = waterAmplitude(x, y, cx, waterTop, waterHeight, w, surfaceTime) + (waterJitter(x, y) - 0.5) * 0.06;
-			const cell = WATER_RAMP.find(step => amp > step.min);
-			if (cell) put(x, y, gradientEscape(screenGradientT(x, y, w, h, phase), shine) + cell.char + RESET);
+			const i = row * w + x;
+			const wave =
+				0.5 * Math.sin(field.radial[i] - surfaceTime) +
+				0.3 * Math.sin(field.diagonal[i] - tDiagonal) +
+				0.2 * Math.sin(field.cross[i] - tCross);
+			const level = 0.5 + 0.5 * wave;
+			const char = waterChar(level * field.edge[x] * fade + field.jitter[i]);
+			if (char) cells[y][x] = gradient(x, y) + char + RESET;
 		}
 	}
 	// 2. twinkling starfield in the sky above the water
@@ -162,13 +230,9 @@ export function renderSetupSplash(width: number, height: number, elapsedMs: numb
 	LARGE_LOGO.forEach((line, row) => {
 		let col = 0;
 		for (const ch of line) {
-			if (ch !== " ") {
-				put(
-					hx + col,
-					hy + row,
-					gradientEscape(screenGradientT(hx + col, hy + row, w, h, phase), shine) + ch + RESET,
-				);
-			}
+			const x = hx + col;
+			const y = hy + row;
+			if (ch !== " " && y >= 0 && y < h && x >= 0 && x < w) cells[y][x] = gradient(x, y) + ch + RESET;
 			col++;
 		}
 	});