@psnext/slingcli 2.5.20260607-2 → 2.5.20260615-2

package/node_modules/@earendil-works/pi-tui/dist/terminal.js

@@ -11,7 +11,6 @@ const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
 const TERMINAL_PROGRESS_CLEAR_SEQUENCE = "\x1b]9;4;0;\x07";
 const APPLE_TERMINAL_SHIFT_ENTER_SEQUENCE = "\x1b[13;2u";
 const DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS = 7;
-const KITTY_KEYBOARD_PROTOCOL_FALLBACK_TIMEOUT_MS = 150;
 const KEYBOARD_PROTOCOL_RESPONSE_FRAGMENT_TIMEOUT_MS = 150;
 const KITTY_KEYBOARD_PROTOCOL_QUERY = `\x1b[>${DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS}u\x1b[?u\x1b[c`;
 export function parseKeyboardProtocolNegotiationSequence(sequence) {
@@ -24,8 +23,8 @@ export function parseKeyboardProtocolNegotiationSequence(sequence) {
     }
     return undefined;
 }
-function isKeyboardProtocolNegotiationSequencePrefix(sequence, allowBareEscapePrefix) {
-    return (allowBareEscapePrefix && sequence === "\x1b") || sequence === "\x1b[" || /^\x1b\[\?[\d;]*$/.test(sequence);
+function isKeyboardProtocolNegotiationSequencePrefix(sequence) {
+    return sequence === "\x1b[" || /^\x1b\[\?[\d;]*$/.test(sequence);
 }
 export function isAppleTerminalSession() {
     return process.platform === "darwin" && process.env.TERM_PROGRAM === "Apple_Terminal";
@@ -45,10 +44,7 @@ export class ProcessTerminal {
     _kittyProtocolActive = false;
     _modifyOtherKeysActive = false;
     keyboardProtocolPushed = false;
-    keyboardProtocolNegotiationPending = false;
-    keyboardProtocolLateResponsePending = false;
     keyboardProtocolNegotiationBuffer = "";
-    keyboardProtocolFallbackTimer;
     keyboardProtocolBufferFlushTimer;
     stdinBuffer;
     stdinDataHandler;
@@ -72,6 +68,9 @@ export class ProcessTerminal {
     get kittyProtocolActive() {
         return this._kittyProtocolActive;
     }
+    get modifyOtherKeysActive() {
+        return this._modifyOtherKeysActive;
+    }
     start(onInput, onResize) {
         this.inputHandler = onInput;
         this.resizeHandler = onResize;
@@ -96,8 +95,7 @@ export class ProcessTerminal {
         // events that lose modifier information. Must run AFTER setRawMode(true)
         // since that resets console mode flags.
         this.enableWindowsVTInput();
-        // Query and enable Kitty keyboard protocol
-        // The query handler intercepts input temporarily, then installs the user's handler
+        // Query Kitty keyboard protocol and fall back to modifyOtherKeys when DA confirms no Kitty response.
         // See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
         this.queryAndEnableKittyProtocol();
     }
@@ -113,24 +111,13 @@ export class ProcessTerminal {
         this.stdinBuffer = new StdinBuffer({ timeout: 10 });
         // Forward individual sequences to the input handler
         this.stdinBuffer.on("data", (sequence) => {
-            if (this.keyboardProtocolNegotiationPending) {
-                const negotiationSequence = this.readKeyboardProtocolNegotiationSequence(sequence, true);
-                if (negotiationSequence === "pending") {
-                    return; // Wait for the rest of a split negotiation response.
-                }
-                if (this.handleKeyboardProtocolNegotiationSequence(negotiationSequence)) {
-                    return;
-                }
+            const negotiationSequence = this.readKeyboardProtocolNegotiationSequence(sequence);
+            if (negotiationSequence === "pending") {
+                this.scheduleKeyboardProtocolNegotiationBufferFlush();
+                return; // Wait briefly for the rest of a split Kitty response.
             }
-            if (this.keyboardProtocolLateResponsePending) {
-                const negotiationSequence = this.readKeyboardProtocolNegotiationSequence(sequence, false);
-                if (negotiationSequence === "pending") {
-                    this.scheduleKeyboardProtocolNegotiationBufferFlush();
-                    return; // Wait for the rest of a split late negotiation response.
-                }
-                if (this.handleKeyboardProtocolNegotiationSequence(negotiationSequence)) {
-                    return;
-                }
+            if (this.handleKeyboardProtocolNegotiationSequence(negotiationSequence)) {
+                return;
             }
             this.forwardInputSequence(sequence);
         });
@@ -150,9 +137,8 @@ export class ProcessTerminal {
      *
      * Kitty's progressive enhancement detection requires requesting the desired
      * flags before querying them. The trailing DA query is a sentinel supported by
-     * terminals that do not know Kitty keyboard protocol. A short timeout remains
-     * as a backup for terminals, PTYs, and SSH sessions that delay, split, or drop
-     * the DA response.
+     * terminals that do not know Kitty keyboard protocol; receiving DA before a
+     * Kitty response enables modifyOtherKeys fallback without a startup timeout.
      *
      * The requested flags are:
      * - 1 = disambiguate escape codes
@@ -163,45 +149,32 @@ export class ProcessTerminal {
         this.setupStdinBuffer();
         process.stdin.on("data", this.stdinDataHandler);
         this.keyboardProtocolPushed = true;
-        this.keyboardProtocolNegotiationPending = true;
-        this.keyboardProtocolLateResponsePending = false;
         this.clearKeyboardProtocolNegotiationBuffer();
         process.stdout.write(KITTY_KEYBOARD_PROTOCOL_QUERY);
-        this.keyboardProtocolFallbackTimer = setTimeout(() => {
-            this.keyboardProtocolFallbackTimer = undefined;
-            this.keyboardProtocolNegotiationPending = false;
-            this.keyboardProtocolLateResponsePending = true;
-            if (this.keyboardProtocolNegotiationBuffer === "\x1b") {
-                this.flushKeyboardProtocolNegotiationBufferAsInput();
-            }
-            else {
-                this.scheduleKeyboardProtocolNegotiationBufferFlush();
-            }
-            this.enableModifyOtherKeys();
-        }, KITTY_KEYBOARD_PROTOCOL_FALLBACK_TIMEOUT_MS);
     }
     handleKeyboardProtocolNegotiationSequence(negotiationSequence) {
         if (!negotiationSequence)
             return false;
+        this.clearKeyboardProtocolNegotiationBuffer();
         if (negotiationSequence.type === "kitty-flags") {
-            if (negotiationSequence.flags !== 0 && !this._kittyProtocolActive) {
-                this._kittyProtocolActive = true;
-                setKittyProtocolActive(true);
-                this.keyboardProtocolNegotiationPending = false;
-                this.keyboardProtocolLateResponsePending = true;
-                this.clearKeyboardProtocolNegotiationBuffer();
-                this.clearKeyboardProtocolFallbackTimer();
+            if (negotiationSequence.flags !== 0) {
+                this.disableModifyOtherKeys();
+                if (!this._kittyProtocolActive) {
+                    this._kittyProtocolActive = true;
+                    setKittyProtocolActive(true);
+                }
+            }
+            else {
+                this.enableModifyOtherKeys();
             }
             return true;
         }
-        this.keyboardProtocolNegotiationPending = false;
-        this.keyboardProtocolLateResponsePending = true;
-        this.clearKeyboardProtocolNegotiationBuffer();
-        this.clearKeyboardProtocolFallbackTimer();
-        this.enableModifyOtherKeys();
+        if (!this._kittyProtocolActive) {
+            this.enableModifyOtherKeys();
+        }
         return true;
     }
-    readKeyboardProtocolNegotiationSequence(sequence, allowBareEscapePrefix) {
+    readKeyboardProtocolNegotiationSequence(sequence) {
         if (this.keyboardProtocolNegotiationBuffer) {
             const bufferedSequence = this.keyboardProtocolNegotiationBuffer + sequence;
             const negotiationSequence = parseKeyboardProtocolNegotiationSequence(bufferedSequence);
@@ -209,7 +182,7 @@ export class ProcessTerminal {
                 this.clearKeyboardProtocolNegotiationBuffer();
                 return negotiationSequence;
             }
-            if (isKeyboardProtocolNegotiationSequencePrefix(bufferedSequence, allowBareEscapePrefix)) {
+            if (isKeyboardProtocolNegotiationSequencePrefix(bufferedSequence)) {
                 this.setKeyboardProtocolNegotiationBuffer(bufferedSequence);
                 return "pending";
             }
@@ -218,7 +191,7 @@ export class ProcessTerminal {
         const negotiationSequence = parseKeyboardProtocolNegotiationSequence(sequence);
         if (negotiationSequence)
             return negotiationSequence;
-        if (isKeyboardProtocolNegotiationSequencePrefix(sequence, allowBareEscapePrefix)) {
+        if (isKeyboardProtocolNegotiationSequencePrefix(sequence)) {
             this.setKeyboardProtocolNegotiationBuffer(sequence);
             return "pending";
         }
@@ -266,11 +239,11 @@ export class ProcessTerminal {
         process.stdout.write("\x1b[>4;2m");
         this._modifyOtherKeysActive = true;
     }
-    clearKeyboardProtocolFallbackTimer() {
-        if (!this.keyboardProtocolFallbackTimer)
+    disableModifyOtherKeys() {
+        if (!this._modifyOtherKeysActive)
             return;
-        clearTimeout(this.keyboardProtocolFallbackTimer);
-        this.keyboardProtocolFallbackTimer = undefined;
+        process.stdout.write("\x1b[>4;0m");
+        this._modifyOtherKeysActive = false;
     }
     /**
      * On Windows, add ENABLE_VIRTUAL_TERMINAL_INPUT (0x0200) to the stdin
@@ -311,10 +284,8 @@ export class ProcessTerminal {
         }
     }
     async drainInput(maxMs = 1000, idleMs = 50) {
-        const shouldDisableKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive || this.keyboardProtocolNegotiationPending;
-        this.keyboardProtocolLateResponsePending = false;
+        const shouldDisableKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive;
         this.clearKeyboardProtocolNegotiationBuffer();
-        this.clearKeyboardProtocolFallbackTimer();
         if (shouldDisableKittyProtocol) {
             // Disable Kitty keyboard protocol first so any late key releases
             // do not generate new Kitty escape sequences.
@@ -323,11 +294,7 @@ export class ProcessTerminal {
             this._kittyProtocolActive = false;
             setKittyProtocolActive(false);
         }
-        this.keyboardProtocolNegotiationPending = false;
-        if (this._modifyOtherKeysActive) {
-            process.stdout.write("\x1b[>4;0m");
-            this._modifyOtherKeysActive = false;
-        }
+        this.disableModifyOtherKeys();
         const previousHandler = this.inputHandler;
         this.inputHandler = undefined;
         let lastDataTime = Date.now();
@@ -358,10 +325,8 @@ export class ProcessTerminal {
         }
         // Disable bracketed paste mode
         process.stdout.write("\x1b[?2004l");
-        const shouldDisableKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive || this.keyboardProtocolNegotiationPending;
-        this.keyboardProtocolLateResponsePending = false;
+        const shouldDisableKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive;
         this.clearKeyboardProtocolNegotiationBuffer();
-        this.clearKeyboardProtocolFallbackTimer();
         // Disable Kitty keyboard protocol if not already done by drainInput()
         if (shouldDisableKittyProtocol) {
             process.stdout.write("\x1b[<u");
@@ -369,11 +334,7 @@ export class ProcessTerminal {
             this._kittyProtocolActive = false;
             setKittyProtocolActive(false);
         }
-        this.keyboardProtocolNegotiationPending = false;
-        if (this._modifyOtherKeysActive) {
-            process.stdout.write("\x1b[>4;0m");
-            this._modifyOtherKeysActive = false;
-        }
+        this.disableModifyOtherKeys();
         // Clean up StdinBuffer
         if (this.stdinBuffer) {
             this.stdinBuffer.destroy();

package/node_modules/@earendil-works/pi-tui/dist/tui.js

@@ -6,28 +6,42 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { performance } from "node:perf_hooks";
 import { isKeyRelease, matchesKey } from "./keys.js";
+import { isOsc11BackgroundColorResponse, parseOsc11BackgroundColor } from "./terminal-colors.js";
 import { deleteKittyImage, getCapabilities, isImageLine, setCellDimensions } from "./terminal-image.js";
 import { extractSegments, normalizeTerminalOutput, sliceByColumn, sliceWithWidth, visibleWidth } from "./utils.js";
 const KITTY_SEQUENCE_PREFIX = "\x1b_G";
-function extractKittyImageIds(line) {
+function parseKittyImageHeader(line) {
     const sequenceStart = line.indexOf(KITTY_SEQUENCE_PREFIX);
     if (sequenceStart === -1)
-        return [];
+        return undefined;
     const paramsStart = sequenceStart + KITTY_SEQUENCE_PREFIX.length;
     const paramsEnd = line.indexOf(";", paramsStart);
     if (paramsEnd === -1)
-        return [];
+        return undefined;
+    const ids = [];
+    let rows = 1;
     const params = line.slice(paramsStart, paramsEnd);
     for (const param of params.split(",")) {
         const [key, value] = param.split("=", 2);
-        if (key !== "i" || value === undefined)
+        if (value === undefined)
             continue;
-        const id = Number(value);
-        if (Number.isInteger(id) && id > 0 && id <= 0xffffffff) {
-            return [id];
+        const numberValue = Number(value);
+        if (!Number.isInteger(numberValue) || numberValue <= 0 || numberValue > 0xffffffff)
+            continue;
+        if (key === "i") {
+            ids.push(numberValue);
+        }
+        else if (key === "r") {
+            rows = numberValue;
         }
     }
-    return [];
+    return { ids, rows };
+}
+function extractKittyImageIds(line) {
+    return parseKittyImageHeader(line)?.ids ?? [];
+}
+function extractKittyImageRows(line) {
+    return parseKittyImageHeader(line)?.rows ?? 1;
 }
 /** Type guard to check if a component implements Focusable */
 export function isFocusable(component) {
@@ -115,6 +129,8 @@ export class TUI extends Container {
     previousViewportTop = 0; // Track previous viewport top for resize-aware cursor moves
     fullRedrawCount = 0;
     stopped = false;
+    pendingOsc11BackgroundReplies = 0;
+    pendingOsc11BackgroundQueries = [];
     // Overlay stack for modal components rendered on top of base content
     focusOrderCounter = 0;
     overlayStack = [];
@@ -505,6 +521,9 @@ export class TUI extends Container {
         }, delay);
     }
     handleInput(data) {
+        if (this.consumeOsc11BackgroundResponse(data)) {
+            return;
+        }
         if (this.inputListeners.size > 0) {
             let current = data;
             for (const listener of this.inputListeners) {
@@ -570,6 +589,27 @@ export class TUI extends Container {
             this.requestRender();
         }
     }
+    consumeOsc11BackgroundResponse(data) {
+        if (this.pendingOsc11BackgroundReplies <= 0) {
+            return false;
+        }
+        if (!isOsc11BackgroundColorResponse(data)) {
+            return false;
+        }
+        const rgb = parseOsc11BackgroundColor(data);
+        this.pendingOsc11BackgroundReplies -= 1;
+        const query = this.pendingOsc11BackgroundQueries.shift();
+        if (query && !query.settled) {
+            query.settled = true;
+            if (query.timer) {
+                clearTimeout(query.timer);
+                query.timer = undefined;
+            }
+            query.resolve?.(rgb);
+            query.resolve = undefined;
+        }
+        return true;
+    }
     consumeCellSizeResponse(data) {
         // Response format: ESC [ 6 ; height ; width t
         const match = data.match(/^\x1b\[6;(\d+);(\d+)t$/);
@@ -789,14 +829,37 @@ export class TUI extends Container {
         }
         return buffer;
     }
-    expandLastChangedForKittyImages(firstChanged, lastChanged) {
+    getKittyImageReservedRows(lines, index, maxIndex = lines.length - 1) {
+        const rows = extractKittyImageRows(lines[index] ?? "");
+        if (rows <= 1)
+            return 1;
+        const maxRows = Math.min(rows, maxIndex - index + 1, lines.length - index);
+        let reservedRows = 1;
+        while (reservedRows < maxRows) {
+            const line = lines[index + reservedRows] ?? "";
+            if (isImageLine(line) || visibleWidth(line) > 0)
+                break;
+            reservedRows++;
+        }
+        return reservedRows;
+    }
+    expandChangedRangeForKittyImages(firstChanged, lastChanged, newLines) {
+        let expandedFirstChanged = firstChanged;
         let expandedLastChanged = lastChanged;
-        for (let i = firstChanged; i < this.previousLines.length; i++) {
-            if (extractKittyImageIds(this.previousLines[i]).length > 0) {
-                expandedLastChanged = Math.max(expandedLastChanged, i);
+        const expandForLines = (lines) => {
+            for (let i = 0; i < lines.length; i++) {
+                if (extractKittyImageIds(lines[i]).length === 0)
+                    continue;
+                const blockEnd = i + this.getKittyImageReservedRows(lines, i) - 1;
+                if (i >= firstChanged || (i <= lastChanged && blockEnd >= firstChanged)) {
+                    expandedFirstChanged = Math.min(expandedFirstChanged, i);
+                    expandedLastChanged = Math.max(expandedLastChanged, blockEnd);
+                }
             }
-        }
-        return expandedLastChanged;
+        };
+        expandForLines(this.previousLines);
+        expandForLines(newLines);
+        return { firstChanged: expandedFirstChanged, lastChanged: expandedLastChanged };
     }
     deleteChangedKittyImages(firstChanged, lastChanged) {
         if (firstChanged < 0 || lastChanged < firstChanged)
@@ -910,7 +973,20 @@ export class TUI extends Container {
             for (let i = 0; i < newLines.length; i++) {
                 if (i > 0)
                     buffer += "\r\n";
-                buffer += newLines[i];
+                const line = newLines[i];
+                const isImage = isImageLine(line);
+                const imageReservedRows = isImage ? this.getKittyImageReservedRows(newLines, i) : 1;
+                if (imageReservedRows > 1 && imageReservedRows <= height) {
+                    for (let row = 1; row < imageReservedRows; row++) {
+                        buffer += "\r\n";
+                    }
+                    buffer += `\x1b[${imageReservedRows - 1}A`;
+                    buffer += line;
+                    buffer += `\x1b[${imageReservedRows - 1}B`;
+                    i += imageReservedRows - 1;
+                    continue;
+                }
+                buffer += line;
             }
             buffer += "\x1b[?2026l"; // End synchronized output
             this.terminal.write(buffer);
@@ -989,7 +1065,9 @@ export class TUI extends Container {
             lastChanged = newLines.length - 1;
         }
         if (firstChanged !== -1) {
-            lastChanged = this.expandLastChangedForKittyImages(firstChanged, lastChanged);
+            const expandedRange = this.expandChangedRangeForKittyImages(firstChanged, lastChanged, newLines);
+            firstChanged = expandedRange.firstChanged;
+            lastChanged = expandedRange.lastChanged;
         }
         const appendStart = appendedLines && firstChanged === this.previousLines.length && firstChanged > 0;
         // No changes - but still need to update hardware cursor position if it moved
@@ -1024,16 +1102,18 @@ export class TUI extends Container {
                     fullRender(true);
                     return;
                 }
-                if (extraLines > 0) {
-                    buffer += "\x1b[1B";
+                const clearStartOffset = newLines.length === 0 ? 0 : 1;
+                if (extraLines > 0 && clearStartOffset > 0) {
+                    buffer += `\x1b[${clearStartOffset}B`;
                 }
                 for (let i = 0; i < extraLines; i++) {
                     buffer += "\r\x1b[2K";
                     if (i < extraLines - 1)
                         buffer += "\x1b[1B";
                 }
-                if (extraLines > 0) {
-                    buffer += `\x1b[${extraLines}A`;
+                const moveBack = Math.max(0, extraLines - 1 + clearStartOffset);
+                if (moveBack > 0) {
+                    buffer += `\x1b[${moveBack}A`;
                 }
                 buffer += "\x1b[?2026l";
                 this.terminal.write(buffer);
@@ -1088,9 +1168,27 @@ export class TUI extends Container {
         for (let i = firstChanged; i <= renderEnd; i++) {
             if (i > firstChanged)
                 buffer += "\r\n";
-            buffer += "\x1b[2K"; // Clear current line
             const line = newLines[i];
             const isImage = isImageLine(line);
+            const imageReservedRows = isImage ? this.getKittyImageReservedRows(newLines, i, renderEnd) : 1;
+            if (imageReservedRows > 1) {
+                const imageStartScreenRow = i - viewportTop;
+                if (imageStartScreenRow < 0 || imageStartScreenRow + imageReservedRows > height) {
+                    logRedraw(`kitty image pre-clear would scroll (${imageStartScreenRow} + ${imageReservedRows} > ${height})`);
+                    fullRender(true);
+                    return;
+                }
+                buffer += "\x1b[2K";
+                for (let row = 1; row < imageReservedRows; row++) {
+                    buffer += "\r\n\x1b[2K";
+                }
+                buffer += `\x1b[${imageReservedRows - 1}A`;
+                buffer += line;
+                buffer += `\x1b[${imageReservedRows - 1}B`;
+                i += imageReservedRows - 1;
+                continue;
+            }
+            buffer += "\x1b[2K"; // Clear current line
             if (!isImage && visibleWidth(line) > width) {
                 // Log all lines to crash file for debugging
                 const crashLogPath = path.join(os.homedir(), ".pi", "agent", "pi-crash.log");
@@ -1217,5 +1315,31 @@ export class TUI extends Container {
             this.terminal.hideCursor();
         }
     }
+    /**
+     * Query the terminal's default background color with OSC 11 (`ESC ] 11 ; ? BEL`).
+     * @param timeoutMs Query timeout in milliseconds.
+     * @returns Promise containing the parsed RGB color, or undefined if it times out or fails to parse.
+     */
+    queryTerminalBackgroundColor({ timeoutMs }) {
+        return new Promise((resolve) => {
+            const query = {
+                settled: false,
+                resolve,
+                timer: undefined,
+            };
+            query.timer = setTimeout(() => {
+                if (query.settled) {
+                    return;
+                }
+                query.settled = true;
+                query.timer = undefined;
+                query.resolve?.(undefined);
+                query.resolve = undefined;
+            }, timeoutMs);
+            this.pendingOsc11BackgroundQueries.push(query);
+            this.pendingOsc11BackgroundReplies += 1;
+            this.terminal.write("\x1b]11;?\x07");
+        });
+    }
 }
 //# sourceMappingURL=tui.js.map

package/node_modules/@earendil-works/pi-tui/dist/utils.js

@@ -37,6 +37,7 @@ const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
 // Cache for non-ASCII strings
 const WIDTH_CACHE_SIZE = 512;
 const widthCache = new Map();
+export const cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
 function isPrintableAscii(str) {
     for (let i = 0; i < str.length; i++) {
         const code = str.charCodeAt(i);
@@ -549,8 +550,16 @@ function splitIntoTokensWithAnsi(text) {
     const tokens = [];
     let current = "";
     let pendingAnsi = ""; // ANSI codes waiting to be attached to next visible content
-    let inWhitespace = false;
+    let currentKind = null;
     let i = 0;
+    const flushCurrent = () => {
+        if (!current) {
+            return;
+        }
+        tokens.push(current);
+        current = "";
+        currentKind = null;
+    };
     while (i < text.length) {
         const ansiResult = extractAnsiCode(text, i);
         if (ansiResult) {
@@ -559,25 +568,44 @@ function splitIntoTokensWithAnsi(text) {
             i += ansiResult.length;
             continue;
         }
-        const char = text[i];
-        const charIsSpace = char === " ";
-        if (charIsSpace !== inWhitespace && current) {
-            // Switching between whitespace and non-whitespace, push current token
-            tokens.push(current);
-            current = "";
+        let end = i;
+        while (end < text.length && !extractAnsiCode(text, end)) {
+            end++;
         }
-        // Attach any pending ANSI codes to this visible character
-        if (pendingAnsi) {
-            current += pendingAnsi;
-            pendingAnsi = "";
+        for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+            const segmentIsSpace = segment === " ";
+            if (!segmentIsSpace && cjkBreakRegex.test(segment)) {
+                flushCurrent();
+                const token = pendingAnsi + segment;
+                pendingAnsi = "";
+                tokens.push(token);
+                continue;
+            }
+            const segmentKind = segmentIsSpace ? "space" : "word";
+            if (current && currentKind !== segmentKind) {
+                flushCurrent();
+            }
+            // Attach any pending ANSI codes to this visible character
+            if (pendingAnsi) {
+                current += pendingAnsi;
+                pendingAnsi = "";
+            }
+            currentKind = segmentKind;
+            current += segment;
         }
-        inWhitespace = charIsSpace;
-        current += char;
-        i++;
+        i = end;
     }
     // Handle any remaining pending ANSI codes (attach to last token)
     if (pendingAnsi) {
-        current += pendingAnsi;
+        if (current) {
+            current += pendingAnsi;
+        }
+        else if (tokens.length > 0) {
+            tokens[tokens.length - 1] += pendingAnsi;
+        }
+        else {
+            current = pendingAnsi;
+        }
     }
     if (current) {
         tokens.push(current);
@@ -998,7 +1026,7 @@ export function extractSegments(line, beforeEnd, afterStart, afterLen, strictAft
             textEnd++;
         for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
             const w = graphemeWidth(segment);
-            if (currentCol < beforeEnd) {
+            if (currentCol < beforeEnd && currentCol + w <= beforeEnd) {
                 if (pendingAnsiBefore) {
                     before += pendingAnsiBefore;
                     pendingAnsiBefore = "";

package/node_modules/@earendil-works/pi-tui/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-tui",
-	"version": "0.78.1",
+	"version": "0.79.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",

package/node_modules/@nodable/entities/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodable/entities",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Entity parser for XML, HTML, External entites with security and NCR control",
   "main": "./src/index.js",
   "type": "module",
@@ -25,10 +25,13 @@
     "xml",
     "html",
     "entity",
+    "entities",
+    "stringify",
     "encode",
     "decode",
     "ncr",
     "security",
+    "safe",
     "performance"
   ],
   "author": "Amit Gupta (https://solothought.com)",