nastech-tui 0.0.1

package/packages/nastech-ink/src/entry-exports.ts

@@ -0,0 +1,32 @@
+export { default as useStderr } from './hooks/use-stderr.js'
+export { default as useStdout } from './hooks/use-stdout.js'
+export { Ansi } from './ink/Ansi.js'
+export { evictInkCaches, type EvictLevel, type InkCacheSizes } from './ink/cache-eviction.js'
+export { AlternateScreen } from './ink/components/AlternateScreen.js'
+export { default as Box } from './ink/components/Box.js'
+export { default as Link } from './ink/components/Link.js'
+export { default as Newline } from './ink/components/Newline.js'
+export { NoSelect } from './ink/components/NoSelect.js'
+export { RawAnsi } from './ink/components/RawAnsi.js'
+export { default as ScrollBox } from './ink/components/ScrollBox.js'
+export { default as Spacer } from './ink/components/Spacer.js'
+export { default as Text } from './ink/components/Text.js'
+export { default as useApp } from './ink/hooks/use-app.js'
+export { useCursorAdvance } from './ink/hooks/use-cursor-advance.js'
+export { useDeclaredCursor } from './ink/hooks/use-declared-cursor.js'
+export { type RunExternalProcess, useExternalProcess, withInkSuspended } from './ink/hooks/use-external-process.js'
+export { default as useInput } from './ink/hooks/use-input.js'
+export { useHasSelection, useSelection } from './ink/hooks/use-selection.js'
+export { default as useStdin } from './ink/hooks/use-stdin.js'
+export { useTabStatus } from './ink/hooks/use-tab-status.js'
+export { useTerminalFocus } from './ink/hooks/use-terminal-focus.js'
+export { useTerminalTitle } from './ink/hooks/use-terminal-title.js'
+export { useTerminalViewport } from './ink/hooks/use-terminal-viewport.js'
+export { default as measureElement } from './ink/measure-element.js'
+export { scrollFastPathStats, type ScrollFastPathStats } from './ink/render-node-to-output.js'
+export { createRoot, forceRedraw, default as render, renderSync } from './ink/root.js'
+export { stringWidth } from './ink/stringWidth.js'
+export { wrapAnsi } from './ink/wrapAnsi.js'
+export { isXtermJs } from './ink/terminal.js'
+export type { MouseTrackingMode } from './ink/termio/dec.js'
+export { default as TextInput, UncontrolledTextInput } from 'ink-text-input'

package/packages/nastech-ink/src/hooks/use-stderr.ts

@@ -0,0 +1,15 @@
+import { useMemo } from 'react'
+export type StderrHandle = {
+  stderr: NodeJS.WriteStream
+  write: (data: string) => boolean
+}
+
+export default function useStderr(): StderrHandle {
+  return useMemo(
+    () => ({
+      stderr: process.stderr,
+      write: data => process.stderr.write(data)
+    }),
+    []
+  )
+}

package/packages/nastech-ink/src/hooks/use-stdout.ts

@@ -0,0 +1,15 @@
+import { useMemo } from 'react'
+export type StdoutHandle = {
+  stdout: NodeJS.WriteStream
+  write: (data: string) => boolean
+}
+
+export default function useStdout(): StdoutHandle {
+  return useMemo(
+    () => ({
+      stdout: process.stdout,
+      write: data => process.stdout.write(data)
+    }),
+    []
+  )
+}

package/packages/nastech-ink/src/ink/Ansi.tsx

