fix(terminal): retain selection through redraw

Author: skulidropek

packages/terminal/src/web/terminal-copy-interaction.ts

@@ -17,6 +17,10 @@ type TerminalSelectionTarget = {
   readonly hasSelection: () => boolean
 }
 
+type TerminalDisposable = {
+  readonly dispose: () => void
+}
+
 export type TerminalCopyKeyboardEvent = {
   readonly altKey: boolean
   readonly ctrlKey: boolean
@@ -32,6 +36,7 @@ export type TerminalCopyInteractionTerminal = TerminalSelectionTarget & {
   readonly modes: {
     readonly mouseTrackingMode: TerminalMouseTrackingMode
   }
+  readonly onSelectionChange?: (handler: () => void) => TerminalDisposable
 }
 
 type TerminalCopyClipboardData = {
@@ -197,6 +202,7 @@ class TerminalSelectionContextSnapshot {
 class TerminalCopyInteractionController {
   private readonly selectionContext: TerminalSelectionContextSnapshot
   private readonly selectionDrag: ReturnType<typeof createTerminalSelectionDragController>
+  private selectionChangeDisposable: TerminalDisposable | null = null
 
   constructor(private readonly args: TerminalCopyInteractionArgs) {
     this.selectionContext = new TerminalSelectionContextSnapshot(args.terminal)
@@ -205,15 +211,36 @@ class TerminalCopyInteractionController {
 
   readonly attach = (): { readonly dispose: () => void } => {
     this.args.terminal.attachCustomKeyEventHandler?.(this.onTerminalKeyEvent)
+    this.selectionChangeDisposable = this.args.terminal.onSelectionChange?.(this.onTerminalSelectionChange) ?? null
     this.args.host.addEventListener("mousedown", this.onMouseDown, true)
     this.args.host.addEventListener("mouseup", this.onMouseUp, true)
     this.args.host.addEventListener("contextmenu", this.onContextMenu, true)
     this.args.host.addEventListener("copy", this.onCopy, true)
     return { dispose: this.dispose }
   }
 
+  private readonly shouldLetBrowserHandleCopyShortcut = (event: TerminalCopyKeyboardEvent): boolean =>
+    shouldLetBrowserHandleTerminalCopyShortcut(event, this.args.terminal) ||
+    (isKeyboardCopyShortcut(event) && this.selectionContext.has())
+
   private readonly onTerminalKeyEvent = (event: TerminalCopyKeyboardEvent): boolean =>
-    !shouldLetBrowserHandleTerminalCopyShortcut(event, this.args.terminal)
+    !this.shouldLetBrowserHandleCopyShortcut(event)
+
+  private readonly onTerminalSelectionChange = (): void => {
+    // CHANGE: keep a copyable snapshot before terminal redraws can drop xterm's live selection.
+    // WHY: Claude Code periodically repaints the TUI; xterm selection is buffer-bound and may vanish during repaint.
+    // QUOTE(ТЗ): "когда очистился выделение бы не спадало"
+    // REF: user-message-2026-06-15-terminal-redraw-selection
+    // SOURCE: n/a
+    // FORMAT THEOREM: selected(t) before redraw(t) => cachedSelection(t)
+    // PURITY: SHELL
+    // EFFECT: reads terminal.hasSelection() and terminal.getSelection().
+    // INVARIANT: empty redraw selection events do not erase the last user-created non-empty selection snapshot.
+    // COMPLEXITY: O(n)/O(1) where n = selected text length.
+    if (this.args.terminal.hasSelection()) {
+      this.selectionContext.refresh()
+    }
+  }
 
   private readonly hasProtectedSelectionContext = (): boolean =>
     hasActiveMouseTracking(this.args.terminal) &&
@@ -295,6 +322,8 @@ class TerminalCopyInteractionController {
   }
 
   private readonly dispose = (): void => {
+    this.selectionChangeDisposable?.dispose()
+    this.selectionChangeDisposable = null
     this.selectionDrag.dispose()
     this.selectionContext.clear()
     this.args.host.removeEventListener("mousedown", this.onMouseDown, true)

packages/terminal/tests/web/terminal-copy-redraw-interaction.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "@effect/vitest"
+
+import {
+  attachTerminalCopyInteraction,
+  type TerminalCopyInteractionTerminal,
+  type TerminalCopyKeyboardEvent
+} from "../../src/web/terminal-copy-interaction.js"
+import { copyEvent, FakeTerminalCopyHost, mouseEvent } from "./fixtures/terminal-copy-interaction.js"
+
+const keyboardCopyEvent: TerminalCopyKeyboardEvent = {
+  altKey: false,
+  ctrlKey: true,
+  key: "c",
+  metaKey: false,
+  type: "keydown"
+}
+
+describe("terminal copy redraw interaction", () => {
+  it("keeps selection snapshot copyable after terminal redraw clears live selection", () => {
+    let terminalSelection = ""
+    const keyHandlers: Array<(event: TerminalCopyKeyboardEvent) => boolean> = []
+    const selectionChangeHandlers: Array<() => void> = []
+    const clipboardWrites: Array<{ readonly data: string; readonly format: string }> = []
+    const host = new FakeTerminalCopyHost(null)
+    const terminal: TerminalCopyInteractionTerminal = {
+      attachCustomKeyEventHandler: (handler) => {
+        keyHandlers.push(handler)
+      },
+      getSelection: () => terminalSelection,
+      hasSelection: () => terminalSelection.length > 0,
+      modes: { mouseTrackingMode: "any" },
+      onSelectionChange: (handler) => {
+        selectionChangeHandlers.push(handler)
+        return {
+          dispose: () => {
+            const handlerIndex = selectionChangeHandlers.indexOf(handler)
+            if (handlerIndex !== -1) {
+              selectionChangeHandlers.splice(handlerIndex, 1)
+            }
+          }
+        }
+      }
+    }
+    const disposable = attachTerminalCopyInteraction({ host, terminal })
+
+    terminalSelection = "selected before redraw"
+    for (const handler of selectionChangeHandlers) {
+      handler()
+    }
+    terminalSelection = ""
+
+    expect(keyHandlers).toHaveLength(1)
+    const handleKey = keyHandlers[0] ?? expect.fail("Expected terminal copy key handler to be registered.")
+    expect(handleKey(keyboardCopyEvent)).toBe(false)
+
+    const contextMenu = mouseEvent(0, "contextmenu")
+    const copy = copyEvent({
+      setData: (format: string, data: string) => {
+        clipboardWrites.push({ data, format })
+      }
+    })
+    host.dispatchMouse("contextmenu", contextMenu)
+    host.dispatchCopy(copy)
+
+    expect(contextMenu.shiftKey).toBe(true)
+    expect(contextMenu.stopImmediatePropagationCalls).toBe(1)
+    expect(contextMenu.stopPropagationCalls).toBeGreaterThanOrEqual(1)
+    expect(clipboardWrites).toEqual([{ data: "selected before redraw", format: "text/plain" }])
+    expect(copy.preventDefaultCalls).toBe(1)
+    expect(copy.stopPropagationCalls).toBe(1)
+    expect(selectionChangeHandlers).toHaveLength(1)
+    expect(handleKey(keyboardCopyEvent)).toBe(true)
+
+    disposable.dispose()
+    expect(selectionChangeHandlers).toHaveLength(0)
+  })
+})