@xp266/dshtui 0.1.0

package/src/model/selection.ts

@@ -0,0 +1,63 @@
+export interface LineSelection {
+  anchorRow: number
+  anchorCol: number
+  focusRow: number
+  focusCol: number
+  inMessage: boolean
+}
+
+export function selectedRange(sel: LineSelection, row: number): { start: number; end: number } | null {
+  const top = Math.min(sel.anchorRow, sel.focusRow)
+  const bottom = Math.max(sel.anchorRow, sel.focusRow)
+  if (row < top || row > bottom) return null
+  if (sel.anchorRow === sel.focusRow) {
+    return { start: Math.min(sel.anchorCol, sel.focusCol), end: Math.max(sel.anchorCol, sel.focusCol) }
+  }
+  const upward = sel.focusRow < sel.anchorRow
+  if (row === sel.anchorRow) {
+    return upward ? { start: 0, end: sel.anchorCol } : { start: sel.anchorCol, end: Infinity }
+  }
+  if (row === sel.focusRow) {
+    return upward ? { start: sel.focusCol, end: Infinity } : { start: 0, end: sel.focusCol }
+  }
+  return { start: 0, end: Infinity }
+}
+
+export function toScreenSelection(
+  selection: LineSelection | null,
+  scrollTop: number,
+  messageHeight: number,
+): LineSelection | null {
+  if (selection === null) return null
+  if (!selection.inMessage) return selection
+  const rawAnchor = selection.anchorRow - scrollTop
+  const rawFocus = selection.focusRow - scrollTop
+  const visible = (row: number) => row >= 0 && row < messageHeight
+  if (!visible(rawAnchor) && !visible(rawFocus)) return null
+  const clampRow = (row: number): number => (row < 0 ? 0 : row >= messageHeight ? messageHeight - 1 : row)
+  const snapCol = (raw: number, col: number): number => (raw < 0 ? 0 : raw >= messageHeight ? Infinity : col)
+  return {
+    anchorRow: clampRow(rawAnchor),
+    anchorCol: snapCol(rawAnchor, selection.anchorCol),
+    focusRow: clampRow(rawFocus),
+    focusCol: snapCol(rawFocus, selection.focusCol),
+    inMessage: true,
+  }
+}
+
+export function clampFocusRow(
+  inMessage: boolean,
+  eventY: number,
+  scrollTop: number,
+  messageHeight: number,
+  rows: number,
+  dialogOpen: boolean,
+): number {
+  if (inMessage) {
+    return Math.min(eventY + scrollTop, scrollTop + messageHeight - 1)
+  }
+  if (dialogOpen) {
+    return Math.max(0, Math.min(eventY, rows - 1))
+  }
+  return Math.max(messageHeight, eventY)
+}

package/src/performance-guard.ts

@@ -0,0 +1,28 @@
+import { performance } from 'node:perf_hooks'
+
+const TIMELINE_SWEEP_MS = 10_000
+
+/**
+ * The development react-reconciler build records one user-timing entry per
+ * component render into the global timeline, which Node never evicts by
+ * itself, so a long streaming session grows the heap until OOM. The entry
+ * sink is read at call time, so neutralising it before the first render
+ * keeps the timeline flat regardless of which build is loaded; the periodic
+ * sweep drains anything recorded outside this process boundary.
+ */
+export function startPerformanceGuard(): () => void {
+  const measure = performance.measure.bind(performance)
+  const mark = performance.mark.bind(performance)
+  performance.measure = (() => {}) as unknown as typeof performance.measure
+  performance.mark = (() => {}) as unknown as typeof performance.mark
+  const timer = setInterval(() => {
+    performance.clearMeasures()
+    performance.clearMarks()
+  }, TIMELINE_SWEEP_MS)
+  timer.unref()
+  return () => {
+    clearInterval(timer)
+    performance.measure = measure
+    performance.mark = mark
+  }
+}

package/src/runtime/prod-react.ts

@@ -0,0 +1,10 @@
+// React picks its development or production build at import time from
+// NODE_ENV; the dsh launcher leaves it unset, so the default resolution loads
+// react.development.js and every reconciler frame pays roughly twice the
+// CPU. Pin production before the UI graph's react imports evaluate — this
+// module must stay the first import of every entry that pulls react. The
+// host reads NODE_ENV only during module loading (verified across
+// @deepseek-ai packages), so the pin is inert outside module resolution.
+if (process.env.NODE_ENV === undefined || process.env.NODE_ENV === '') {
+  process.env.NODE_ENV = 'production'
+}