@@ -0,0 +1,435 @@
+import React, { type ReactNode } from 'react'
+import { c as _c } from 'react/compiler-runtime'
+
+import Link from './components/Link.js'
+import Text from './components/Text.js'
+import type { Color } from './styles.js'
+import { type NamedColor, Parser, type Color as TermioColor, type TextStyle } from './termio.js'
+type Props = {
+  children?: ReactNode
+  /** When true, force all text to be rendered with dim styling */
+  dimColor?: boolean
+}
+type SpanProps = {
+  color?: Color
+  backgroundColor?: Color
+  dim?: boolean
+  bold?: boolean
+  italic?: boolean
+  underline?: boolean
+  strikethrough?: boolean
+  inverse?: boolean
+  hyperlink?: string
+}
+
+type Span = {
+  text: string
+  props: SpanProps
+}
+
+/**
+ * Component that parses ANSI escape codes and renders them using Text components.
+ *
+ * Use this as an escape hatch when you have pre-formatted ANSI strings from
+ * external tools (like cli-highlight) that need to be rendered in Ink.
+ *
+ * Memoized to prevent re-renders when parent changes but children string is the same.
+ */
+export const Ansi = React.memo(function Ansi(t0: Props) {
+  const $ = _c(12)
+
+  const { children, dimColor } = t0
+
+  if (typeof children !== 'string') {
+    let t1
+
+    if ($[0] !== children || $[1] !== dimColor) {
+      t1 = dimColor ? <Text dim={true}>{String(children)}</Text> : <Text>{String(children)}</Text>
+      $[0] = children
+      $[1] = dimColor
+      $[2] = t1
+    } else {
+      t1 = $[2]
+    }
+
+    return t1
+  }
+
+  if (children === '') {
+    return null
+  }
+
+  let t1
+  let t2
+
+  if ($[3] !== children || $[4] !== dimColor) {
+    t2 = Symbol.for('react.early_return_sentinel')
+
+    bb0: {
+      const spans = parseToSpans(children)
+
+      if (spans.length === 0) {
+        t2 = null
+
+        break bb0
+      }
+
+      if (spans.length === 1 && !hasAnyProps(spans[0].props)) {
+        t2 = dimColor ? <Text dim={true}>{spans[0].text}</Text> : <Text>{spans[0].text}</Text>
+
+        break bb0
+      }
+
+      let t3
+
+      if ($[7] !== dimColor) {
+        t3 = (span: Span, i: number) => {
+          const hyperlink = span.props.hyperlink
+
+          if (dimColor) {
+            span.props.dim = true
+          }
+
+          const hasTextProps = hasAnyTextProps(span.props)
+
+          if (hyperlink) {
+            return hasTextProps ? (
+              <Link key={i} url={hyperlink}>
+                <StyledText
+                  backgroundColor={span.props.backgroundColor}
+                  bold={span.props.bold}
+                  color={span.props.color}
+                  dim={span.props.dim}
+                  inverse={span.props.inverse}
+                  italic={span.props.italic}
+                  strikethrough={span.props.strikethrough}
+                  underline={span.props.underline}
+                >
+                  {span.text}
+                </StyledText>
+              </Link>
+            ) : (
+              <Link key={i} url={hyperlink}>
+                {span.text}
+              </Link>
+            )
+          }
+
+          return hasTextProps ? (
+            <StyledText
+              backgroundColor={span.props.backgroundColor}
+              bold={span.props.bold}
+              color={span.props.color}
+              dim={span.props.dim}
+              inverse={span.props.inverse}
+              italic={span.props.italic}
+              key={i}
+              strikethrough={span.props.strikethrough}
+              underline={span.props.underline}
+            >
+              {span.text}
+            </StyledText>
+          ) : (
+            span.text
+          )
+        }
+
+        $[7] = dimColor
+        $[8] = t3
+      } else {
+        t3 = $[8]
+      }
+
+      t1 = spans.map(t3)
+    }
+
+    $[3] = children
+    $[4] = dimColor
+    $[5] = t1
+    $[6] = t2
+  } else {
+    t1 = $[5]
+    t2 = $[6]
+  }
+
+  if (t2 !== Symbol.for('react.early_return_sentinel')) {
+    return t2
+  }
+
+  const content = t1
+  let t3
+
+  if ($[9] !== content || $[10] !== dimColor) {
+    t3 = dimColor ? <Text dim={true}>{content}</Text> : <Text>{content}</Text>
+    $[9] = content
+    $[10] = dimColor
+    $[11] = t3
+  } else {
+    t3 = $[11]
+  }
+
+  return t3
+})
+
+/**
+ * Parse an ANSI string into spans using the termio parser.
+ */
+function parseToSpans(input: string): Span[] {
+  const parser = new Parser()
+  const actions = parser.feed(input)
+  const spans: Span[] = []
+  let currentHyperlink: string | undefined
+
+  for (const action of actions) {
+    if (action.type === 'link') {
+      if (action.action.type === 'start') {
+        currentHyperlink = action.action.url
+      } else {
+        currentHyperlink = undefined
+      }
+
+      continue
+    }
+
+    if (action.type === 'text') {
+      const text = action.graphemes.map(g => g.value).join('')
+
+      if (!text) {
+        continue
+      }
+
+      const props = textStyleToSpanProps(action.style)
+
+      if (currentHyperlink) {
+        props.hyperlink = currentHyperlink
+      }
+
+      // Try to merge with previous span if props match
+      const lastSpan = spans[spans.length - 1]
+
+      if (lastSpan && propsEqual(lastSpan.props, props)) {
+        lastSpan.text += text
+      } else {
+        spans.push({
+          text,
+          props
+        })
+      }
+    }
+  }
+
+  return spans
+}
+
+/**
+ * Convert termio's TextStyle to SpanProps.
+ */
+function textStyleToSpanProps(style: TextStyle): SpanProps {
+  const props: SpanProps = {}
+
+  if (style.bold) {
+    props.bold = true
+  }
+
+  if (style.dim) {
+    props.dim = true
+  }
+
+  if (style.italic) {
+    props.italic = true
+  }
+
+  if (style.underline !== 'none') {
+    props.underline = true
+  }
+
+  if (style.strikethrough) {
+    props.strikethrough = true
+  }
+
+  if (style.inverse) {
+    props.inverse = true
+  }
+
+  const fgColor = colorToString(style.fg)
+
+  if (fgColor) {
+    props.color = fgColor
+  }
+
+  const bgColor = colorToString(style.bg)
+
+  if (bgColor) {
+    props.backgroundColor = bgColor
+  }
+
+  return props
+}
+
+// Map termio named colors to the ansi: format
+const NAMED_COLOR_MAP: Record<NamedColor, string> = {
+  black: 'ansi:black',
+  red: 'ansi:red',
+  green: 'ansi:green',
+  yellow: 'ansi:yellow',
+  blue: 'ansi:blue',
+  magenta: 'ansi:magenta',
+  cyan: 'ansi:cyan',
+  white: 'ansi:white',
+  brightBlack: 'ansi:blackBright',
+  brightRed: 'ansi:redBright',
+  brightGreen: 'ansi:greenBright',
+  brightYellow: 'ansi:yellowBright',
+  brightBlue: 'ansi:blueBright',
+  brightMagenta: 'ansi:magentaBright',
+  brightCyan: 'ansi:cyanBright',
+  brightWhite: 'ansi:whiteBright'
+}
+
+/**
+ * Convert termio's Color to the string format used by Ink.
+ */
+function colorToString(color: TermioColor): Color | undefined {
+  switch (color.type) {
+    case 'named':
+      return NAMED_COLOR_MAP[color.name] as Color
+
+    case 'indexed':
+      return `ansi256(${color.index})` as Color
+
+    case 'rgb':
+      return `rgb(${color.r},${color.g},${color.b})` as Color
+
+    case 'default':
+      return undefined
+  }
+}
+
+/**
+ * Check if two SpanProps are equal for merging.
+ */
+function propsEqual(a: SpanProps, b: SpanProps): boolean {
+  return (
+    a.color === b.color &&
+    a.backgroundColor === b.backgroundColor &&
+    a.bold === b.bold &&
+    a.dim === b.dim &&
+    a.italic === b.italic &&
+    a.underline === b.underline &&
+    a.strikethrough === b.strikethrough &&
+    a.inverse === b.inverse &&
+    a.hyperlink === b.hyperlink
+  )
+}
+
+function hasAnyProps(props: SpanProps): boolean {
+  return (
+    props.color !== undefined ||
+    props.backgroundColor !== undefined ||
+    props.dim === true ||
+    props.bold === true ||
+    props.italic === true ||
+    props.underline === true ||
+    props.strikethrough === true ||
+    props.inverse === true ||
+    props.hyperlink !== undefined
+  )
+}
+
+function hasAnyTextProps(props: SpanProps): boolean {
+  return (
+    props.color !== undefined ||
+    props.backgroundColor !== undefined ||
+    props.dim === true ||
+    props.bold === true ||
+    props.italic === true ||
+    props.underline === true ||
+    props.strikethrough === true ||
+    props.inverse === true
+  )
+}
+
+// Text style props without weight (bold/dim) - these are handled separately
+type BaseTextStyleProps = {
+  color?: Color
+  backgroundColor?: Color
+  italic?: boolean
+  underline?: boolean
+  strikethrough?: boolean
+  inverse?: boolean
+}
+
+// Wrapper component that handles bold/dim mutual exclusivity for Text
+function StyledText(t0: BaseTextStyleProps & { bold?: boolean; dim?: boolean; children?: ReactNode }) {
+  const $ = _c(14)
+  let bold
+  let children
+  let dim
+  let rest
+
+  if ($[0] !== t0) {
+    ;({ bold, dim, children, ...rest } = t0)
+    $[0] = t0
+    $[1] = bold
+    $[2] = children
+    $[3] = dim
+    $[4] = rest
+  } else {
+    bold = $[1]
+    children = $[2]
+    dim = $[3]
+    rest = $[4]
+  }
+
+  if (dim) {
+    let t1
+
+    if ($[5] !== children || $[6] !== rest) {
+      t1 = (
+        <Text {...rest} dim={true}>
+          {children}
+        </Text>
+      )
+      $[5] = children
+      $[6] = rest
+      $[7] = t1
+    } else {
+      t1 = $[7]
+    }
+
+    return t1
+  }
+
+  if (bold) {
+    let t1
+
+    if ($[8] !== children || $[9] !== rest) {
+      t1 = (
+        <Text {...rest} bold={true}>
+          {children}
+        </Text>
+      )
+      $[8] = children
+      $[9] = rest
+      $[10] = t1
+    } else {
+      t1 = $[10]
+    }
+
+    return t1
+  }
+
+  let t1
+
+  if ($[11] !== children || $[12] !== rest) {
+    t1 = <Text {...rest}>{children}</Text>
+    $[11] = children
+    $[12] = rest
+    $[13] = t1
+  } else {
+    t1 = $[13]
+  }
+
+  return t1
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Link","Text","Color","NamedColor","Parser","TermioColor","TextStyle","Props","children","dimColor","SpanProps","color","backgroundColor","dim","bold","italic","underline","strikethrough","inverse","hyperlink","Ansi","memo","t0","$","_c","t1","String","t2","Symbol","for","bb0","spans","parseToSpans","length","hasAnyProps","props","text","t3","span","i","hasTextProps","hasAnyTextProps","map","content","Span","input","parser","actions","feed","currentHyperlink","action","type","url","undefined","graphemes","g","value","join","textStyleToSpanProps","style","lastSpan","propsEqual","push","fgColor","colorToString","fg","bgColor","bg","NAMED_COLOR_MAP","Record","black","red","green","yellow","blue","magenta","cyan","white","brightBlack","brightRed","brightGreen","brightYellow","brightBlue","brightMagenta","brightCyan","brightWhite","name","index","r","b","a","BaseTextStyleProps","StyledText","rest"],"sources":["Ansi.tsx"],"sourcesContent":["import React from 'react'\nimport Link from './components/Link.js'\nimport Text from './components/Text.js'\nimport type { Color } from './styles.js'\nimport {\n  type NamedColor,\n  Parser,\n  type Color as TermioColor,\n  type TextStyle,\n} from './termio.js'\n\ntype Props = {\n  children: string\n  /** When true, force all text to be rendered with dim styling */\n  dimColor?: boolean\n}\n\ntype SpanProps = {\n  color?: Color\n  backgroundColor?: Color\n  dim?: boolean\n  bold?: boolean\n  italic?: boolean\n  underline?: boolean\n  strikethrough?: boolean\n  inverse?: boolean\n  hyperlink?: string\n}\n\n/**\n * Component that parses ANSI escape codes and renders them using Text components.\n *\n * Use this as an escape hatch when you have pre-formatted ANSI strings from\n * external tools (like cli-highlight) that need to be rendered in Ink.\n *\n * Memoized to prevent re-renders when parent changes but children string is the same.\n */\nexport const Ansi = React.memo(function Ansi({\n  children,\n  dimColor,\n}: Props): React.ReactNode {\n  if (typeof children !== 'string') {\n    return dimColor ? (\n      <Text dim>{String(children)}</Text>\n    ) : (\n      <Text>{String(children)}</Text>\n    )\n  }\n\n  if (children === '') {\n    return null\n  }\n\n  const spans = parseToSpans(children)\n\n  if (spans.length === 0) {\n    return null\n  }\n\n  if (spans.length === 1 && !hasAnyProps(spans[0]!.props)) {\n    return dimColor ? (\n      <Text dim>{spans[0]!.text}</Text>\n    ) : (\n      <Text>{spans[0]!.text}</Text>\n    )\n  }\n\n  const content = spans.map((span, i) => {\n    const hyperlink = span.props.hyperlink\n    // When dimColor is forced, override the span's dim prop\n    if (dimColor) {\n      span.props.dim = true\n    }\n    const hasTextProps = hasAnyTextProps(span.props)\n\n    if (hyperlink) {\n      return hasTextProps ? (\n        <Link key={i} url={hyperlink}>\n          <StyledText\n            color={span.props.color}\n            backgroundColor={span.props.backgroundColor}\n            dim={span.props.dim}\n            bold={span.props.bold}\n            italic={span.props.italic}\n            underline={span.props.underline}\n            strikethrough={span.props.strikethrough}\n            inverse={span.props.inverse}\n          >\n            {span.text}\n          </StyledText>\n        </Link>\n      ) : (\n        <Link key={i} url={hyperlink}>\n          {span.text}\n        </Link>\n      )\n    }\n\n    return hasTextProps ? (\n      <StyledText\n        key={i}\n        color={span.props.color}\n        backgroundColor={span.props.backgroundColor}\n        dim={span.props.dim}\n        bold={span.props.bold}\n        italic={span.props.italic}\n        underline={span.props.underline}\n        strikethrough={span.props.strikethrough}\n        inverse={span.props.inverse}\n      >\n        {span.text}\n      </StyledText>\n    ) : (\n      span.text\n    )\n  })\n\n  return dimColor ? <Text dim>{content}</Text> : <Text>{content}</Text>\n})\n\ntype Span = {\n  text: string\n  props: SpanProps\n}\n\n/**\n * Parse an ANSI string into spans using the termio parser.\n */\nfunction parseToSpans(input: string): Span[] {\n  const parser = new Parser()\n  const actions = parser.feed(input)\n  const spans: Span[] = []\n\n  let currentHyperlink: string | undefined\n\n  for (const action of actions) {\n    if (action.type === 'link') {\n      if (action.action.type === 'start') {\n        currentHyperlink = action.action.url\n      } else {\n        currentHyperlink = undefined\n      }\n      continue\n    }\n\n    if (action.type === 'text') {\n      const text = action.graphemes.map(g => g.value).join('')\n      if (!text) continue\n\n      const props = textStyleToSpanProps(action.style)\n      if (currentHyperlink) {\n        props.hyperlink = currentHyperlink\n      }\n\n      // Try to merge with previous span if props match\n      const lastSpan = spans[spans.length - 1]\n      if (lastSpan && propsEqual(lastSpan.props, props)) {\n        lastSpan.text += text\n      } else {\n        spans.push({ text, props })\n      }\n    }\n  }\n\n  return spans\n}\n\n/**\n * Convert termio's TextStyle to SpanProps.\n */\nfunction textStyleToSpanProps(style: TextStyle): SpanProps {\n  const props: SpanProps = {}\n\n  if (style.bold) props.bold = true\n  if (style.dim) props.dim = true\n  if (style.italic) props.italic = true\n  if (style.underline !== 'none') props.underline = true\n  if (style.strikethrough) props.strikethrough = true\n  if (style.inverse) props.inverse = true\n\n  const fgColor = colorToString(style.fg)\n  if (fgColor) props.color = fgColor\n\n  const bgColor = colorToString(style.bg)\n  if (bgColor) props.backgroundColor = bgColor\n\n  return props\n}\n\n// Map termio named colors to the ansi: format\nconst NAMED_COLOR_MAP: Record<NamedColor, string> = {\n  black: 'ansi:black',\n  red: 'ansi:red',\n  green: 'ansi:green',\n  yellow: 'ansi:yellow',\n  blue: 'ansi:blue',\n  magenta: 'ansi:magenta',\n  cyan: 'ansi:cyan',\n  white: 'ansi:white',\n  brightBlack: 'ansi:blackBright',\n  brightRed: 'ansi:redBright',\n  brightGreen: 'ansi:greenBright',\n  brightYellow: 'ansi:yellowBright',\n  brightBlue: 'ansi:blueBright',\n  brightMagenta: 'ansi:magentaBright',\n  brightCyan: 'ansi:cyanBright',\n  brightWhite: 'ansi:whiteBright',\n}\n\n/**\n * Convert termio's Color to the string format used by Ink.\n */\nfunction colorToString(color: TermioColor): Color | undefined {\n  switch (color.type) {\n    case 'named':\n      return NAMED_COLOR_MAP[color.name] as Color\n    case 'indexed':\n      return `ansi256(${color.index})` as Color\n    case 'rgb':\n      return `rgb(${color.r},${color.g},${color.b})` as Color\n    case 'default':\n      return undefined\n  }\n}\n\n/**\n * Check if two SpanProps are equal for merging.\n */\nfunction propsEqual(a: SpanProps, b: SpanProps): boolean {\n  return (\n    a.color === b.color &&\n    a.backgroundColor === b.backgroundColor &&\n    a.bold === b.bold &&\n    a.dim === b.dim &&\n    a.italic === b.italic &&\n    a.underline === b.underline &&\n    a.strikethrough === b.strikethrough &&\n    a.inverse === b.inverse &&\n    a.hyperlink === b.hyperlink\n  )\n}\n\nfunction hasAnyProps(props: SpanProps): boolean {\n  return (\n    props.color !== undefined ||\n    props.backgroundColor !== undefined ||\n    props.dim === true ||\n    props.bold === true ||\n    props.italic === true ||\n    props.underline === true ||\n    props.strikethrough === true ||\n    props.inverse === true ||\n    props.hyperlink !== undefined\n  )\n}\n\nfunction hasAnyTextProps(props: SpanProps): boolean {\n  return (\n    props.color !== undefined ||\n    props.backgroundColor !== undefined ||\n    props.dim === true ||\n    props.bold === true ||\n    props.italic === true ||\n    props.underline === true ||\n    props.strikethrough === true ||\n    props.inverse === true\n  )\n}\n\n// Text style props without weight (bold/dim) - these are handled separately\ntype BaseTextStyleProps = {\n  color?: Color\n  backgroundColor?: Color\n  italic?: boolean\n  underline?: boolean\n  strikethrough?: boolean\n  inverse?: boolean\n}\n\n// Wrapper component that handles bold/dim mutual exclusivity for Text\nfunction StyledText({\n  bold,\n  dim,\n  children,\n  ...rest\n}: BaseTextStyleProps & {\n  bold?: boolean\n  dim?: boolean\n  children: string\n}): React.ReactNode {\n  // dim takes precedence over bold when both are set (terminals treat them as mutually exclusive)\n  if (dim) {\n    return (\n      <Text {...rest} dim>\n        {children}\n      </Text>\n    )\n  }\n  if (bold) {\n    return (\n      <Text {...rest} bold>\n        {children}\n      </Text>\n    )\n  }\n  return <Text {...rest}>{children}</Text>\n}\n"],"mappings":"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","ignoreList":[]}

package/packages/nastech-ink/src/ink/app-mouse.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { handleMouseEvent } from './components/App.js'
+import { createSelectionState, hasSelection, startSelection, updateSelection } from './selection.js'
+
+const makeApp = () => {
+  const selection = createSelectionState()
+
+  return {
+    clickCount: 1,
+    lastHoverCol: -1,
+    lastHoverRow: -1,
+    mouseCaptureTarget: undefined,
+    props: {
+      getSelectedText: vi.fn(() => 'selected text'),
+      onCopySelectionNoClear: vi.fn(async () => 'selected text'),
+      onHoverAt: vi.fn(),
+      onMouseDownAt: vi.fn(),
+      onMouseDragAt: vi.fn(),
+      onMouseUpAt: vi.fn(),
+      onSelectionChange: vi.fn(),
+      selection
+    }
+  } as any
+}
+
+describe('handleMouseEvent right-click selection behavior', () => {
+  it('copies an active selection instead of dispatching right-click paste handlers', async () => {
+    const app = makeApp()
+
+    startSelection(app.props.selection, 0, 0)
+    updateSelection(app.props.selection, 4, 0)
+
+    handleMouseEvent(app, { action: 'press', button: 2, col: 3, kind: 'mouse', row: 1 })
+    await Promise.resolve()
+
+    expect(app.props.onCopySelectionNoClear).toHaveBeenCalledOnce()
+    expect(app.props.onMouseDownAt).not.toHaveBeenCalled()
+    expect(app.clickCount).toBe(0)
+  })
+
+  it('clears the highlight after a successful right-click copy', async () => {
+    const app = makeApp()
+
+    startSelection(app.props.selection, 0, 0)
+    updateSelection(app.props.selection, 4, 0)
+    expect(hasSelection(app.props.selection)).toBe(true)
+
+    handleMouseEvent(app, { action: 'press', button: 2, col: 3, kind: 'mouse', row: 1, sequence: '' })
+    await Promise.resolve()
+    await Promise.resolve()
+
+    // Deliberate copy clears the selection (visual confirmation + a follow-up
+    // right-click on empty space pastes rather than re-copying a stale range).
+    expect(hasSelection(app.props.selection)).toBe(false)
+    expect(app.props.onSelectionChange).toHaveBeenCalled()
+  })
+
+  it('keeps the highlight when right-click copy fails (no clipboard path)', async () => {
+    const app = makeApp()
+    app.props.onCopySelectionNoClear.mockResolvedValue('')
+
+    startSelection(app.props.selection, 0, 0)
+    updateSelection(app.props.selection, 4, 0)
+
+    handleMouseEvent(app, { action: 'press', button: 2, col: 3, kind: 'mouse', row: 1, sequence: '' })
+    await Promise.resolve()
+    await Promise.resolve()
+
+    // Copy didn't land, so the highlight must survive (and we fall back to the
+    // right-click paste handler instead).
+    expect(hasSelection(app.props.selection)).toBe(true)
+  })
+
+  it('falls back to right-click handlers when selection copy has no clipboard path', async () => {
+    const app = makeApp()
+    app.props.onCopySelectionNoClear.mockResolvedValue('')
+
+    startSelection(app.props.selection, 0, 0)
+    updateSelection(app.props.selection, 4, 0)
+
+    handleMouseEvent(app, { action: 'press', button: 2, col: 3, kind: 'mouse', row: 1 })
+    await Promise.resolve()
+
+    expect(app.props.onCopySelectionNoClear).toHaveBeenCalledOnce()
+    expect(app.props.onMouseDownAt).toHaveBeenCalledWith(2, 0, 2)
+  })
+
+  it('does not paste when highlighted selection text is empty', async () => {
+    const app = makeApp()
+    app.props.getSelectedText.mockReturnValue('')
+
+    startSelection(app.props.selection, 0, 0)
+    updateSelection(app.props.selection, 4, 0)
+
+    handleMouseEvent(app, { action: 'press', button: 2, col: 3, kind: 'mouse', row: 1 })
+    await Promise.resolve()
+
+    expect(app.props.onCopySelectionNoClear).not.toHaveBeenCalled()
+    expect(app.props.onMouseDownAt).not.toHaveBeenCalled()
+  })
+
+  it('does not repeatedly copy or paste during right-button motion events over a selection', () => {
+    const app = makeApp()
+
+    startSelection(app.props.selection, 0, 0)
+    updateSelection(app.props.selection, 4, 0)
+
+    handleMouseEvent(app, { action: 'press', button: 0x20 | 2, col: 3, kind: 'mouse', row: 1 })
+
+    expect(app.props.onCopySelectionNoClear).not.toHaveBeenCalled()
+    expect(app.props.onMouseDownAt).not.toHaveBeenCalled()
+  })
+
+  it('still dispatches right-click handlers when no text is selected', () => {
+    const app = makeApp()
+
+    handleMouseEvent(app, { action: 'press', button: 2, col: 3, kind: 'mouse', row: 1 })
+
+    expect(app.props.onCopySelectionNoClear).not.toHaveBeenCalled()
+    expect(app.props.onMouseDownAt).toHaveBeenCalledWith(2, 0, 2)
+  })
+})