@oh-my-pi/pi-tui 16.5.2 → 17.0.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [17.0.0] - 2026-07-15
+
+### Added
+
+- Improved LaTeX rendering for \underbrace, \overbrace, \overset, \underset, and \stackrel to use drawn horizontal braces with centered labels and stacked annotations instead of flat inline glyphs.
+- Improved LaTeX rendering of multi-letter subscripts and superscripts by displaying them as raised or lowered blocks instead of ragged per-character Unicode glyphs.
+- Added an opt-in Editor.setImeSafeCursorLayout() method to protect macOS IME preedit while retaining the compact bordered layout by default.
+
+### Fixed
+
+- Fixed SIXEL image rendering where images with cell heights not divisible by 6 would have their bottom portion overwritten by subsequent content.
+- Fixed an issue where the Kitty OSC 99 desktop-notification capability probe would leak raw text into the terminal pane when running inside a multiplexer like tmux or screen.
+
 ## [16.5.2] - 2026-07-14
 
 ### Fixed

package/dist/types/components/editor.d.ts

@@ -92,6 +92,8 @@ export declare class Editor implements Component, Focusable {
      * Use the real terminal cursor instead of rendering a cursor glyph.
      */
     setUseTerminalCursor(useTerminalCursor: boolean): void;
+    /** Render a dedicated bottom border so terminal-local IME preedit cannot shift editor chrome. */
+    setImeSafeCursorLayout(enabled: boolean): void;
     getUseTerminalCursor(): boolean;
     setMaxHeight(maxHeight: number | undefined): void;
     setPaddingX(paddingX: number): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "16.5.2",
+	"version": "17.0.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -37,8 +37,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "16.5.2",
-		"@oh-my-pi/pi-utils": "16.5.2",
+		"@oh-my-pi/pi-natives": "17.0.0",
+		"@oh-my-pi/pi-utils": "17.0.0",
 		"lru-cache": "11.5.2",
 		"marked": "^18.0.6"
 	},

package/src/components/editor.ts