package/src/terminal/background.ts

@@ -0,0 +1,66 @@
+import { colorLevel } from './capabilities.ts'
+import { env } from '../env.ts'
+import type { ThemeMode } from '../theme.ts'
+
+const OSC11_QUERY = '\x1b]11;?\x1b\\'
+const OSC11_RESPONSE = /\x1b]11;rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})(?:\x07|\x1b\\)/
+const OSC11_TIMEOUT_MS = 250
+
+function parseColorFgbg(): ThemeMode | undefined {
+  const raw = process.env.COLORFGBG
+  if (raw === undefined) return undefined
+  const bg = Number(raw.split(';')[1])
+  if (Number.isNaN(bg)) return undefined
+  return bg === 7 || bg === 15 ? 'light' : 'dark'
+}
+
+function luminance(r: number, g: number, b: number): number {
+  return 0.299 * r + 0.587 * g + 0.114 * b
+}
+
+function queryOsc11Background(): Promise<ThemeMode | undefined> {
+  return new Promise(resolve => {
+    const stdin = process.stdin
+    if (colorLevel === 0 || !stdin.isTTY || !process.stdout.isTTY || stdin.setRawMode === undefined) {
+      resolve(undefined)
+      return
+    }
+    let buffer = ''
+    let timer: ReturnType<typeof setTimeout> | undefined
+    const finish = (result: ThemeMode | undefined): void => {
+      if (timer !== undefined) clearTimeout(timer)
+      stdin.off('data', onData)
+      try {
+        stdin.setRawMode(false)
+      } catch {
+        // The stream may have closed while the probe was in flight; nothing to restore.
+      }
+      resolve(result)
+    }
+    const onData = (chunk: Buffer | string): void => {
+      buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8')
+      const match = OSC11_RESPONSE.exec(buffer)
+      if (match === null) return
+      const channel = (hex: string): number => parseInt(hex, 16) / (16 ** hex.length - 1)
+      const bright = luminance(channel(match[1]), channel(match[2]), channel(match[3])) > 0.5
+      finish(bright ? 'light' : 'dark')
+    }
+    try {
+      stdin.setRawMode(true)
+    } catch {
+      // Raw mode is unavailable (piped stdin or non-TTY); default to dark.
+      resolve(undefined)
+      return
+    }
+    stdin.on('data', onData)
+    process.stdout.write(OSC11_QUERY)
+    timer = setTimeout(() => finish(undefined), OSC11_TIMEOUT_MS)
+  })
+}
+
+export async function detectBackgroundMode(): Promise<ThemeMode> {
+  if (env.background === 'dark' || env.background === 'light') return env.background
+  const colorFgbg = parseColorFgbg()
+  if (colorFgbg !== undefined) return colorFgbg
+  return (await queryOsc11Background()) ?? 'dark'
+}

package/src/terminal/capabilities.ts

@@ -0,0 +1,54 @@
+import chalk from 'chalk'
+import { env } from '../env.ts'
+
+export type ColorLevel = 0 | 1 | 2 | 3
+
+function parseForcedColorLevel(value: string | undefined): ColorLevel | undefined {
+  if (value === '0' || value === '1' || value === '2' || value === '3') return Number(value) as ColorLevel
+  if (value === 'truecolor') return 3
+  if (value === 'none' || value === 'false') return 0
+  return undefined
+}
+
+function detectColorLevel(): ColorLevel {
+  const forced = parseForcedColorLevel(env.color)
+  if (forced !== undefined) return forced
+  if (process.env.NO_COLOR !== undefined) return 0
+  const forceColor = process.env.FORCE_COLOR
+  if (forceColor !== undefined) {
+    if (forceColor === 'false' || forceColor === '0') return 0
+    if (forceColor === 'true' || forceColor === '') return 1
+    const parsed = Number(forceColor)
+    if (parsed === 1 || parsed === 2 || parsed === 3) return parsed
+  }
+  const term = process.env.TERM ?? ''
+  if (term === 'dumb') return 0
+  const colorterm = process.env.COLORTERM ?? ''
+  if (colorterm === 'truecolor' || colorterm === '24bit') return 3
+  if (term.includes('truecolor')) return 3
+  if (process.env.WT_SESSION !== undefined) return 3
+  if (term.includes('256color')) return 2
+  if (term !== '' || process.env.TERM_PROGRAM !== undefined) return 1
+  return 0
+}
+
+function detectUnicode(): boolean {
+  if (env.ascii) return false
+  if ((process.env.TERM ?? '') === 'dumb') return false
+  const locale = process.env.LC_ALL ?? process.env.LANG ?? ''
+  if (locale === '' || /utf-?8/i.test(locale)) return true
+  const base = locale.split('.')[0] ?? locale
+  if (base === 'C' || base === 'POSIX') return false
+  return !locale.includes('.')
+}
+
+export let colorLevel: ColorLevel = detectColorLevel()
+
+export function setColorLevel(level: ColorLevel): void {
+  colorLevel = level
+  chalk.level = level
+}
+
+chalk.level = colorLevel
+
+export const unicode: boolean = detectUnicode()

