@code-yeongyu/senpi-tui 2026.9.30 → 2026.10.1-2

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import type { CellDimensions, ImageDimensions } from "./terminal-image.ts";
 export { Marked, type Token, type Tokens } from "marked";
 export { AltScreenSearchComponent, type AltScreenSearchMatch, type AltScreenSearchSegment, findAltScreenSearchMatches, getAltScreenSearchMatchKey, } from "./alt-screen-search.ts";
 export { type AutocompleteItem, type AutocompleteProvider, type AutocompleteSuggestions, CombinedAutocompleteProvider, type SlashCommand, } from "./autocomplete.ts";
+export { backgroundAnsi, type Color, type ColorMixSpace, colorToHex, colorToOkhsl, colorToOklch, colorToRgb, foregroundAnsi, type IndexedColor, indexedColor, mixColors, type OkhslChannels, type OklchChannels, type OklchColorValue, okhslColor, oklchColor, parseColor, type RgbColorValue, rgbColor, styleText, styleTextWithAnsi, type TerminalColorMode, type TextAttributes, type TextStyle, } from "./colors.ts";
 export { Box } from "./components/box.ts";
 export { CancellableLoader } from "./components/cancellable-loader.ts";
 export { Editor, type EditorOptions, type EditorTheme, } from "./components/editor.ts";