@@ -382,6 +382,7 @@ export class Editor implements Component, Focusable {
 
 	#theme: EditorTheme;
 	#useTerminalCursor = false;
+	#imeSafeCursorLayout = false;
 
 	/** When set, replaces the normal cursor glyph at end-of-text with this ANSI-styled string. */
 	cursorOverride: string | undefined;
@@ -539,6 +540,11 @@ export class Editor implements Component, Focusable {
 		this.#useTerminalCursor = useTerminalCursor;
 	}
 
+	/** Render a dedicated bottom border so terminal-local IME preedit cannot shift editor chrome. */
+	setImeSafeCursorLayout(enabled: boolean): void {
+		this.#imeSafeCursorLayout = enabled;
+	}
+
 	getUseTerminalCursor(): boolean {
 		return this.#useTerminalCursor;
 	}
@@ -866,6 +872,7 @@ export class Editor implements Component, Focusable {
 			let displayWidth = visibleWidth(layoutLine.text);
 			let cursorPaddingOverflow = 0;
 			let decorated = false;
+			let imeSafeCursorTail = false;
 			const showPromptGutter = promptGutter !== undefined && visibleIndex === 0;
 			const gutterText =
 				promptGutter === undefined ? "" : showPromptGutter ? promptGutter.firstLine : promptGutter.continuation;
@@ -922,7 +929,13 @@ export class Editor implements Component, Focusable {
 				if (marker) {
 					const before = displayText.slice(0, layoutLine.cursorPos);
 					const after = displayText.slice(layoutLine.cursorPos);
-					if (after.length === 0 && inlineHint) {
+					if (this.#imeSafeCursorLayout && after.length === 0 && borderVisible) {
+						// Terminal frontends render IME marked text locally before committed bytes
+						// reach the application. Keep the end-of-input cursor row empty to its
+						// right so that insertion cannot shift box chrome onto the next row.
+						displayText = before + marker;
+						imeSafeCursorTail = true;
+					} else if (after.length === 0 && inlineHint) {
 						const availWidth = Math.max(0, lineContentWidth - displayWidth);
 						const hintText = hintStyle(truncateToWidth(inlineHint, availWidth));
 						displayText = before + marker + hintText;
@@ -1022,6 +1035,15 @@ export class Editor implements Component, Focusable {
 			// trailing `─`, but never the corner/vertical bar itself.
 			const isLastLine = visibleIndex === visibleLayoutLines.length - 1;
 			const rightChromeCells = Math.max(1, paddingX + 1 - cursorPaddingOverflow);
+			if (isLastLine && imeSafeCursorTail) {
+				const leftBorder = this.borderColor(`${box.vertical}${padding(paddingX)}`);
+				const bottomBorder = this.borderColor(
+					`${box.bottomLeft}${box.horizontal.repeat(Math.max(0, width - 2))}${box.bottomRight}`,
+				);
+				result.push(leftBorder + displayText);
+				result.push(bottomBorder);
+				continue;
+			}
 			if (isLastLine) {
 				const rightPad = Math.max(0, rightChromeCells - 2);
 				const includeHorizontal = rightChromeCells >= 2;

package/src/latex-block.ts

@@ -11,7 +11,8 @@
 // fractions and `\binom`, stretch delimiters (`\left…\right`, tall bare parens,
 // matrix brackets), render matrix/cases/array environments as baseline-aligned
 // grids, place big-operator limits (`\sum`, `\lim`, `\int\limits`) above and
-// below the symbol, draw radicals, raise/lower block scripts, and
+// below the symbol, draw radicals, raise/lower block scripts, draw labeled
+// horizontal braces (`\underbrace{x}_{lbl}`), stack `\overset`/`\underset`, and
 // align `&` columns in `align`-family environments. Flat runs — symbols, fonts,
 // colors, inline scripts — are delegated to `latexToUnicode`.
 //
@@ -126,6 +127,25 @@ const INTEGRAL_OPERATORS: Record<string, true> = {
 	smallint: true,
 };
 
+// Horizontal brace/bracket decorations drawn as a rule row beside the content,
+// with an optional limits-style label beyond the rule (`\underbrace{x}_{lbl}`).
+interface HBraceSpec {
+	left: string;
+	mid: string;
+	center: string;
+	right: string;
+	over: boolean;
+}
+
+const HBRACE_COMMANDS: Record<string, HBraceSpec> = {
+	overbrace: { left: "╭", mid: "─", center: "┴", right: "╮", over: true },
+	underbrace: { left: "╰", mid: "─", center: "┬", right: "╯", over: false },
+	overbracket: { left: "┌", mid: "─", center: "─", right: "┐", over: true },
+	underbracket: { left: "└", mid: "─", center: "─", right: "┘", over: false },
+	overparen: { left: "╭", mid: "─", center: "─", right: "╮", over: true },
+	underparen: { left: "╰", mid: "─", center: "─", right: "╯", over: false },
+};
+
 // Vertical delimiter piece characters: `only` for single-line content, then
 // top/mid/bot columns for stretched forms; `axis` replaces `mid` at the
 // baseline row (the brace point).
@@ -363,6 +383,31 @@ function limitsBox(glyph: Box, sub: Box | null, sup: Box | null): Box {
 	return { lines, baseline, width };
 }
 
+/**
+ * `\underbrace{content}_{label}` / `\overbrace{content}^{label}`: the content
+ * with a drawn horizontal brace beside it and the label centered beyond the
+ * brace. The baseline stays on the content so neighbors align with it.
+ */
+function hbraceBox(content: Box, spec: HBraceSpec, label: Box | null): Box {
+	const braceWidth = Math.max(content.width, 3);
+	const width = Math.max(braceWidth, label?.width ?? 0);
+	const lead = (braceWidth - 3) >> 1;
+	const brace = center(
+		spec.left + spec.mid.repeat(lead) + spec.center + spec.mid.repeat(braceWidth - 3 - lead) + spec.right,
+		width,
+	);
+	const contentLines = content.lines.map(line => center(line, width));
+	const labelLines = label === null ? [] : label.lines.map(line => center(line, width));
+	if (spec.over) {
+		return {
+			lines: [...labelLines, brace, ...contentLines],
+			baseline: labelLines.length + 1 + content.baseline,
+			width,
+		};
+	}
+	return { lines: [...contentLines, brace, ...labelLines], baseline: content.baseline, width };
+}
+
 /**
  * Attach block scripts to `base` as one shared right-hand column: the
  * superscript ends level with the base's top row (raised one row above a
@@ -878,6 +923,59 @@ function parseExpr(src: string, ctx: Ctx = ROOT_CTX): Box {
 				i = bottom.end;
 				continue;
 			}
+			if (name && HBRACE_COMMANDS[name]) {
+				flush();
+				const spec = HBRACE_COMMANDS[name];
+				const arg = readArg(src, j);
+				// Limits-style scripts: the brace-side script is the label; an
+				// opposite-side script attaches as a regular corner script.
+				let subText: string | null = null;
+				let supText: string | null = null;
+				let m = arg.end;
+				for (;;) {
+					let n = m;
+					while (src[n] === " ") n++;
+					if (src[n] === "_" && subText === null) {
+						const s = readArg(src, n + 1);
+						subText = s.text;
+						m = s.end;
+						continue;
+					}
+					if (src[n] === "^" && supText === null) {
+						const s = readArg(src, n + 1);
+						supText = s.text;
+						m = s.end;
+						continue;
+					}
+					break;
+				}
+				const labelText = spec.over ? supText : subText;
+				const otherText = spec.over ? subText : supText;
+				let box = hbraceBox(
+					parseExpr(arg.text, inner()),
+					spec,
+					labelText === null ? null : parseExpr(labelText, inner()),
+				);
+				if (otherText !== null) {
+					const other = parseExpr(otherText, inner());
+					box = attachScripts(box, spec.over ? other : null, spec.over ? null : other);
+				}
+				boxes.push(paint(box));
+				i = m;
+				continue;
+			}
+			if (name === "overset" || name === "underset" || name === "stackrel") {
+				flush();
+				const anno = readArg(src, j);
+				const base = readArg(src, anno.end);
+				const annoBox = parseExpr(anno.text, inner());
+				const baseBox = parseExpr(base.text, inner());
+				boxes.push(
+					paint(limitsBox(baseBox, name === "underset" ? annoBox : null, name === "underset" ? null : annoBox)),
+				);
+				i = base.end;
+				continue;
+			}
 			if (name === "sqrt") {
 				let k = j;
 				while (src[k] === " ") k++;
@@ -1108,8 +1206,18 @@ function parseExpr(src: string, ctx: Ctx = ROOT_CTX): Box {
 				const flat = latexToUnicode(raw);
 				return flat.startsWith("^") || flat.startsWith("_");
 			};
+			// Multi-letter script words (`N_{turns}`) would convert per-char into
+			// Unicode glyphs of uneven height and read ragged; box them too.
+			// Commands are stripped: their output (`\prime` → ′) is not letters.
+			const ragged = (raw: string | undefined): boolean => {
+				if (raw === undefined) return false;
+				const letters = scriptArgOf(raw)
+					.replace(/\\[A-Za-z]+/g, "")
+					.match(/[A-Za-z]/g);
+				return letters !== null && letters.length >= 2;
+			};
 			const tall = (supBox !== null && supBox.lines.length > 1) || (subBox !== null && subBox.lines.length > 1);
-			if (tall || unconvertible(supText) || unconvertible(subText)) {
+			if (tall || unconvertible(supText) || unconvertible(subText) || ragged(supText) || ragged(subText)) {
 				// Block script (`x^{\frac{1}{2}}`, `x^q`): raise/lower the boxes
 				// against the run or box they follow.
 				flush();

package/src/terminal-capabilities.ts

@@ -952,11 +952,25 @@ export function renderImage(
 
 	if (TERMINAL.imageProtocol === ImageProtocol.Sixel) {
 		try {
-			const targetWidthPx = Math.max(1, fit.columns * cellDims.widthPx);
-			const targetHeightPx = Math.max(1, fit.rows * cellDims.heightPx);
+			// SIXEL encodes in 6-pixel vertical bands. A height that is not a
+			// multiple of 6 is padded with transparent rows, but the terminal
+			// still allocates cell rows for the padded height. When the padded
+			// height crosses a cell boundary the terminal uses one more row
+			// than fit.rows, so the next line of content overwrites the bottom
+			// of the image — a visible slice stripped from the image. Round the
+			// encode height DOWN to the largest multiple of 6 that fits within
+			// the requested row budget, so the band boundary aligns without
+			// padding and the reserved row count never exceeds fit.rows. Scale
+			// the width by the same ratio so resize_exact preserves the aspect
+			// ratio instead of squashing the image vertically.
+			const rawHeightPx = Math.max(1, fit.rows * cellDims.heightPx);
+			const targetHeightPx = Math.max(6, Math.floor(rawHeightPx / 6) * 6);
+			const heightScale = targetHeightPx / rawHeightPx;
+			const targetWidthPx = Math.max(1, Math.round(fit.columns * cellDims.widthPx * heightScale));
+			const rows = Math.max(1, Math.ceil(targetHeightPx / cellDims.heightPx));
 			const decoded = new Uint8Array(Buffer.from(base64Data, "base64"));
 			const sequence = encodeSixel(decoded, targetWidthPx, targetHeightPx);
-			return { sequence, rows: fit.rows };
+			return { sequence, rows };
 		} catch {
 			return null;
 		}

package/src/terminal.ts

@@ -12,12 +12,12 @@ import {
 import { setKittyProtocolActive } from "./keys";
 import { StdinBuffer } from "./stdin-buffer";
 import {
+	isInsideTerminalMultiplexer,
 	isInsideTmux,
 	NotifyProtocol,
 	setCellDimensions,
 	setOsc99Supported,
 	TERMINAL,
-	wrapTmuxPassthrough,
 } from "./terminal-capabilities";
 import { type HangulCompatibilityJamoWidth, setHangulCompatibilityJamoWidth } from "./utils";
 
@@ -1042,6 +1042,15 @@ export class ProcessTerminal implements Terminal {
 
 	#shouldQueryOsc99Support(): boolean {
 		if (TERMINAL.notifyProtocol !== NotifyProtocol.Osc99) return false;
+		// Never probe inside a terminal multiplexer. tmux/screen forward the
+		// passthrough-wrapped `p=?` query to the outer terminal, but cannot route
+		// the capability reply back to the pane that sent it (tmux/tmux#4386,
+		// tmux/tmux#3964), so the reply leaks into the pane as literal text and
+		// its bytes perturb input (issue #5582 — the notification sibling of the
+		// graphics-probe leak #5381). Rich notifications fall back to the
+		// single-line OSC 99 form until confirmation, and delivery still uses the
+		// passthrough/BEL path (#3395).
+		if (isInsideTerminalMultiplexer($env)) return false;
 		return !isBunTestRuntime() || $env.PI_TUI_OSC99_PROBE === "1";
 	}
 
@@ -1055,14 +1064,9 @@ export class ProcessTerminal implements Terminal {
 		const id = `omp-probe-${nextOsc99ProbeId++}`;
 		this.#osc99PendingId = id;
 		this.#da1SentinelOwners.push({ kind: "osc99Probe", id });
-		// Wrap the probe under tmux so terminals behind `allow-passthrough on`
-		// can still respond (mirroring how `TerminalInfo.sendNotification`
-		// wraps notification deliveries). Without it the probe is swallowed
-		// inside tmux even when the outer terminal speaks OSC 99, and rich
-		// notifications stay permanently downgraded to the single-line fallback.
-		const probe = `\x1b]99;i=${id}:p=?;\x1b\\`;
-		const sequence = isInsideTmux() ? wrapTmuxPassthrough(probe) : probe;
-		this.#safeWrite(`${sequence}\x1b[c`);
+		// The probe never runs under a multiplexer (see #shouldQueryOsc99Support),
+		// so it is always sent directly to the terminal.
+		this.#safeWrite(`\x1b]99;i=${id}:p=?;\x1b\\\x1b[c`);
 	}
 
 	#handleOsc99CapabilityResponse(metaRaw: string, payload: string): boolean {