package/src/terminal/clipboard-backends.ts

@@ -0,0 +1,69 @@
+import { keyedRegistry } from '../kernel/registry.ts'
+
+export interface ClipboardBackendContribution {
+  id: string
+  order?: number
+  /** Read text from the clipboard; return undefined to fall through. */
+  readText?(): string | undefined | Promise<string | undefined>
+  /** Read an image; return undefined to fall through. */
+  readImage?(): { data: Uint8Array; mediaType: string } | undefined | Promise<{ data: Uint8Array; mediaType: string } | undefined>
+  /** Write text; return true to stop the write chain. */
+  writeText?(text: string): boolean
+}
+
+const backends = keyedRegistry<ClipboardBackendContribution>()
+
+/**
+ * Plugin clipboard backends run before the builtin platform chain (default
+ * order 100 vs builtin 500): a backend that returns undefined lets the next
+ * one try. Write chains stop at the first backend that returns true.
+ */
+export const CLIPBOARD_BUILTIN_ORDER = 500
+
+export function registerClipboardBackend(contribution: ClipboardBackendContribution): () => void {
+  return backends.register(contribution.id, contribution, { order: contribution.order ?? 100 })
+}
+
+export function subscribeClipboardBackends(listener: () => void): () => void {
+  return backends.subscribe(listener)
+}
+
+export async function clipboardReadText(builtin: () => Promise<string | undefined>): Promise<string | undefined> {
+  for (const backend of backends.values()) {
+    if (backend.readText === undefined) continue
+    try {
+      const result = await backend.readText()
+      if (result !== undefined) return result
+    } catch {
+      // fall through to the next backend
+    }
+  }
+  return builtin()
+}
+
+export async function clipboardReadImage(
+  builtin: () => Promise<{ data: Uint8Array; mediaType: string } | undefined>,
+): Promise<{ data: Uint8Array; mediaType: string } | undefined> {
+  for (const backend of backends.values()) {
+    if (backend.readImage === undefined) continue
+    try {
+      const result = await backend.readImage()
+      if (result !== undefined) return result
+    } catch {
+      // fall through to the next backend
+    }
+  }
+  return builtin()
+}
+
+export function clipboardWriteText(text: string, builtin: (text: string) => void): void {
+  for (const backend of backends.values()) {
+    if (backend.writeText === undefined) continue
+    try {
+      if (backend.writeText(text) === true) return
+    } catch {
+      // fall through to the next backend
+    }
+  }
+  builtin(text)
+}

package/src/terminal/clipboard.ts