@@ -25,15 +26,17 @@ export { getKeybindings, type Keybinding, type KeybindingConflict, type Keybindi
 export { decodeKittyPrintable, isKeyRelease, isKeyRepeat, isKittyProtocolActive, Key, type KeyEventType, type KeyId, matchesKey, parseKey, setKittyProtocolActive, } from "./keys.ts";
 export { decodeMouseButton, isMouseSequence, MOUSE_TRACKING, MouseClickSynthesizer, parseSgrMouseEvent, parseWheelEvent, type SgrMouseEvent, toTuiMouseEvent, type WheelEvent, } from "./mouse-input.ts";
 export { getNativeClipboard, type NativeClipboard } from "./native-platform.ts";
+export { oklabToOkhslLightness } from "./oklab.ts";
 export { type EditorPasteState, expandPasteMarkers } from "./paste-markers.ts";
 export { StdinBuffer, type StdinBufferEventMap, type StdinBufferOptions } from "./stdin-buffer.ts";
 export { type CursorPosition, ProcessTerminal, type ProcessTerminalOptions, type Terminal } from "./terminal.ts";
-export { parseOsc11BackgroundColor, parseTerminalColorSchemeReport, type RgbColor, type TerminalColorScheme, } from "./terminal-colors.ts";
+export { parseTerminalColorSchemeReport, type RgbColor, type TerminalColorScheme, type TerminalColors, } from "./terminal-colors.ts";
 export declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
-export { allocateImageId, buildKittyPlaceholderRow, type CellDimensions, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getWebpDimensions, hyperlink, type ImageDimensions, type ImageProtocol, type ImageRenderOptions, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, type TerminalCapabilities, type TmuxPassthroughState, wrapTmuxPassthrough, } from "./terminal-image.ts";
+export { allocateImageId, buildKittyPlaceholderRow, type CellDimensions, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getTerminalColorMode, getWebpDimensions, hyperlink, type ImageDimensions, type ImageProtocol, type ImageRenderOptions, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, type TerminalCapabilities, type TmuxPassthroughState, wrapTmuxPassthrough, } from "./terminal-image.ts";
 export { sanitizeTerminalLabel, shortenImagePath } from "./terminal-text.ts";
 export { type Component, Container, CURSOR_MARKER, compositeTuiLine, type Focusable, isFocusable, isViewportTUI, type OverlayAnchor, type OverlayBounds, type OverlayHandle, type OverlayMargin, type OverlayOptions, type OverlayUnfocusOptions, type SizeValue, TUI, type TuiInputListener, type TuiInputListenerResult, type TuiMode, type TuiMouseButton, type TuiMouseEvent, type TuiMouseEventResult, type TuiMouseEventType, type TuiStopOptions, type ViewportTUI, } from "./tui.ts";
 export { TuiAltScreen, type TuiAltScreenOptions } from "./tui-alt-screen.ts";
 export { TuiMainScreen, type TuiMainScreenRenderState } from "./tui-main-screen.ts";
 export { getGraphemeSegmenter, getOsc8LinkAtColumn, getWordSegmenter, sliceByColumn, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "./utils.ts";
+export type { WheelScrollLines } from "./wheel-scroll.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -5,6 +5,8 @@ export { Marked } from "marked";
 export { AltScreenSearchComponent, findAltScreenSearchMatches, getAltScreenSearchMatchKey, } from "./alt-screen-search.js";
 // Autocomplete support
 export { CombinedAutocompleteProvider, } from "./autocomplete.js";
+// Colors and styling
+export { backgroundAnsi, colorToHex, colorToOkhsl, colorToOklch, colorToRgb, foregroundAnsi, indexedColor, mixColors, okhslColor, oklchColor, parseColor, rgbColor, styleText, styleTextWithAnsi, } from "./colors.js";
 // Components
 export { Box } from "./components/box.js";
 export { CancellableLoader } from "./components/cancellable-loader.js";
@@ -33,18 +35,19 @@ export { decodeKittyPrintable, isKeyRelease, isKeyRepeat, isKittyProtocolActive,
 export { decodeMouseButton, isMouseSequence, MOUSE_TRACKING, MouseClickSynthesizer, parseSgrMouseEvent, parseWheelEvent, toTuiMouseEvent, } from "./mouse-input.js";
 // Native platform integration
 export { getNativeClipboard } from "./native-platform.js";
+export { oklabToOkhslLightness } from "./oklab.js";
 export { expandPasteMarkers } from "./paste-markers.js";
 // Input buffering for batch splitting
 export { StdinBuffer } from "./stdin-buffer.js";
 // Terminal interface and implementations
 export { ProcessTerminal } from "./terminal.js";
 // Terminal colors
-export { parseOsc11BackgroundColor, parseTerminalColorSchemeReport, } from "./terminal-colors.js";
+export { parseTerminalColorSchemeReport, } from "./terminal-colors.js";
 // Terminal image support
 export function calculateImageRows(imageDimensions, targetWidthCells, cellDimensions = { widthPx: 9, heightPx: 18 }) {
     return calculateImageCellSize(imageDimensions, targetWidthCells, undefined, cellDimensions).rows;
 }
-export { allocateImageId, buildKittyPlaceholderRow, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getWebpDimensions, hyperlink, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, wrapTmuxPassthrough, } from "./terminal-image.js";
+export { allocateImageId, buildKittyPlaceholderRow, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getTerminalColorMode, getWebpDimensions, hyperlink, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, wrapTmuxPassthrough, } from "./terminal-image.js";
 export { sanitizeTerminalLabel, shortenImagePath } from "./terminal-text.js";
 export { Container, CURSOR_MARKER, compositeTuiLine, isFocusable, isViewportTUI, TUI, } from "./tui.js";
 export { TuiAltScreen } from "./tui-alt-screen.js";

package/dist/native-platform.d.ts

@@ -4,6 +4,8 @@ export interface NativeClipboard {
     getText(): Promise<string | null | undefined>;
     /** Undefined means unavailable, null means no image; transfer failures reject. */
     getImage(): Promise<Uint8Array | null | undefined>;
+    /** POSIX paths of file URLs on the clipboard. Undefined means unsupported, null means no files. */
+    getFilePaths?(): Promise<string[] | null | undefined>;
     /** Linux uses command-line tools to retain clipboard ownership instead. */
     setText?(text: string): Promise<void>;
 }

package/dist/oklab.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Oklab and OKHSL <-> sRGB conversion. `colors.ts` builds its OKLCH, OKHSL, and color mixing on it.
+ *
+ * Oklab and OKHSL are Björn Ottosson's color spaces; OKHSL's saturation is relative to the sRGB gamut at
+ * each hue and lightness. This is a port of his reference implementation (https://bottosson.github.io/posts/colorpicker/),
+ * Copyright (c) 2021 Björn Ottosson, used under the MIT license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions: The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+ * KIND, EXPRESS OR IMPLIED.
+ */
+import type { RgbColor } from "./terminal-colors.ts";
+type Vector = [number, number, number];
+/** Oklab lightness to OKHSL lightness. */
+export declare const oklabToOkhslLightness: (x: number) => number;
+/** Oklab [L, a, b] to linear sRGB [r, g, b] (0-1, may leave the gamut). */
+export declare function oklabToLinearSrgb(lab: Vector): Vector;
+/** sRGB channels (0-255) to Oklab [L, a, b]. */
+export declare function rgbToOklab({ r, g, b }: RgbColor): Vector;
+/** Linear sRGB [r, g, b] to sRGB channels (0-255, rounded), clipping out-of-gamut channels. */
+export declare function linearSrgbToRgb(linear: Vector): RgbColor;
+/**
+ * Convert OKHSL to sRGB channels (0-255, rounded), clipping out-of-gamut channels.
+ * @param hue Hue in degrees.
+ * @param saturation Saturation, 0-1.
+ * @param lightness Lightness, 0-1.
+ */
+export declare function okhslToRgb(hue: number, saturation: number, lightness: number): RgbColor;
+/**
+ * Convert sRGB channels (0-255) to OKHSL.
+ * @returns Hue `h` in degrees (0 for grays), saturation `s` and lightness `l` 0-1.
+ */
+export declare function rgbToOkhsl(rgb: RgbColor): {
+    h: number;
+    s: number;
+    l: number;
+};
+export {};
+//# sourceMappingURL=oklab.d.ts.map

package/dist/oklab.js

@@ -0,0 +1,210 @@
+/**
+ * Oklab and OKHSL <-> sRGB conversion. `colors.ts` builds its OKLCH, OKHSL, and color mixing on it.
+ *
+ * Oklab and OKHSL are Björn Ottosson's color spaces; OKHSL's saturation is relative to the sRGB gamut at
+ * each hue and lightness. This is a port of his reference implementation (https://bottosson.github.io/posts/colorpicker/),
+ * Copyright (c) 2021 Björn Ottosson, used under the MIT license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions: The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+ * KIND, EXPRESS OR IMPLIED.
+ */
+const multiply = (m, [x, y, z]) => m.map((row) => row[0] * x + row[1] * y + row[2] * z);
+// ============================================================================
+// OKHSL <-> sRGB
+// ============================================================================
+const LINEAR_SRGB_TO_LMS = [
+    [0.4122214694707629, 0.5363325372617349, 0.0514459932675022],
+    [0.2119034958178251, 0.6806995506452344, 0.1073969535369405],
+    [0.0883024591900564, 0.2817188391361215, 0.6299787016738222],
+];
+const LMS_TO_LAB = [
+    [0.210454268309314, 0.793617774702305, -0.0040720430116193],
+    [1.9779985324311684, -2.42859224204858, 0.450593709617411],
+    [0.0259040424655478, 0.7827717124575296, -0.8086757549230774],
+];
+const LAB_TO_LMS = [
+    [1, 0.3963377773761749, 0.2158037573099136],
+    [1, -0.1055613458156586, -0.0638541728258133],
+    [1, -0.0894841775298119, -1.2914855480194092],
+];
+const LMS_TO_LINEAR_SRGB = [
+    [4.0767416360759583, -3.3077115392580629, 0.2309699031821043],
+    [-1.2684379732850315, 2.6097573492876882, -0.341319376002657],
+    [-0.0041960761386756, -0.7034186179359362, 1.7076146940746117],
+];
+/**
+ * Per sRGB channel (red, green, blue): the (a, b) half-plane where that channel clips
+ * first, and the polynomial approximating the maximum saturation there.
+ */
+const SATURATION_FIT = [
+    [
+        [-1.8817031, -0.80936501],
+        [1.19086277, 1.76576728, 0.59662641, 0.75515197, 0.56771245],
+    ],
+    [
+        [1.8144408, -1.19445267],
+        [0.73956515, -0.45954404, 0.08285427, 0.12541073, -0.14503204],
+    ],
+    [
+        [0.13110758, 1.81333971],
+        [1.35733652, -0.00915799, -1.1513021, -0.50559606, 0.00692167],
+    ],
+];
+const K1 = 0.206;
+const K2 = 0.03;
+const K3 = (1 + K1) / (1 + K2);
+/** Oklab lightness to OKHSL lightness. */
+export const oklabToOkhslLightness = (x) => 0.5 * (K3 * x - K1 + Math.sqrt((K3 * x - K1) ** 2 + 4 * K2 * K3 * x));
+/** OKHSL lightness to Oklab lightness. */
+const okhslToOklabLightness = (x) => (x * x + K1 * x) / (K3 * (x + K2));
+/** sRGB transfer function: linear to encoded channel, both 0-1. */
+const linearToSrgb = (value) => value > 0.0031308 ? 1.055 * value ** (1 / 2.4) - 0.055 : 12.92 * value;
+/** Inverse sRGB transfer function: encoded to linear channel, both 0-1. */
+const srgbToLinear = (value) => (value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4);
+/** Oklab [L, a, b] to linear sRGB [r, g, b] (0-1, may leave the gamut). */
+export function oklabToLinearSrgb(lab) {
+    return multiply(LMS_TO_LINEAR_SRGB, multiply(LAB_TO_LMS, lab).map((value) => value ** 3));
+}
+/** Linear sRGB [r, g, b] (0-1) to Oklab [L, a, b]. */
+function linearSrgbToOklab(rgb) {
+    return multiply(LMS_TO_LAB, multiply(LINEAR_SRGB_TO_LMS, rgb).map(Math.cbrt));
+}
+/** sRGB channels (0-255) to Oklab [L, a, b]. */
+export function rgbToOklab({ r, g, b }) {
+    return linearSrgbToOklab([r / 255, g / 255, b / 255].map(srgbToLinear));
+}
+/** Linear sRGB [r, g, b] to sRGB channels (0-255, rounded), clipping out-of-gamut channels. */
+export function linearSrgbToRgb(linear) {
+    const [r, g, b] = linear.map((value) => Math.round(Math.min(1, Math.max(0, linearToSrgb(value))) * 255));
+    return { r, g, b };
+}
+/** Rate of change of each cube-root LMS component along a chroma direction (a, b). */
+function lmsSlopes(a, b) {
+    return [LAB_TO_LMS[0], LAB_TO_LMS[1], LAB_TO_LMS[2]].map((row) => row[1] * a + row[2] * b);
+}
+/** Largest saturation (C/L) inside sRGB for hue (a, b): polynomial fit plus one Halley step. */
+function maxSaturation(a, b) {
+    const channel = SATURATION_FIT.findIndex(([[x, y]], index) => index === 2 || x * a + y * b > 1);
+    const [k0, k1, k2, k3, k4] = SATURATION_FIT[channel][1];
+    const weights = LMS_TO_LINEAR_SRGB[channel];
+    const saturation = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+    const slopes = lmsSlopes(a, b);
+    const base = slopes.map((k) => 1 + saturation * k);
+    const dot = (values) => values.reduce((sum, value, index) => sum + weights[index] * value, 0);
+    const f = dot(base.map((value) => value ** 3));
+    const f1 = dot(base.map((value, index) => 3 * slopes[index] * value ** 2));
+    const f2 = dot(base.map((value, index) => 6 * slopes[index] ** 2 * value));
+    return saturation - (f * f1) / (f1 * f1 - 0.5 * f * f2);
+}
+/** Oklab lightness and chroma of the most saturated sRGB color of hue (a, b). */
+function cusp(a, b) {
+    const saturation = maxSaturation(a, b);
+    const lightness = Math.cbrt(1 / Math.max(...oklabToLinearSrgb([1, saturation * a, saturation * b])));
+    return [lightness, lightness * saturation];
+}
+/** Chroma where the constant-lightness line at `lightness` leaves the sRGB gamut. */
+function maxChroma(a, b, lightness, [cuspL, cuspC]) {
+    if (lightness <= cuspL)
+        return (cuspC * lightness) / cuspL;
+    // Upper half: triangle edge, then one Halley step against each channel reaching 1.
+    const t = (cuspC * (lightness - 1)) / (cuspL - 1);
+    const slopes = lmsSlopes(a, b);
+    const lms = slopes.map((k) => lightness + t * k);
+    const cubes = lms.map((value) => value ** 3);
+    const first = lms.map((value, index) => 3 * slopes[index] * value ** 2);
+    const second = lms.map((value, index) => 6 * slopes[index] ** 2 * value);
+    const dot = (row, values) => row[0] * values[0] + row[1] * values[1] + row[2] * values[2];
+    const steps = LMS_TO_LINEAR_SRGB.map((row) => {
+        const f = dot(row, cubes) - 1;
+        const f1 = dot(row, first);
+        const f2 = dot(row, second);
+        const u = f1 / (f1 * f1 - 0.5 * f * f2);
+        return u >= 0 ? -f * u : Number.MAX_VALUE;
+    });
+    return t + Math.min(...steps);
+}
+/** OKHSL's chroma reference points at lightness L and hue (a, b): [c0, cMid, cMax]. */
+function chromaStops(L, a, b) {
+    const peak = cusp(a, b);
+    const cMax = maxChroma(a, b, L, peak);
+    const k = cMax / Math.min(L * (peak[1] / peak[0]), (1 - L) * (peak[1] / (1 - peak[0])));
+    const midS = 0.11516993 +
+        1 /
+            (7.4477897 +
+                4.1590124 * b +
+                a *
+                    (-2.19557347 +
+                        1.75198401 * b +
+                        a * (-2.13704948 - 10.02301043 * b + a * (-4.24894561 + 5.38770819 * b + 4.69891013 * a))));
+    const midT = 0.11239642 +
+        1 /
+            (1.6132032 -
+                0.68124379 * b +
+                a *
+                    (0.40370612 +
+                        0.90148123 * b +
+                        a * (-0.27087943 + 0.6122399 * b + a * (0.00299215 - 0.45399568 * b - 0.14661872 * a))));
+    const cMid = 0.9 * k * Math.sqrt(Math.sqrt(1 / (1 / (L * midS) ** 4 + 1 / ((1 - L) * midT) ** 4)));
+    const c0 = Math.sqrt(1 / (1 / (L * 0.4) ** 2 + 1 / ((1 - L) * 0.8) ** 2));
+    return [c0, cMid, cMax];
+}
+/**
+ * Convert OKHSL to sRGB channels (0-255, rounded), clipping out-of-gamut channels.
+ * @param hue Hue in degrees.
+ * @param saturation Saturation, 0-1.
+ * @param lightness Lightness, 0-1.
+ */
+export function okhslToRgb(hue, saturation, lightness) {
+    const L = okhslToOklabLightness(lightness);
+    let lab = [L, 0, 0];
+    if (L > 0 && L < 1 && saturation > 0) {
+        const angle = (2 * Math.PI * (((hue % 360) + 360) % 360)) / 360;
+        const a = Math.cos(angle);
+        const b = Math.sin(angle);
+        const [c0, cMid, cMax] = chromaStops(L, a, b);
+        // Chroma rises from 0 through cMid at s = 0.8 to cMax at s = 1.
+        let chroma;
+        if (saturation < 0.8) {
+            const t = 1.25 * saturation;
+            const k1 = 0.8 * c0;
+            chroma = (t * k1) / (1 - (1 - k1 / cMid) * t);
+        }
+        else {
+            const t = 5 * (saturation - 0.8);
+            const k1 = (0.2 * cMid ** 2 * 1.25 ** 2) / c0;
+            chroma = cMid + (t * k1) / (1 - (1 - k1 / (cMax - cMid)) * t);
+        }
+        lab = [L, chroma * a, chroma * b];
+    }
+    return linearSrgbToRgb(oklabToLinearSrgb(lab));
+}
+/**
+ * Convert sRGB channels (0-255) to OKHSL.
+ * @returns Hue `h` in degrees (0 for grays), saturation `s` and lightness `l` 0-1.
+ */
+export function rgbToOkhsl(rgb) {
+    const [L, labA, labB] = rgbToOklab(rgb);
+    const chroma = Math.hypot(labA, labB);
+    const lightness = oklabToOkhslLightness(L);
+    if (chroma < 1e-9 || lightness <= 0 || lightness >= 1)
+        return { h: 0, s: 0, l: lightness };
+    const hue = ((Math.atan2(labB, labA) * 180) / Math.PI + 360) % 360;
+    const [c0, cMid, cMax] = chromaStops(L, labA / chroma, labB / chroma);
+    let saturation;
+    if (chroma < cMid) {
+        const k1 = 0.8 * c0;
+        saturation = 0.8 * (chroma / (k1 + (1 - k1 / cMid) * chroma));
+    }
+    else {
+        const k1 = (0.2 * cMid ** 2 * 1.25 ** 2) / c0;
+        const offset = chroma - cMid;
+        saturation = 0.8 + 0.2 * (offset / (k1 + (1 - k1 / (cMax - cMid)) * offset));
+    }
+    return { h: hue, s: Math.min(1, Math.max(0, saturation)), l: lightness };
+}
+//# sourceMappingURL=oklab.js.map

package/dist/terminal-capabilities.js

@@ -9,7 +9,7 @@ export function detectTerminalCapabilities(env = process.env, platform = process
     const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
     const terminalEmulator = env.TERMINAL_EMULATOR ?? "";
     const colorTerm = env.COLORTERM ?? "";
-    const trueColor = colorTerm === "truecolor" || colorTerm === "24bit";
+    const trueColor = colorTerm === "truecolor" || colorTerm === "24bit" || term.toLowerCase().endsWith("-direct");
     if (env.TMUX || term.startsWith("tmux")) {
         const state = probeTmuxImageState(env, execTmux);
         const override = parseTmuxKittyTerminalOverride(env.PI_TUI_TMUX_KITTY_TERMINAL);

package/dist/terminal-colors.d.ts

@@ -4,7 +4,24 @@ export interface RgbColor {
     b: number;
 }
 export type TerminalColorScheme = "dark" | "light";
-export declare function isOsc11BackgroundColorResponse(data: string): boolean;
-export declare function parseOsc11BackgroundColor(data: string): RgbColor | undefined;
+/** Colors the terminal reports for its current theme. */
+export interface TerminalColors {
+    /** Default foreground (OSC 10). */
+    foreground?: RgbColor;
+    /** Default background (OSC 11). */
+    background?: RgbColor;
+    /** ANSI colors 0-15 (OSC 4). Only set when the terminal reported all 16. */
+    palette?: RgbColor[];
+}
+/** What an OSC color reply reports: the default foreground (OSC 10), background (OSC 11), or a palette index (OSC 4). */
+export type OscColorTarget = "foreground" | "background" | number;
+/**
+ * Parse an OSC 10, 11, or 4 color reply. Returns undefined when `data` is not such a reply;
+ * `rgb` is undefined when it is a reply with an unparseable color.
+ */
+export declare function parseOscColorResponse(data: string): {
+    target: OscColorTarget;
+    rgb: RgbColor | undefined;
+} | undefined;
 export declare function parseTerminalColorSchemeReport(data: string): TerminalColorScheme | undefined;
 //# sourceMappingURL=terminal-colors.d.ts.map

package/dist/terminal-colors.js

@@ -15,17 +15,22 @@ function parseOscHexChannel(channel) {
     }
     return Math.round((parseInt(channel, 16) / max) * 255);
 }
-const OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN = /^\x1b\]11;([^\x07\x1b]*)(?:\x07|\x1b\\)$/i;
+const OSC_COLOR_RESPONSE_PATTERN = /^\x1b\](?:(1[01])|4;(\d{1,3}));([^\x07\x1b]*)(?:\x07|\x1b\\)$/i;
 const COLOR_SCHEME_REPORT_PATTERN = /^(?:\x1b\[\?997;(1|2)n)+$/;
-export function isOsc11BackgroundColorResponse(data) {
-    return OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN.test(data);
-}
-export function parseOsc11BackgroundColor(data) {
-    const match = data.match(OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN);
+/**
+ * Parse an OSC 10, 11, or 4 color reply. Returns undefined when `data` is not such a reply;
+ * `rgb` is undefined when it is a reply with an unparseable color.
+ */
+export function parseOscColorResponse(data) {
+    const match = data.match(OSC_COLOR_RESPONSE_PATTERN);
     if (!match) {
         return undefined;
     }
-    const value = match[1].trim();
+    const target = match[1] === "10" ? "foreground" : match[1] === "11" ? "background" : Number.parseInt(match[2], 10);
+    return { target, rgb: parseOscColorValue(match[3]) };
+}
+function parseOscColorValue(rawValue) {
+    const value = rawValue.trim();
     if (value.startsWith("#")) {
         const hex = value.slice(1);
         if (/^[0-9a-f]{6}$/i.test(hex)) {

package/dist/terminal-image.d.ts

@@ -1,3 +1,4 @@
+import type { TerminalColorMode } from "./colors.ts";
 import { type DetectedTerminalCapabilities, type TerminalCapabilities } from "./terminal-capabilities.ts";
 export type { ImageProtocol, TerminalCapabilities } from "./terminal-capabilities.ts";
 export { outerKittyGraphicsMode } from "./terminal-capabilities.ts";
@@ -28,6 +29,7 @@ export declare function getCellDimensions(): CellDimensions;
 export declare function setCellDimensions(dims: CellDimensions): void;
 export declare function detectCapabilities(tmuxForwardsHyperlink?: () => boolean, tmuxPassthroughState?: () => TmuxPassthroughState): DetectedTerminalCapabilities;
 export declare function getCapabilities(): TerminalCapabilities;
+export declare function getTerminalColorMode(capabilities?: TerminalCapabilities): TerminalColorMode;
 export declare function resetCapabilitiesCache(): void;
 /** Override selected auto-detected capabilities. */
 export declare function setCapabilityOverrides(overrides: Partial<TerminalCapabilities>): void;
@@ -109,7 +111,7 @@ export declare function getKittyImageMetadata(line: string): KittyImageMetadata
 /** Build a placement-only command for an image line emitted by {@link renderImage}. */
 export declare function getKittyImagePlacement(line: string): KittyImagePlacement | undefined;
 export declare function cropKittyImageLine(line: string, hiddenRows: number, visibleRows: number): string;
-export declare function calculateImageCellSize(imageDimensions: ImageDimensions, maxWidthCells: number, maxHeightCells?: number, cellDimensions?: CellDimensions): ImageCellSize;
+export declare function calculateImageCellSize(imageDimensions: ImageDimensions, maxWidthCells: number, maxHeightCells?: number, cellDimensions?: CellDimensions, optimizeAspectRatio?: boolean): ImageCellSize;
 export declare function getPngDimensions(base64Data: string): ImageDimensions | null;
 export declare function getJpegDimensions(base64Data: string): ImageDimensions | null;
 export declare function getGifDimensions(base64Data: string): ImageDimensions | null;

package/dist/terminal-image.js

@@ -35,7 +35,7 @@ function detectCapabilitiesFromEnvironment(tmuxForwardsHyperlink) {
     const terminalEmulator = process.env.TERMINAL_EMULATOR?.toLowerCase() || "";
     const term = process.env.TERM?.toLowerCase() || "";
     const colorTerm = process.env.COLORTERM?.toLowerCase() || "";
-    const hasTrueColorHint = colorTerm === "truecolor" || colorTerm === "24bit";
+    const hasTrueColorHint = colorTerm === "truecolor" || colorTerm === "24bit" || term.endsWith("-direct");
     const isWindowsConsole = process.platform === "win32";
     // Emit OSC 8 hyperlinks only when tmux confirms it forwards.
     // Image protocols are unreliable under tmux, so leave `images: null`.
@@ -132,6 +132,9 @@ export function getCapabilities() {
     }
     return cachedCapabilities;
 }
+export function getTerminalColorMode(capabilities = getCapabilities()) {
+    return capabilities.trueColor ? "truecolor" : "256color";
+}
 export function resetCapabilitiesCache() {
     cachedCapabilities = null;
 }
@@ -415,7 +418,15 @@ export function cropKittyImageLine(line, hiddenRows, visibleRows) {
     controls.push(`y=${sourceY}`, `h=${sourceHeight}`, `r=${croppedRows}`);
     return `${line.slice(0, match.index)}\x1b_G${controls.join(",")};${line.slice(match.index + match[0].length)}`;
 }
-export function calculateImageCellSize(imageDimensions, maxWidthCells, maxHeightCells, cellDimensions = { widthPx: 9, heightPx: 18 }) {
+function chooseLessDistortedCellCount(upperCount, idealCount) {
+    if (upperCount <= 1)
+        return upperCount;
+    const lowerCount = upperCount - 1;
+    const upperDistortion = Math.max(upperCount / idealCount, idealCount / upperCount);
+    const lowerDistortion = Math.max(lowerCount / idealCount, idealCount / lowerCount);
+    return lowerDistortion < upperDistortion ? lowerCount : upperCount;
+}
+export function calculateImageCellSize(imageDimensions, maxWidthCells, maxHeightCells, cellDimensions = { widthPx: 9, heightPx: 18 }, optimizeAspectRatio = false) {
     const maxWidth = Math.max(1, Math.floor(maxWidthCells));
     const maxHeight = maxHeightCells === undefined ? undefined : Math.max(1, Math.floor(maxHeightCells));
     const imageWidth = Math.max(1, imageDimensions.widthPx);
@@ -425,12 +436,24 @@ export function calculateImageCellSize(imageDimensions, maxWidthCells, maxHeight
     const scale = Math.min(widthScale, heightScale);
     const scaledWidthPx = imageWidth * scale;
     const scaledHeightPx = imageHeight * scale;
-    const columns = Math.ceil(scaledWidthPx / cellDimensions.widthPx);
-    const rows = Math.ceil(scaledHeightPx / cellDimensions.heightPx);
-    return {
-        columns: Math.max(1, Math.min(maxWidth, columns)),
-        rows: Math.max(1, maxHeight === undefined ? rows : Math.min(maxHeight, rows)),
-    };
+    let columns = Math.max(1, Math.min(maxWidth, Math.ceil(scaledWidthPx / cellDimensions.widthPx)));
+    const heightRows = scaledHeightPx / cellDimensions.heightPx;
+    let rows = Math.max(1, Math.ceil(heightRows));
+    if (maxHeight !== undefined) {
+        rows = Math.min(maxHeight, rows);
+    }
+    if (!optimizeAspectRatio) {
+        return { columns, rows };
+    }
+    if (widthScale <= heightScale) {
+        const idealRows = (columns * cellDimensions.widthPx * imageHeight) / (imageWidth * cellDimensions.heightPx);
+        rows = chooseLessDistortedCellCount(rows, idealRows);
+    }
+    else {
+        const idealColumns = (rows * cellDimensions.heightPx * imageWidth) / (imageHeight * cellDimensions.widthPx);
+        columns = chooseLessDistortedCellCount(columns, idealColumns);
+    }
+    return { columns, rows };
 }
 export function getPngDimensions(base64Data) {
     try {
@@ -564,7 +587,8 @@ export function renderImage(base64Data, imageDimensions, options = {}) {
         return null;
     }
     const maxWidth = options.maxWidthCells ?? 80;
-    const size = calculateImageCellSize(imageDimensions, maxWidth, options.maxHeightCells, getCellDimensions());
+    // Reduce Kitty's cell-aligned distortion without shrinking iTerm2 reservations.
+    const size = calculateImageCellSize(imageDimensions, maxWidth, options.maxHeightCells, getCellDimensions(), caps.images === "kitty");
     if (caps.images === "kitty" && caps.kittyUnicodePlaceholders) {
         // Virtual placement: transmit once, then show the image with plain-text
         // placeholder cells. Under tmux the placeholder cells move/clip with the

package/dist/terminal.d.ts

@@ -97,6 +97,8 @@ export declare class ProcessTerminal implements Terminal {
     private _kittyProtocolActive;
     private _modifyOtherKeysActive;
     private keyboardProtocolPushed;
+    /** DA1 replies owed to keyboard protocol queries. Later DA1 replies answer other queries and are forwarded. */
+    private pendingKeyboardProtocolDeviceAttributes;
     private keyboardProtocolNegotiationBuffer;
     private discardingPrivateResponse;
     private keyboardProtocolBufferFlushTimer?;
@@ -143,6 +145,7 @@ export declare class ProcessTerminal implements Terminal {
      */
     private queryAndEnableKittyProtocol;
     private handleKeyboardProtocolNegotiationSequence;
+    /** Returns the parsed negotiation reply with its full (possibly reassembled) sequence. */
     private readKeyboardProtocolNegotiationSequence;
     private setKeyboardProtocolNegotiationBuffer;
     private clearKeyboardProtocolNegotiationBuffer;

package/dist/terminal.js

@@ -188,6 +188,8 @@ export class ProcessTerminal {
         this._kittyProtocolActive = false;
         this._modifyOtherKeysActive = false;
         this.keyboardProtocolPushed = false;
+        /** DA1 replies owed to keyboard protocol queries. Later DA1 replies answer other queries and are forwarded. */
+        this.pendingKeyboardProtocolDeviceAttributes = 0;
         this.keyboardProtocolNegotiationBuffer = "";
         this.discardingPrivateResponse = false;
         this.writeLogPath = (() => {
@@ -399,15 +401,15 @@ export class ProcessTerminal {
                     return;
                 }
             }
-            const negotiationSequence = this.readKeyboardProtocolNegotiationSequence(sequence);
-            if (negotiationSequence === "pending") {
+            const negotiation = this.readKeyboardProtocolNegotiationSequence(sequence);
+            if (negotiation === "pending") {
                 this.scheduleKeyboardProtocolNegotiationBufferFlush();
                 return; // Wait briefly for the rest of a split Kitty response.
             }
-            if (this.handleKeyboardProtocolNegotiationSequence(negotiationSequence)) {
+            if (negotiation && this.handleKeyboardProtocolNegotiationSequence(negotiation.parsed)) {
                 return;
             }
-            this.forwardInputSequence(sequence);
+            this.forwardInputSequence(negotiation?.sequence ?? sequence);
         });
         // Re-wrap paste content with bracketed paste markers for existing editor handling
         this.stdinBuffer.on("paste", (content) => {
@@ -443,12 +445,11 @@ export class ProcessTerminal {
             this.enableModifyOtherKeys();
         }
         this.keyboardProtocolPushed = true;
+        this.pendingKeyboardProtocolDeviceAttributes += 1;
         this.clearKeyboardProtocolNegotiationBuffer();
         this.rawWrite(KITTY_KEYBOARD_PROTOCOL_QUERY);
     }
     handleKeyboardProtocolNegotiationSequence(negotiationSequence) {
-        if (!negotiationSequence)
-            return false;
         this.clearKeyboardProtocolNegotiationBuffer();
         if (negotiationSequence.type === "cursor-position") {
             if (this.cursorQuery?.issued && this.cursorQuery.tmuxPane === undefined) {
@@ -457,6 +458,11 @@ export class ProcessTerminal {
             }
             return true;
         }
+        if (negotiationSequence.type === "device-attributes") {
+            if (this.pendingKeyboardProtocolDeviceAttributes === 0)
+                return false;
+            this.pendingKeyboardProtocolDeviceAttributes -= 1;
+        }
         this.keyboardNegotiationSettled = true;
         this.issueCursorQuery();
         if (negotiationSequence.type === "kitty-flags") {
@@ -477,13 +483,14 @@ export class ProcessTerminal {
         }
         return true;
     }
+    /** Returns the parsed negotiation reply with its full (possibly reassembled) sequence. */
     readKeyboardProtocolNegotiationSequence(sequence) {
         if (this.keyboardProtocolNegotiationBuffer) {
             const bufferedSequence = this.keyboardProtocolNegotiationBuffer + sequence;
             const negotiationSequence = parseKeyboardProtocolNegotiationSequence(bufferedSequence);
             if (negotiationSequence) {
                 this.clearKeyboardProtocolNegotiationBuffer();
-                return negotiationSequence;
+                return { parsed: negotiationSequence, sequence: bufferedSequence };
             }
             if (isKeyboardProtocolNegotiationSequencePrefix(bufferedSequence)) {
                 this.setKeyboardProtocolNegotiationBuffer(bufferedSequence);
@@ -493,7 +500,7 @@ export class ProcessTerminal {
         }
         const negotiationSequence = parseKeyboardProtocolNegotiationSequence(sequence);
         if (negotiationSequence)
-            return negotiationSequence;
+            return { parsed: negotiationSequence, sequence };
         if (isKeyboardProtocolNegotiationSequencePrefix(sequence)) {
             this.setKeyboardProtocolNegotiationBuffer(sequence);
             return "pending";

package/dist/tui-alt-screen.d.ts

@@ -1,8 +1,12 @@
 import type { Terminal } from "./terminal.ts";
 import { type Component, TuiBase, type TuiStopOptions, VIEWPORT_TUI, type ViewportTUI } from "./tui.ts";
+import { type WheelScrollLines } from "./wheel-scroll.ts";
 export interface TuiAltScreenOptions {
-    /** Number of logical lines moved for each mouse-wheel event. */
-    wheelScrollLines?: number;
+    /**
+     * Logical lines moved for each mouse-wheel event (default: 1). `"auto"` accelerates fast wheel
+     * spins on terminals that send one event per notch. Alt+wheel moves five times as far.
+     */
+    wheelScrollLines?: WheelScrollLines;
     /** Capture mouse events for viewport scrolling and application-owned text selection. */
     mouse?: boolean;
     /** Style a non-current transcript search match. */
@@ -23,10 +27,11 @@ export interface TuiAltScreenOptions {
     /** Automatically copy selected text to the clipboard on mouse release (default: true). */
     copyOnSelect?: boolean;
     /**
-     * Copy selected text to the system clipboard. Return `true` on success; the caller flashes
-     * an error otherwise. When omitted, the selection is copied via an OSC 52 write.
+     * Copy selected text to the system clipboard. Return `true` on success, an error message to
+     * display on failure, or `false` for a generic error. When omitted, the selection is copied
+     * via an OSC 52 write.
      */
-    copySelection?: (text: string) => Promise<boolean>;
+    copySelection?: (text: string) => Promise<boolean | string>;
 }
 /** Alternate-screen TUI with a scrollable, application-owned viewport. */
 export declare class TuiAltScreen extends TuiBase implements ViewportTUI {
@@ -65,7 +70,7 @@ export declare class TuiAltScreen extends TuiBase implements ViewportTUI {
     private mousePressPoint?;
     private mousePressMoved;
     private lastComponentClick?;
-    private readonly wheelScrollLines;
+    private readonly wheelScroll;
     private readonly mouseEnabled;
     private readonly searchMatchStyle;
     private readonly searchCurrentMatchStyle;
@@ -78,6 +83,7 @@ export declare class TuiAltScreen extends TuiBase implements ViewportTUI {
     constructor(terminal: Terminal, showHardwareCursor?: boolean, logDirectory?: string, options?: TuiAltScreenOptions);
     get viewportTop(): number;
     get isFollowingOutput(): boolean;
+    setWheelScrollLines(lines: WheelScrollLines): void;
     getCopyOnSelect(): boolean;
     setCopyOnSelect(enabled: boolean): void;
     /** Whether the fullscreen viewport has a non-empty active text selection. */
@@ -119,7 +125,6 @@ export declare class TuiAltScreen extends TuiBase implements ViewportTUI {
     private clearTextSelection;
     private handleMouseEvent;
     private parseWheelEvent;
-    private getWheelScrollLines;
     private routeWheel;
     private parseSgrMouseEvent;
     private handleRightClickPaste;