pi-ui-extend 0.1.34 → 0.1.36

package/dist/app/terminal/terminal-controller.js

@@ -1,10 +1,14 @@
 import { ANSI_RESET } from "../../theme.js";
-import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RESET_TERMINAL_VIEWPORT_STATE, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
+import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_MODIFY_OTHER_KEYS, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RESET_TERMINAL_VIEWPORT_STATE, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
 export class AppTerminalController {
     host;
     terminalEnabled = false;
     interactiveSuspended = false;
     stopPromise;
+    keyboardProtocolNegotiationBuffer = "";
+    keyboardProtocolBufferFlushTimer;
+    kittyProtocolActive = false;
+    modifyOtherKeysActive = false;
     enterInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}\x1b[?1049h${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`;
     exitInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`;
     constructor(host) {
@@ -17,6 +21,7 @@ export class AppTerminalController {
         if (this.terminalEnabled)
             return;
         this.terminalEnabled = true;
+        this.beginKeyboardProtocolNegotiation();
         process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.on("data", this.onInputData);
@@ -66,6 +71,7 @@ export class AppTerminalController {
     restoreTerminal = () => {
         if (!this.terminalEnabled)
             return;
+        this.clearKeyboardProtocolNegotiationBuffer();
         this.terminalEnabled = false;
         this.interactiveSuspended = false;
         process.stdout.write(this.exitInteractiveSequence);
@@ -87,6 +93,7 @@ export class AppTerminalController {
         if (!this.terminalEnabled || !this.interactiveSuspended)
             return;
         this.interactiveSuspended = false;
+        this.beginKeyboardProtocolNegotiation();
         if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
         process.stdin.resume();
@@ -99,6 +106,7 @@ export class AppTerminalController {
     async stopInternal() {
         if (!this.host.isRunning())
             return;
+        this.clearKeyboardProtocolNegotiationBuffer();
         this.host.setRunning(false);
         this.host.closeSdkMenuForStop();
         this.host.clearToastTimers();
@@ -133,6 +141,87 @@ export class AppTerminalController {
         this.host.render();
     };
     onInputData = (chunk) => {
-        this.host.handleInputChunk(chunk);
+        const input = this.filterKeyboardProtocolNegotiationInput(chunk.toString("utf8"));
+        if (input)
+            this.host.handleInputChunk(Buffer.from(input, "utf8"));
     };
+    beginKeyboardProtocolNegotiation() {
+        this.clearKeyboardProtocolNegotiationBuffer();
+        this.kittyProtocolActive = false;
+        this.modifyOtherKeysActive = false;
+    }
+    filterKeyboardProtocolNegotiationInput(data) {
+        let input = this.keyboardProtocolNegotiationBuffer + data;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        let output = "";
+        while (input.length > 0) {
+            const response = readKeyboardProtocolNegotiationResponse(input);
+            if (response.kind === "complete") {
+                this.handleKeyboardProtocolNegotiationResponse(response.response);
+                input = input.slice(response.length);
+                continue;
+            }
+            if (response.kind === "pending") {
+                this.setKeyboardProtocolNegotiationBuffer(input);
+                break;
+            }
+            output += input[0];
+            input = input.slice(1);
+        }
+        return output;
+    }
+    handleKeyboardProtocolNegotiationResponse(response) {
+        if (response.type === "kitty-flags") {
+            if (response.flags !== 0) {
+                this.kittyProtocolActive = true;
+                this.modifyOtherKeysActive = false;
+            }
+            else {
+                this.enableModifyOtherKeysFallback();
+            }
+            return;
+        }
+        if (!this.kittyProtocolActive)
+            this.enableModifyOtherKeysFallback();
+    }
+    enableModifyOtherKeysFallback() {
+        if (this.kittyProtocolActive || this.modifyOtherKeysActive)
+            return;
+        process.stdout.write(ENABLE_TERMINAL_MODIFY_OTHER_KEYS);
+        this.modifyOtherKeysActive = true;
+    }
+    setKeyboardProtocolNegotiationBuffer(data) {
+        this.clearKeyboardProtocolNegotiationBuffer();
+        this.keyboardProtocolNegotiationBuffer = data;
+        this.keyboardProtocolBufferFlushTimer = setTimeout(() => {
+            this.keyboardProtocolBufferFlushTimer = undefined;
+            const buffered = this.keyboardProtocolNegotiationBuffer;
+            this.keyboardProtocolNegotiationBuffer = "";
+            if (buffered)
+                this.host.handleInputChunk(Buffer.from(buffered, "utf8"));
+        }, 150);
+    }
+    clearKeyboardProtocolNegotiationBuffer() {
+        if (this.keyboardProtocolBufferFlushTimer)
+            clearTimeout(this.keyboardProtocolBufferFlushTimer);
+        this.keyboardProtocolBufferFlushTimer = undefined;
+        this.keyboardProtocolNegotiationBuffer = "";
+    }
+}
+function readKeyboardProtocolNegotiationResponse(input) {
+    const kittyFlags = /^\x1b\[\?(\d+)u/.exec(input);
+    if (kittyFlags) {
+        return {
+            kind: "complete",
+            response: { type: "kitty-flags", flags: Number.parseInt(kittyFlags[1] ?? "0", 10) },
+            length: kittyFlags[0].length,
+        };
+    }
+    const deviceAttributes = /^\x1b\[\?[\d;]*c/.exec(input);
+    if (deviceAttributes) {
+        return { kind: "complete", response: { type: "device-attributes" }, length: deviceAttributes[0].length };
+    }
+    if (input === "\x1b[" || /^\x1b\[\?[\d;]*$/.test(input))
+        return { kind: "pending" };
+    return { kind: "none" };
 }

package/dist/app/todo/todo-model.js

@@ -59,6 +59,8 @@ export function isTodoLiveStateEvent(value) {
         return false;
     if (value.sessionFile !== undefined && typeof value.sessionFile !== "string")
         return false;
+    if (value.sessionId !== undefined && typeof value.sessionId !== "string")
+        return false;
     return typeof value.checkedAt === "number" && Number.isFinite(value.checkedAt);
 }
 export function todoStatusIcon(status) {

package/dist/app/todo/todo-widget-controller.d.ts

@@ -1,6 +1,7 @@
 import type { TodoDetails } from "../types.js";
 export type TodoWidgetControllerHost = {
     sessionFile?(): string | undefined;
+    sessionId?(): string | undefined;
     isRunning(): boolean;
     render(): void;
 };
@@ -17,5 +18,6 @@ export declare class AppTodoWidgetController {
     private updateDetailsForCurrentSession;
     private updateDetailsForSession;
     private currentSessionDetails;
+    private currentSessionKey;
     private sessionKey;
 }

package/dist/app/todo/todo-widget-controller.js

@@ -25,17 +25,21 @@ export class AppTodoWidgetController {
     observeLiveState(data) {
         if (!isTodoLiveStateEvent(data))
             return;
-        this.updateDetailsForSession(data.sessionFile ?? this.host.sessionFile?.(), this.visibleDetails(data.details));
+        const sessionFile = data.sessionFile;
+        const sessionId = data.sessionId;
+        if (!sessionFile && !sessionId && this.currentSessionKey())
+            return;
+        this.updateDetailsForSession(sessionFile, sessionId, this.visibleDetails(data.details));
     }
     visibleDetails(details) {
         return hasOpenTodoTasks(details) ? details : undefined;
     }
     updateDetailsForCurrentSession(next, options = {}) {
-        this.updateDetailsForSession(this.host.sessionFile?.(), next, options);
+        this.updateDetailsForSession(this.host.sessionFile?.(), this.host.sessionId?.(), next, options);
     }
-    updateDetailsForSession(sessionFile, next, options = {}) {
+    updateDetailsForSession(sessionFile, sessionId, next, options = {}) {
         const previous = stringifyUnknown(this.currentSessionDetails());
-        const key = this.sessionKey(sessionFile);
+        const key = this.sessionKey(sessionFile, sessionId);
         if (key) {
             if (next)
                 this.detailsBySessionFile.set(key, next);
@@ -50,10 +54,16 @@ export class AppTodoWidgetController {
             this.host.render();
     }
     currentSessionDetails() {
-        const key = this.sessionKey(this.host.sessionFile?.());
+        const key = this.currentSessionKey();
         return key ? this.detailsBySessionFile.get(key) : this.unscopedDetails;
     }
-    sessionKey(sessionFile) {
-        return sessionFile ? resolve(sessionFile) : undefined;
+    currentSessionKey() {
+        return this.sessionKey(this.host.sessionFile?.(), this.host.sessionId?.());
+    }
+    sessionKey(sessionFile, sessionId) {
+        if (sessionFile)
+            return `file:${resolve(sessionFile)}`;
+        const normalizedSessionId = sessionId?.trim();
+        return normalizedSessionId ? `id:${normalizedSessionId}` : undefined;
     }
 }

package/dist/app/types.d.ts

@@ -74,6 +74,8 @@ export type Entry = {
     expanded: boolean;
     status: "running" | "done";
     level?: string;
+    startedAt?: number;
+    finishedAt?: number;
 } | {
     id: string;
     kind: "tool";
@@ -125,6 +127,7 @@ export type TodoLiveStateEvent = {
     version: 1;
     details: TodoDetails;
     sessionFile?: string;
+    sessionId?: string;
     checkedAt: number;
 };
 export type SubagentStatus = (typeof SUBAGENT_STATUSES)[number];
@@ -193,6 +196,7 @@ export type SubagentRegistryAgent = {
     updatedAt: string;
 };
 export type SubagentsWidgetState = {
+    runs?: SubagentLiveStateRun[];
     runDir: string;
     agents: SubagentAgentState[];
     tasks?: SubagentTaskPreview[];

package/dist/app/workspace/workspace-actions-controller.d.ts

@@ -4,6 +4,7 @@ import { type WorkspaceMutation, type WorkspaceMutationFromToolInput, type Works
 export type AppWorkspaceActionsControllerHost = {
     readonly entries: Entry[];
     runtime(): AgentSessionRuntime | undefined;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     findUserEntry(entryId: string): Extract<Entry, {
         kind: "user";
     }> | undefined;

package/dist/app/workspace/workspace-actions-controller.js

@@ -94,6 +94,7 @@ export class AppWorkspaceActionsController {
             throw new Error("Session entry for this message is not available yet");
         this.host.setStatus("forking session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.fork(sessionEntryId);
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });

package/dist/bundled-extensions/question/tui.js

@@ -60,6 +60,12 @@ function wrapLine(line, width) {
         lines.push(current.trimEnd());
     return lines.length > 0 ? lines : [""];
 }
+function wrapIndentedLine(line, width) {
+    const indent = line.match(/^\s*/)?.[0] ?? "";
+    const content = line.slice(indent.length);
+    const contentWidth = Math.max(1, width - indent.length);
+    return wrapLine(content, contentWidth).map((wrapped) => `${indent}${wrapped}`);
+}
 function stripAnsi(text) {
     return text.replace(/\u001b\[[0-9;]*m/g, "");
 }
@@ -191,7 +197,8 @@ export async function runQuestionnaire(questions, ctx) {
             clickZones.push({ ...zone, row, startColumn: 1, endColumn: width + 1 });
         }
         function renderMutedLine(add, text, width) {
-            add(paintLine(theme, text, width, { foreground: "muted" }));
+            for (const line of wrapIndentedLine(text, width))
+                add(paintLine(theme, line, width, { foreground: "muted" }));
         }
         function moveToQuestion(index) {
             captureCustomDraft();

package/dist/bundled-extensions/session-title/index.js

@@ -4,6 +4,24 @@ import { loadSessionTitleConfig } from "./config.js";
 import { fallbackSessionTitleFromInput, firstUserMessageText as firstUserMessageTextFromEntries, generateSessionTitle, sessionTitleModelRefs, } from "./title-generation.js";
 export { fallbackSessionTitleFromInput, generateSessionTitle, sessionTitleModelRefs, sanitizeSessionTitle } from "./title-generation.js";
 const DEFAULT_TERMINAL_TITLE = "pi";
+function isStaleExtensionContextError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message);
+}
+function ignoreStaleExtensionContextError(error) {
+    if (!isStaleExtensionContextError(error))
+        throw error;
+}
+function staleSafe(callback) {
+    try {
+        return callback();
+    }
+    catch (error) {
+        ignoreStaleExtensionContextError(error);
+        return undefined;
+    }
+}
 function imageAttachmentLabel(images) {
     if (images.length === 0)
         return undefined;
@@ -76,14 +94,23 @@ export default function sessionTitle(pi) {
             clearTimeout(timer);
         refreshTimers.clear();
     }
+    function safeCtxCall(callback) {
+        return staleSafe(callback);
+    }
+    function safePiCall(callback) {
+        return staleSafe(callback);
+    }
+    function currentSessionId(ctx) {
+        return safeCtxCall(() => ctx.sessionManager.getSessionId());
+    }
     function currentSessionName(ctx) {
-        const name = pi.getSessionName() ?? ctx?.sessionManager.getSessionName?.();
+        const name = safePiCall(() => pi.getSessionName()) ?? safeCtxCall(() => ctx?.sessionManager.getSessionName?.());
         return name?.trim() || undefined;
     }
     function shouldGeneratePendingTitle(ctx) {
         if (!pendingGeneration)
             return false;
-        if (pendingGeneration.sessionId !== ctx.sessionManager.getSessionId())
+        if (pendingGeneration.sessionId !== currentSessionId(ctx))
             return false;
         const name = currentSessionName(ctx);
         if (!name)
@@ -110,7 +137,12 @@ export default function sessionTitle(pi) {
         const safeTitle = terminalSafeText(title) || DEFAULT_TERMINAL_TITLE;
         if (!force && safeTitle === lastRenderedTitle)
             return;
-        ctx.ui.setTitle(safeTitle);
+        const rendered = safeCtxCall(() => {
+            ctx.ui.setTitle(safeTitle);
+            return true;
+        });
+        if (!rendered)
+            return;
         lastRenderedTitle = safeTitle;
     }
     function refreshSessionUi(ctx, options = {}) {
@@ -130,7 +162,7 @@ export default function sessionTitle(pi) {
         for (const delayMs of [0, 100, 500, 1500, 3000]) {
             const timer = setTimeout(() => {
                 refreshTimers.delete(timer);
-                refreshSessionUi(ctx, { reapplyTitle: true });
+                safeCtxCall(() => refreshSessionUi(ctx, { reapplyTitle: true }));
             }, delayMs);
             timer.unref?.();
             refreshTimers.add(timer);
@@ -146,7 +178,7 @@ export default function sessionTitle(pi) {
             return;
         retryTimer = setTimeout(() => {
             retryTimer = undefined;
-            startTitleGeneration(ctx, currentConfig);
+            safeCtxCall(() => startTitleGeneration(ctx, currentConfig));
         }, currentConfig.retryDelayMs);
         retryTimer.unref?.();
     }
@@ -157,7 +189,11 @@ export default function sessionTitle(pi) {
         const fallbackTitle = fallbackSessionTitleFromInput(input, currentConfig.maxTitleChars);
         if (!fallbackTitle)
             return false;
-        pi.setSessionName(fallbackTitle);
+        if (!safePiCall(() => {
+            pi.setSessionName(fallbackTitle);
+            return true;
+        }))
+            return false;
         refreshSessionUi(ctx, { force: true });
         scheduleSessionUiRefresh(ctx);
         return true;
@@ -185,36 +221,47 @@ export default function sessionTitle(pi) {
         abortCurrentRequest();
         controller = new AbortController();
         const requestController = controller;
-        const currentSessionId = pendingGeneration.sessionId;
+        const pendingSessionId = pendingGeneration.sessionId;
         const generation = { ...pendingGeneration, modelRef };
         void (async () => {
             try {
-                const title = await generateSessionTitle(generation.input, ctx.modelRegistry, currentConfig, generation.modelRef, requestController.signal, currentConfig.debug && ctx.hasUI ? (message) => ctx.ui.notify(message, "warning") : undefined);
+                const notifyDebug = currentConfig.debug && ctx.hasUI
+                    ? (message) => {
+                        safeCtxCall(() => ctx.ui.notify(message, "warning"));
+                    }
+                    : undefined;
+                const title = await generateSessionTitle(generation.input, ctx.modelRegistry, currentConfig, generation.modelRef, requestController.signal, notifyDebug);
                 if (!title || requestController.signal.aborted)
                     return;
-                if (sessionId !== currentSessionId)
+                if (sessionId !== pendingSessionId)
+                    return;
+                if (pendingSessionId !== currentSessionId(ctx))
                     return;
                 if (!shouldGeneratePendingTitle(ctx))
                     return;
-                pi.setSessionName(title);
+                if (!safePiCall(() => {
+                    pi.setSessionName(title);
+                    return true;
+                }))
+                    return;
                 pendingGeneration = undefined;
                 refreshSessionUi(ctx, { force: true });
                 scheduleSessionUiRefresh(ctx);
                 if (currentConfig.notify && ctx.hasUI)
-                    ctx.ui.notify(`Session named: ${title}`, "info");
+                    safeCtxCall(() => ctx.ui.notify(`Session named: ${title}`, "info"));
             }
             catch (error) {
                 if (requestController.signal.aborted)
                     return;
                 if (currentConfig.debug && ctx.hasUI) {
                     const message = error instanceof Error ? error.message : String(error);
-                    ctx.ui.notify(`Session title generation failed: ${message}`, "warning");
+                    safeCtxCall(() => ctx.ui.notify(`Session title generation failed: ${message}`, "warning"));
                 }
             }
             finally {
                 if (controller === requestController)
                     controller = undefined;
-                if (requestController.signal.aborted || pendingGeneration?.sessionId !== currentSessionId)
+                if (requestController.signal.aborted || pendingGeneration?.sessionId !== pendingSessionId)
                     return;
                 if (shouldGeneratePendingTitle(ctx)) {
                     if (!advancePendingGeneration(currentConfig)) {
@@ -363,7 +410,11 @@ export default function sessionTitle(pi) {
                 : fallbackInput;
             const provisionalSessionName = fallbackSessionTitleFromInput(fallbackTitleInput, currentConfig.maxTitleChars);
             if (provisionalSessionName && (!currentName || activeForkTitleState)) {
-                pi.setSessionName(provisionalSessionName);
+                if (!safePiCall(() => {
+                    pi.setSessionName(provisionalSessionName);
+                    return true;
+                }))
+                    return { action: "continue" };
                 refreshSessionUi(ctx, { force: true });
                 scheduleSessionUiRefresh(ctx);
             }

package/dist/input-editor-files.js

@@ -1,5 +1,24 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
 import { resizeImage } from "@earendil-works/pi-coding-agent";
-import { hasImage, getImageBinary } from "@mariozechner/clipboard";
+const moduleRequire = createRequire(import.meta.url);
+const executableDirRequire = createRequire(pathToFileURL(join(dirname(process.execPath), "package.json")).href);
+function loadClipboardNative(requires = [moduleRequire, executableDirRequire]) {
+    for (const requireClipboard of requires) {
+        try {
+            return requireClipboard("@mariozechner/clipboard");
+        }
+        catch {
+            // Try the next resolution root. This mirrors pi's packaged-binary fallback,
+            // where native sidecars may resolve relative to the executable directory.
+        }
+    }
+    return null;
+}
+const nativeClipboard = !process.env.TERMUX_VERSION && (process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY))
+    ? loadClipboardNative()
+    : null;
 /**
  * Read an image from the system clipboard.
  * Uses the native @mariozechner/clipboard N-API module for direct clipboard
@@ -7,12 +26,12 @@ import { hasImage, getImageBinary } from "@mariozechner/clipboard";
  */
 export async function readClipboardImage() {
     try {
-        if (!hasImage())
+        if (!nativeClipboard?.hasImage())
             return null;
-        const bytes = await getImageBinary();
+        const bytes = await nativeClipboard.getImageBinary();
         if (!bytes || bytes.length === 0)
             return null;
-        const uint8 = new Uint8Array(bytes);
+        const uint8 = bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes);
         try {
             const resized = await resizeImage(uint8, "image/png", { maxWidth: 2000, maxHeight: 2000 });
             if (resized)

package/dist/markdown-format.d.ts

@@ -22,8 +22,11 @@ export type RenderedMarkdownTextLine = {
     syntaxHighlight?: SyntaxLineHighlight | undefined;
     heading?: boolean;
 };
+export type RenderMarkdownTextLinesOptions = {
+    preserveWrappedWordSeparator?: boolean;
+};
 export declare function formatMarkdownTables(text: string, maxWidth?: number): string;
 export declare function renderMarkdownLine(text: string, start?: number): RenderedMarkdownLine;
-export declare function renderMarkdownTextLines(text: string, width: number, start?: number): RenderedMarkdownTextLine[];
+export declare function renderMarkdownTextLines(text: string, width: number, start?: number, options?: RenderMarkdownTextLinesOptions): RenderedMarkdownTextLine[];
 export declare function markdownSyntaxHighlightsForText(text: string, startColumn?: number): ToolBodySyntaxHighlights;
 export declare function isOnlyHiddenMetadata(text: string): boolean;

package/dist/markdown-format.js

@@ -1,5 +1,6 @@
 import { expandTabs, stringDisplayWidth } from "./terminal-width.js";
 import { syntaxHighlightLanguageForMarkdownFence, } from "./syntax-highlight.js";
+const MIN_TRAILING_WORD_WIDTH_TO_REBALANCE = 5;
 export function formatMarkdownTables(text, maxWidth) {
     const lines = text.split("\n");
     const formatted = [];
@@ -70,7 +71,7 @@ export function renderMarkdownLine(text, start = 0) {
     }
     return { text: rendered, segments, ...(isHeading ? { heading: true } : {}) };
 }
-export function renderMarkdownTextLines(text, width, start = 0) {
+export function renderMarkdownTextLines(text, width, start = 0, options = {}) {
     const lines = [];
     let fence;
     const formattedText = formatMarkdownTables(sanitizeMarkdownText(text), width);
@@ -83,7 +84,7 @@ export function renderMarkdownTextLines(text, width, start = 0) {
         const syntaxHighlight = markdownLineSyntaxHighlight(fence, Boolean(opensFence || closesFence), start);
         const isHeadingLine = !fence && /^\s{0,3}#{1,6}\s/.test(rawLine);
         const markdownLine = syntaxHighlight?.language === "markdown" || isHeadingLine ? renderMarkdownLine(rawLine) : undefined;
-        for (const wrapped of wrapRenderedMarkdownLine(markdownLine ?? { text: rawLine, segments: [] }, width)) {
+        for (const wrapped of wrapRenderedMarkdownLine(markdownLine ?? { text: rawLine, segments: [] }, width, options)) {
             lines.push({
                 text: wrapped.text,
                 ...(wrapped.copyText === undefined ? {} : { copyText: wrapped.copyText }),
@@ -122,11 +123,11 @@ export function markdownSyntaxHighlightsForText(text, startColumn = 0) {
     }
     return highlights;
 }
-function wrapRenderedMarkdownLine(line, width) {
+function wrapRenderedMarkdownLine(line, width, options) {
     const safeWidth = Math.max(1, width);
     if (stringDisplayWidth(line.text) <= safeWidth)
         return [line];
-    const ranges = wrapDisplayLineByWordsWithRanges(line.text, safeWidth);
+    const ranges = wrapDisplayLineByWordsWithRanges(line.text, safeWidth, options);
     return ranges.map((range, index) => ({
         text: range.text,
         copyText: line.text.slice(range.start, ranges[index + 1]?.start ?? range.end),
@@ -134,7 +135,7 @@ function wrapRenderedMarkdownLine(line, width) {
         segments: line.segments.flatMap((segment) => shiftSegmentToRange(segment, range.start, range.end)),
     }));
 }
-function wrapDisplayLineByWordsWithRanges(text, width) {
+function wrapDisplayLineByWordsWithRanges(text, width, options) {
     const chunks = [];
     let chunkText = "";
     let chunkStart = 0;
@@ -165,10 +166,19 @@ function wrapDisplayLineByWordsWithRanges(text, width) {
                 chunkEnd = token.end;
             }
             else {
-                chunks.push(trimTrailingWhitespaceChunk(chunkText, chunkStart));
-                chunkText = "";
-                chunkStart = token.end;
-                chunkEnd = token.end;
+                const rewrapped = options.preserveWrappedWordSeparator
+                    ? splitChunkBeforeTrailingWord(chunkText, chunkStart, token, width)
+                    : undefined;
+                if (rewrapped) {
+                    chunks.push(rewrapped.previous);
+                    setChunk(rewrapped.next);
+                }
+                else {
+                    chunks.push(trimTrailingWhitespaceChunk(chunkText, chunkStart));
+                    chunkText = "";
+                    chunkStart = token.end;
+                    chunkEnd = chunkStart;
+                }
             }
             continue;
         }
@@ -182,6 +192,14 @@ function wrapDisplayLineByWordsWithRanges(text, width) {
             chunkEnd = token.end;
             continue;
         }
+        const rewrapped = options.preserveWrappedWordSeparator
+            ? splitChunkBeforeTrailingWordWithNextToken(chunkText, chunkStart, token, width)
+            : undefined;
+        if (rewrapped) {
+            chunks.push(rewrapped.previous);
+            setChunk(rewrapped.next);
+            continue;
+        }
         chunks.push(trimTrailingWhitespaceChunk(chunkText, chunkStart));
         appendTokenToEmptyChunk(token);
     }
@@ -238,6 +256,55 @@ function trimTrailingWhitespaceChunk(text, start) {
     const trimmed = text.replace(/\s+$/u, "");
     return { text: trimmed, start, end: start + trimmed.length };
 }
+function splitChunkBeforeTrailingWord(chunkText, chunkStart, separator, width) {
+    const match = /^(.*\S)(\s+)(\S+)$/u.exec(chunkText);
+    if (!match)
+        return undefined;
+    const prefix = match[1] ?? "";
+    const whitespace = match[2] ?? "";
+    const trailingWord = match[3] ?? "";
+    if (!prefix || !whitespace || !trailingWord)
+        return undefined;
+    const nextText = `${trailingWord}${separator.text}`;
+    if (stringDisplayWidth(nextText) > width)
+        return undefined;
+    const previous = trimTrailingWhitespaceChunk(prefix, chunkStart);
+    if (!previous.text)
+        return undefined;
+    const trailingWordStart = chunkStart + prefix.length + whitespace.length;
+    return {
+        previous,
+        next: { text: nextText, start: trailingWordStart, end: separator.end },
+    };
+}
+function splitChunkBeforeTrailingWordWithNextToken(chunkText, chunkStart, nextToken, width) {
+    const match = /^(.*\S)(\s+)(\S+)(\s+)$/u.exec(chunkText);
+    if (!match)
+        return undefined;
+    const prefix = match[1] ?? "";
+    const whitespace = match[2] ?? "";
+    const trailingWord = match[3] ?? "";
+    const trailingWhitespace = match[4] ?? "";
+    if (!prefix || !whitespace || !trailingWord || !trailingWhitespace)
+        return undefined;
+    if (!shouldMoveTrailingWordToPreserveSeparator(prefix, trailingWord, width))
+        return undefined;
+    const nextText = `${trailingWord}${trailingWhitespace}${nextToken.text}`;
+    if (stringDisplayWidth(nextText) > width)
+        return undefined;
+    const previous = trimTrailingWhitespaceChunk(prefix, chunkStart);
+    if (!previous.text)
+        return undefined;
+    const trailingWordStart = chunkStart + prefix.length + whitespace.length;
+    return {
+        previous,
+        next: { text: nextText, start: trailingWordStart, end: nextToken.end },
+    };
+}
+function shouldMoveTrailingWordToPreserveSeparator(prefix, trailingWord, width) {
+    return stringDisplayWidth(prefix) >= Math.floor(width / 2)
+        && stringDisplayWidth(trailingWord) >= MIN_TRAILING_WORD_WIDTH_TO_REBALANCE;
+}
 function shiftSegmentToRange(segment, rangeStart, rangeEnd) {
     const start = Math.max(segment.start, rangeStart);
     const end = Math.min(segment.end, rangeEnd);