@@ -0,0 +1,161 @@
+import { execFile } from 'node:child_process'
+import { platform, release, tmpdir } from 'node:os'
+import { readFile, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { clipboardReadImage, clipboardReadText, clipboardWriteText } from './clipboard-backends.ts'
+
+/**
+ * Clipboard writes go through OSC52 only: one escape sequence to the terminal,
+ * no child processes. The terminal owns the system clipboard, so the app never
+ * races platform tools (clip.exe mangles unicode through the console codepage
+ * and every spawned helper adds copy latency for no benefit).
+ */
+export function writeOsc52(text: string): void {
+  const encoded = Buffer.from(text, 'utf8').toString('base64')
+  process.stdout.write(`\x1b]52;c;${encoded}\x07`)
+}
+
+export function isWsl(): boolean {
+  if (platform() !== 'linux') return false
+  if (process.env.WSL_DISTRO_NAME !== undefined) return true
+  return release().toLowerCase().includes('microsoft')
+}
+
+export interface ClipboardImage {
+  data: Uint8Array
+  mediaType: string
+}
+
+const EXEC_TIMEOUT_MS = 2000
+const MAX_CAPTURE_BYTES = 32 * 1024 * 1024
+
+function capture(command: string, args: string[]): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { timeout: EXEC_TIMEOUT_MS, maxBuffer: MAX_CAPTURE_BYTES, encoding: 'buffer' }, (error, stdout) => {
+      if (error !== null) {
+        reject(error)
+        return
+      }
+      if (stdout.length === 0) {
+        reject(new Error(`${command} returned nothing`))
+        return
+      }
+      resolve(stdout)
+    })
+  })
+}
+
+async function firstCapture(attempts: Array<{ command: string; args: string[]; mediaType: string }>): Promise<ClipboardImage | undefined> {
+  for (const attempt of attempts) {
+    try {
+      const data = new Uint8Array(await capture(attempt.command, attempt.args))
+      return { data, mediaType: attempt.mediaType }
+    } catch {
+      // The helper is missing or returned nothing; try the next backend.
+    }
+  }
+  return undefined
+}
+
+async function firstText(attempts: Array<{ command: string; args: string[] }>): Promise<string | undefined> {
+  for (const attempt of attempts) {
+    try {
+      const data = await capture(attempt.command, attempt.args)
+      return data.toString('utf8')
+    } catch {
+      // The helper is missing or returned nothing; try the next backend.
+    }
+  }
+  return undefined
+}
+
+async function readClipboardImageBuiltin(): Promise<ClipboardImage | undefined> {
+  if (platform() === 'darwin') {
+    const file = join(tmpdir(), 'dshtui-clipboard.png')
+    const escaped = file.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+    const script = [
+      'set imageData to the clipboard as "PNGf"',
+      `set fileRef to open for access POSIX file "${escaped}" with write permission`,
+      'set eof fileRef to 0',
+      'write imageData to fileRef',
+      'close access fileRef',
+    ]
+    const args: string[] = []
+    for (const line of script) args.push('-e', line)
+    try {
+      await capture('osascript', args)
+      const data = new Uint8Array(await readFile(file))
+      return { data, mediaType: 'image/png' }
+    } catch {
+      // No image on the clipboard (or osascript missing); report undefined.
+      return undefined
+    } finally {
+      await rm(file, { force: true }).catch(() => {})
+    }
+  }
+  const unix = await firstCapture([
+    { command: 'wl-paste', args: ['-t', 'image/png'], mediaType: 'image/png' },
+    { command: 'wl-paste', args: ['-t', 'image/jpeg'], mediaType: 'image/jpeg' },
+    { command: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], mediaType: 'image/png' },
+    { command: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/jpeg', '-o'], mediaType: 'image/jpeg' },
+  ])
+  if (unix !== undefined) return unix
+  if (platform() === 'win32' || isWsl()) {
+    const script = 'Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img) { $ms = New-Object System.IO.MemoryStream; $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); [Console]::Out.Write([Convert]::ToBase64String($ms.ToArray())) }'
+    try {
+      const base64 = (await capture('powershell.exe', ['-NonInteractive', '-NoProfile', '-command', script])).toString('utf8').trim()
+      if (base64 === '') return undefined
+      return { data: new Uint8Array(Buffer.from(base64, 'base64')), mediaType: 'image/png' }
+    } catch {
+      // No image on the clipboard (or powershell missing); report undefined.
+      return undefined
+    }
+  }
+  return undefined
+}
+
+async function readClipboardTextBuiltin(): Promise<string | undefined> {
+  if (platform() === 'darwin') return firstText([{ command: 'pbpaste', args: [] }])
+  const unix = await firstText([
+    { command: 'wl-paste', args: [] },
+    { command: 'xclip', args: ['-selection', 'clipboard', '-o'] },
+    { command: 'xsel', args: ['--clipboard', '--output'] },
+  ])
+  if (unix !== undefined) return unix
+  if (platform() === 'win32' || isWsl()) {
+    return firstText([{ command: 'powershell.exe', args: ['-NonInteractive', '-NoProfile', '-command', '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Get-Clipboard'] }])
+  }
+  return undefined
+}
+
+export async function readClipboardImageUris(): Promise<string[]> {
+  if (platform() !== 'linux') return []
+  const uris = await firstText([
+    { command: 'wl-paste', args: ['-t', 'text/uri-list'] },
+    { command: 'xclip', args: ['-selection', 'clipboard', '-t', 'text/uri-list', '-o'] },
+  ])
+  if (uris === undefined) return []
+  return uris
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(line => line.startsWith('file://'))
+    .map(line => decodeURIComponent(line.slice('file://'.length)))
+}
+
+/** Backend-chain-aware clipboard read; plugin backends run first. */
+export async function readClipboardText(): Promise<string | undefined> {
+  const text = await clipboardReadText(readClipboardTextBuiltin)
+  // A U+FEFF in clipboard text is BOM contamination (legacy clip.exe writes),
+  // never meaningful content: drop it for every consumer.
+  return text === undefined ? undefined : text.replace(/\ufeff/g, '')
+}
+
+/** Backend-chain-aware image read; plugin backends run first. */
+export async function readClipboardImage(): Promise<ClipboardImage | undefined> {
+  return clipboardReadImage(readClipboardImageBuiltin)
+}
+
+/** Backend-chain-aware write; the first backend claiming the write stops the chain. */
+export function writeClipboardText(text: string): void {
+  clipboardWriteText(text, writeOsc52)
+}

package/src/terminal/cursor-shape.ts

@@ -0,0 +1,13 @@
+const SEQUENCES = {
+  beam: '\x1b[1 q',
+  block: '\x1b[2 q',
+  reset: '\x1b[0 q',
+  hide: '\x1b[?25l',
+  show: '\x1b[?25h',
+} as const
+
+export type CursorShape = keyof typeof SEQUENCES
+
+export function writeCursorShape(shape: CursorShape): void {
+  process.stdout.write(SEQUENCES[shape])
+}

package/src/terminal/glyphs.ts

@@ -0,0 +1,44 @@
+import { unicode } from './capabilities.ts'
+
+type BorderTriple = readonly [string, string, string]
+
+const borderTop: BorderTriple = unicode ? ['┌', '┬', '┐'] : ['+', '-', '+']
+const borderMiddle: BorderTriple = unicode ? ['├', '┼', '┤'] : ['+', '-', '+']
+const borderBottom: BorderTriple = unicode ? ['└', '┴', '┘'] : ['+', '-', '+']
+
+export const glyphs = {
+  spinnerFrames: unicode
+    ? ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+    : ['|', '/', '-', '\\'],
+  bullets: unicode ? ['•', '◦', '▪'] : ['*', 'o', '-'],
+  horizontal: unicode ? '─' : '-',
+  tableVertical: unicode ? '│' : '|',
+  tableBorders: {
+    top: borderTop,
+    middle: borderMiddle,
+    bottom: borderBottom,
+  },
+  quoteBar: unicode ? '▌' : '|',
+  taskChecked: unicode ? '☑' : '[x]',
+  taskUnchecked: unicode ? '☐' : '[ ]',
+  headerExpanded: unicode ? '↓' : 'v',
+  headerCollapsed: '-',
+  treeBranch: unicode ? '└' : '+',
+  separator: unicode ? '·' : '-',
+  tokenArrow: unicode ? '→' : '->',
+  ellipsis: unicode ? '…' : '...',
+  focusMarker: unicode ? '❯' : '>',
+  tick: unicode ? '✓' : 'x',
+  checkboxOn: unicode ? '[✓]' : '[x]',
+  checkboxOff: '[ ]',
+  pageFlip: unicode ? '⇄' : '<->',
+  wrapArrows: unicode ? '⇅' : '^v',
+  carouselLeft: unicode ? '◀' : '<',
+  carouselRight: unicode ? '▶' : '>',
+  todoPending: '[ ]',
+  todoInProgress: unicode ? '[●]' : '[o]',
+  todoDone: unicode ? '[√]' : '[x]',
+  halfBlockCaps: unicode,
+  blockCapTop: '▄',
+  blockCapBottom: '▀',
+}

package/src/terminal/mouse.ts

@@ -0,0 +1,154 @@
+export type MouseEventType = 'down' | 'up' | 'drag' | 'move' | 'scroll'
+
+export interface MouseEventData {
+  type: MouseEventType
+  button: number
+  x: number
+  y: number
+  modifiers: { shift: boolean; alt: boolean; ctrl: boolean }
+  scrollDirection?: 'up' | 'down'
+}
+
+const MOUSE_ENABLE_SEQUENCES = '\x1b[?1003l\x1b[?1000h\x1b[?1002h\x1b[?1006h'
+const MOUSE_DISABLE_SEQUENCES = '\x1b[?1003l\x1b[?1000l\x1b[?1002l\x1b[?1006l'
+
+export function writeMouseEnable(): void {
+  process.stdout.write(MOUSE_ENABLE_SEQUENCES)
+}
+
+export function writeMouseDisable(): void {
+  process.stdout.write(MOUSE_DISABLE_SEQUENCES)
+}
+
+interface ParsedSequence {
+  event: MouseEventData
+  consumed: number
+}
+
+const MAX_BUFFER = 64
+const SGR_PREFIX = '\x1b[<'
+
+function partialPrefixLength(buffer: string): number {
+  for (let keep = Math.min(2, buffer.length); keep > 0; keep--) {
+    if (SGR_PREFIX.startsWith(buffer.slice(-keep))) return keep
+  }
+  return 0
+}
+
+export function createMouseParser(onEvent: (event: MouseEventData) => void) {
+  let buffer = ''
+  const pressedButtons = new Set<number>()
+  function parseSequenceAt(str: string, offset: number): ParsedSequence | null {
+    if (!str.startsWith('\x1b[<', offset)) return null
+    let index = offset + 3
+    const values: number[] = []
+    let current = 0
+    let hasDigit = false
+    let terminator = ''
+    for (; index < str.length; index++) {
+      const ch = str[index]
+      if (ch >= '0' && ch <= '9') {
+        current = current * 10 + (ch.charCodeAt(0) - 48)
+        hasDigit = true
+      } else if (ch === ';' && hasDigit) {
+        values.push(current)
+        current = 0
+        hasDigit = false
+      } else if (ch === 'M' || ch === 'm') {
+        if (!hasDigit) return null
+        values.push(current)
+        terminator = ch
+        break
+      } else {
+        return null
+      }
+    }
+    if (terminator === '') return null
+    if (values.length !== 3) return null
+    return { event: decodeSgrEvent(values[0], values[1], values[2], terminator as 'M' | 'm', pressedButtons), consumed: index - offset + 1 }
+  }
+  return {
+    feed(chunk: string): void {
+      buffer += chunk
+      while (true) {
+        const start = buffer.indexOf('\x1b[<')
+        if (start === -1) {
+          const keep = partialPrefixLength(buffer)
+          buffer = keep === 0 ? '' : buffer.slice(-keep)
+          return
+        }
+        if (start > 0) {
+          buffer = buffer.slice(start)
+          continue
+        }
+        if (buffer.length > MAX_BUFFER) {
+          buffer = ''
+          return
+        }
+        const parsed = parseSequenceAt(buffer, 0)
+        if (parsed === null) return
+        const { event, consumed } = parsed
+        buffer = buffer.slice(consumed)
+        onEvent(event)
+      }
+    },
+  }
+}
+
+function decodeSgrEvent(rawButtonCode: number, wireX: number, wireY: number, pressRelease: 'M' | 'm', pressed: Set<number>): MouseEventData {
+  const button = rawButtonCode & 3
+  const isScroll = (rawButtonCode & 64) !== 0
+  const isMotion = (rawButtonCode & 32) !== 0
+  const modifiers = {
+    shift: (rawButtonCode & 4) !== 0,
+    alt: (rawButtonCode & 8) !== 0,
+    ctrl: (rawButtonCode & 16) !== 0,
+  }
+  let type: MouseEventType
+  let scrollDirection: 'up' | 'down' | undefined
+  if (isScroll) {
+    type = 'scroll'
+    scrollDirection = button === 0 ? 'up' : 'down'
+  } else if (isMotion) {
+    type = pressed.size > 0 ? 'drag' : 'move'
+  } else if (pressRelease === 'M') {
+    type = 'down'
+    if (button !== 3) pressed.add(button)
+  } else {
+    type = 'up'
+    if (button === 3) pressed.clear()
+    else pressed.delete(button)
+  }
+  return {
+    type,
+    button: button === 3 ? 0 : button,
+    x: wireX - 1,
+    y: wireY - 1,
+    modifiers,
+    ...(scrollDirection === undefined ? {} : { scrollDirection }),
+  }
+}
+
+export function isMouseResidue(input: string): boolean {
+  return input.includes('\x1b') || /^\[<\d+(;\d+)*[Mm]$/.test(input)
+}
+
+export interface MouseController {
+  enable: () => void
+  disable: () => void
+}
+
+export function createMouseController(onEvent: (event: MouseEventData) => void): MouseController {
+  const parser = createMouseParser(onEvent)
+  const onData = (chunk: Buffer) => parser.feed(chunk.toString('latin1'))
+  return {
+    enable() {
+      writeMouseEnable()
+      process.stdin.on('data', onData)
+    },
+    disable() {
+      writeMouseDisable()
+      process.stdin.off('data', onData)
+    },
+  }
+}