ghostty_enabled.go

//go:build ghostty && !windows

package main

import (
	"bytes"
	"context"
	"fmt"
	"image"
	"image/color"
	"image/draw"
	"image/png"
	"io"
	"log"
	"math"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"time"
	"unicode/utf8"

	"github.com/creack/pty"
	"github.com/go-rod/rod/lib/input"
	textrender "github.com/go-text/render"
	"github.com/go-text/typesetting/font"
	"github.com/go-text/typesetting/fontscan"
	"github.com/go-text/typesetting/shaping"
	libghostty "go.mitchellh.com/libghostty"
	"golang.org/x/image/math/fixed"
)

const ghosttyScrollbackLines = 10_000

type ghosttyBackend struct {
	mu      sync.Mutex
	writeMu sync.Mutex

	command *exec.Cmd
	pty     *os.File
	term    *libghostty.Terminal
	state   *libghostty.RenderState
	encoder *libghostty.KeyEncoder
	event   *libghostty.KeyEvent

	fontMaps map[fontStyle]*fontscan.FontMap
	renderer textrender.Renderer
	options  *Options

	cellWidth  int
	cellHeight int
	baseline   int
	width      int
	height     int
	cachedText []byte
	blinkStart time.Time
	background color.RGBA
	cursor     color.RGBA
}

type fontStyle struct {
	bold   bool
	italic bool
}

type renderedCell struct {
	text          string
	foreground    color.RGBA
	background    color.RGBA
	bold          bool
	italic        bool
	faint         bool
	invisible     bool
	strikethrough bool
	overline      bool
	underline     int
}

type boxConnections struct {
	left, right, up, down bool
	heavy                 bool
}

var boxDrawingConnections = map[rune]boxConnections{
	'─': {left: true, right: true},
	'━': {left: true, right: true, heavy: true},
	'│': {up: true, down: true},
	'┃': {up: true, down: true, heavy: true},
	'┌': {right: true, down: true},
	'┐': {left: true, down: true},
	'└': {right: true, up: true},
	'┘': {left: true, up: true},
	'┏': {right: true, down: true, heavy: true},
	'┓': {left: true, down: true, heavy: true},
	'┗': {right: true, up: true, heavy: true},
	'┛': {left: true, up: true, heavy: true},
	'├': {right: true, up: true, down: true},
	'┤': {left: true, up: true, down: true},
	'┬': {left: true, right: true, down: true},
	'┴': {left: true, right: true, up: true},
	'┼': {left: true, right: true, up: true, down: true},
	'┣': {right: true, up: true, down: true, heavy: true},
	'┫': {left: true, up: true, down: true, heavy: true},
	'┳': {left: true, right: true, down: true, heavy: true},
	'┻': {left: true, right: true, up: true, heavy: true},
	'╋': {left: true, right: true, up: true, down: true, heavy: true},
}

func newGhosttyTerminal(shell Shell) (ghosttyTerminal, error) {
	b := &ghosttyBackend{}

	term, err := libghostty.NewTerminal(
		libghostty.WithSize(defaultColumns, 24),
		libghostty.WithMaxScrollback(ghosttyScrollbackLines),
		libghostty.WithWritePty(func(_ *libghostty.Terminal, data []byte) {
			_ = b.writePTY(data)
		}),
	)
	if err != nil {
		return nil, fmt.Errorf("create Ghostty terminal: %w", err)
	}
	b.term = term

	b.state, err = libghostty.NewRenderState()
	if err != nil {
		term.Close()
		return nil, fmt.Errorf("create Ghostty render state: %w", err)
	}
	b.encoder, err = libghostty.NewKeyEncoder()
	if err != nil {
		b.state.Close()
		term.Close()
		return nil, fmt.Errorf("create Ghostty key encoder: %w", err)
	}
	b.event, err = libghostty.NewKeyEvent()
	if err != nil {
		b.encoder.Close()
		b.state.Close()
		term.Close()
		return nil, fmt.Errorf("create Ghostty key event: %w", err)
	}

	b.command = exec.CommandContext(context.Background(), shell.Command[0], shell.Command[1:]...) //nolint:gosec
	b.command.Env = append(os.Environ(), shell.Env...)
	b.command.Env = append(b.command.Env, "TERM=xterm-256color", "COLORTERM=truecolor")
	b.pty, err = pty.StartWithSize(b.command, &pty.Winsize{Rows: 24, Cols: defaultColumns})
	if err != nil {
		_ = b.Close()
		return nil, fmt.Errorf("start Ghostty PTY: %w", err)
	}

	go b.readPTY()
	return b, nil
}

func (b *ghosttyBackend) Setup(options *Options) error {
	b.mu.Lock()
	defer b.mu.Unlock()

	b.options = options
	b.blinkStart = time.Now()
	if err := b.configureTheme(options.Theme); err != nil {
		return err
	}
	if err := b.configureFonts(options); err != nil {
		return err
	}

	style := options.Video.Style
	bar := 0
	if style.WindowBar != "" {
		bar = style.WindowBarSize
	}
	margin := 0
	if style.MarginFill != "" {
		margin = style.Margin
	}
	b.width = style.Width - double(style.Padding) - double(margin)
	b.height = style.Height - double(style.Padding) - double(margin) - bar

	cols := max(1, b.width/b.cellWidth)
	rows := max(1, b.height/b.cellHeight)
	if cols > math.MaxUint16 || rows > math.MaxUint16 {
		return fmt.Errorf("ghostty terminal dimensions exceed %d cells", math.MaxUint16)
	}
	cellWidth, err := checkedUint32(b.cellWidth)
	if err != nil {
		return fmt.Errorf("convert Ghostty cell width: %w", err)
	}
	cellHeight, err := checkedUint32(b.cellHeight)
	if err != nil {
		return fmt.Errorf("convert Ghostty cell height: %w", err)
	}
	if err := b.term.Resize(uint16(cols), uint16(rows), cellWidth, cellHeight); err != nil {
		return fmt.Errorf("resize Ghostty terminal: %w", err)
	}
	if err := pty.Setsize(b.pty, &pty.Winsize{
		Rows: uint16(rows),
		Cols: uint16(cols),
		X:    boundedUint16(b.width),
		Y:    boundedUint16(b.height),
	}); err != nil {
		return fmt.Errorf("resize Ghostty PTY: %w", err)
	}
	return nil
}

func (b *ghosttyBackend) configureFonts(options *Options) error {
	families := strings.Split(options.FontFamily, fontsSeparator)
	for i := range families {
		families[i] = strings.TrimSpace(families[i])
	}

	b.fontMaps = make(map[fontStyle]*fontscan.FontMap, 4)
	for _, style := range []fontStyle{{}, {bold: true}, {italic: true}, {bold: true, italic: true}} {
		fm := fontscan.NewFontMap(log.New(io.Discard, "", 0))
		cacheDir := filepath.Join(os.TempDir(), "vhs-font-cache")
		if err := fm.UseSystemFonts(cacheDir); err != nil {
			return fmt.Errorf("scan system fonts: %w", err)
		}
		aspect := font.Aspect{}
		if style.bold {
			aspect.Weight = font.WeightBold
		}
		if style.italic {
			aspect.Style = font.StyleItalic
		}
		fm.SetQuery(fontscan.Query{Families: families, Aspect: aspect})
		b.fontMaps[style] = fm
	}

	face := b.fontMaps[fontStyle{}].ResolveFace('M')
	gid, ok := face.NominalGlyph('M')
	if !ok {
		return fmt.Errorf("font %q has no printable monospace glyphs", options.FontFamily)
	}
	scale := float64(options.FontSize) / float64(face.Upem())
	b.cellWidth = max(1, int(math.Round(float64(face.HorizontalAdvance(gid))*scale+options.LetterSpacing)))

	extents, ok := face.FontHExtents()
	if !ok {
		return fmt.Errorf("font %q has no horizontal metrics", options.FontFamily)
	}
	ascent := float64(extents.Ascender) * scale
	descent := -float64(extents.Descender) * scale
	fontHeight := ascent + descent
	b.cellHeight = max(1, int(math.Ceil(fontHeight*options.LineHeight)))
	b.baseline = int(math.Round((float64(b.cellHeight)-fontHeight)/2 + ascent))
	b.renderer.FontSize = float32(options.FontSize)
	b.renderer.PixScale = 1
	return nil
}

func (b *ghosttyBackend) configureTheme(theme Theme) error {
	background, err := b.term.ColorBackgroundDefault()
	if err != nil {
		return fmt.Errorf("read default Ghostty background: %w", err)
	}
	if background == nil {
		value, err := ghosttyRGB(DefaultTheme.Background)
		if err != nil {
			return err
		}
		background = &value
	}
	if theme.Background != "" {
		value, err := ghosttyRGB(theme.Background)
		if err != nil {
			return err
		}
		background = &value
	}
	foreground, err := b.term.ColorForegroundDefault()
	if err != nil {
		return fmt.Errorf("read default Ghostty foreground: %w", err)
	}
	if foreground == nil {
		value, err := ghosttyRGB(DefaultTheme.Foreground)
		if err != nil {
			return err
		}
		foreground = &value
	}
	if theme.Foreground != "" {
		value, err := ghosttyRGB(theme.Foreground)
		if err != nil {
			return err
		}
		foreground = &value
	}
	cursor, err := b.term.ColorCursorDefault()
	if err != nil {
		return fmt.Errorf("read default Ghostty cursor: %w", err)
	}
	if cursor == nil {
		cursor = foreground
	}
	if theme.Cursor != "" {
		value, err := ghosttyRGB(theme.Cursor)
		if err != nil {
			return err
		}
		cursor = &value
	}
	if err := b.term.SetColorBackground(background); err != nil {
		return fmt.Errorf("set Ghostty background: %w", err)
	}
	if err := b.term.SetColorForeground(foreground); err != nil {
		return fmt.Errorf("set Ghostty foreground: %w", err)
	}
	if err := b.term.SetColorCursor(cursor); err != nil {
		return fmt.Errorf("set Ghostty cursor: %w", err)
	}
	b.background = rgba(*background)
	b.cursor = rgba(*cursor)

	values := themePaletteValues(theme)
	palette, err := b.term.ColorPaletteDefault()
	if err != nil {
		return fmt.Errorf("read default Ghostty palette: %w", err)
	}
	if palette == nil {
		palette = &libghostty.Palette{}
		for i, value := range themePaletteValues(DefaultTheme) {
			palette[i], err = ghosttyRGB(value)
			if err != nil {
				return err
			}
		}
	}
	for i, value := range values {
		if value == "" {
			continue
		}
		palette[i], err = ghosttyRGB(value)
		if err != nil {
			return err
		}
	}
	if err := b.term.SetColorPalette(palette); err != nil {
		return fmt.Errorf("set Ghostty palette: %w", err)
	}
	return nil
}

func themePaletteValues(theme Theme) []string {
	return []string{
		theme.Black, theme.Red, theme.Green, theme.Yellow,
		theme.Blue, theme.Magenta, theme.Cyan, theme.White,
		theme.BrightBlack, theme.BrightRed, theme.BrightGreen, theme.BrightYellow,
		theme.BrightBlue, theme.BrightMagenta, theme.BrightCyan, theme.BrightWhite,
	}
}

func ghosttyRGB(value string) (libghostty.ColorRGB, error) {
	c, err := parseHexColor(value)
	if err != nil {
		return libghostty.ColorRGB{}, fmt.Errorf("parse terminal color %q: %w", value, err)
	}
	return libghostty.ColorRGB{R: c.R, G: c.G, B: c.B}, nil
}

func (b *ghosttyBackend) readPTY() {
	buf := make([]byte, 32*1024)
	for {
		n, err := b.pty.Read(buf)
		if n > 0 {
			b.mu.Lock()
			b.term.VTWrite(buf[:n])
			b.mu.Unlock()
		}
		if err != nil {
			return
		}
	}
}

func (b *ghosttyBackend) writePTY(data []byte) error {
	b.writeMu.Lock()
	defer b.writeMu.Unlock()
	if _, err := b.pty.Write(data); err != nil {
		return fmt.Errorf("write Ghostty PTY: %w", err)
	}
	return nil
}

func (b *ghosttyBackend) TypeText(text string) error {
	return b.writePTY([]byte(text))
}

func (b *ghosttyBackend) TypeKey(key input.Key, modifiers ghosttyModifiers) error {
	b.mu.Lock()
	b.encoder.SetOptFromTerminal(b.term)
	b.encoder.SetOptOptionAsAlt(libghostty.OptionAsAltTrue)

	info := key.Info()
	ghosttyKey, ok := ghosttyKeyFromCode(info.Code)
	if !ok {
		b.mu.Unlock()
		return fmt.Errorf("unsupported key %q", info.Code)
	}
	mods := libghostty.Mods(0)
	if modifiers&ghosttyModShift != 0 {
		mods |= libghostty.ModShift
	}
	if modifiers&ghosttyModCtrl != 0 {
		mods |= libghostty.ModCtrl
	}
	if modifiers&ghosttyModAlt != 0 {
		mods |= libghostty.ModAlt
	}
	b.event.SetAction(libghostty.KeyActionPress)
	b.event.SetKey(ghosttyKey)
	b.event.SetMods(mods)
	if len(info.Key) == 1 {
		b.event.SetUTF8(info.Key)
		b.event.SetUnshiftedCodepoint([]rune(strings.ToLower(info.Key))[0])
	} else {
		b.event.SetUTF8("")
		b.event.SetUnshiftedCodepoint(0)
	}
	encoded, err := b.encoder.Encode(b.event)
	b.mu.Unlock()
	if err != nil {
		return fmt.Errorf("encode Ghostty key: %w", err)
	}
	return b.writePTY(encoded)
}

func ghosttyKeyFromCode(code string) (libghostty.Key, bool) {
	keys := map[string]libghostty.Key{
		"Backquote":      libghostty.KeyBackquote,
		"Backslash":      libghostty.KeyBackslash,
		"BracketLeft":    libghostty.KeyBracketLeft,
		"BracketRight":   libghostty.KeyBracketRight,
		"Comma":          libghostty.KeyComma,
		"Equal":          libghostty.KeyEqual,
		"Minus":          libghostty.KeyMinus,
		"Period":         libghostty.KeyPeriod,
		"Quote":          libghostty.KeyQuote,
		"Semicolon":      libghostty.KeySemicolon,
		"Slash":          libghostty.KeySlash,
		keyNameBackspace: libghostty.KeyBackspace,
		keyNameEnter:     libghostty.KeyEnter,
		keyNameSpace:     libghostty.KeySpace,
		"Tab":            libghostty.KeyTab,
		"Delete":         libghostty.KeyDelete,
		"End":            libghostty.KeyEnd,
		"Home":           libghostty.KeyHome,
		"Insert":         libghostty.KeyInsert,
		"PageDown":       libghostty.KeyPageDown,
		"PageUp":         libghostty.KeyPageUp,
		"ArrowDown":      libghostty.KeyArrowDown,
		"ArrowLeft":      libghostty.KeyArrowLeft,
		"ArrowRight":     libghostty.KeyArrowRight,
		"ArrowUp":        libghostty.KeyArrowUp,
		"Escape":         libghostty.KeyEscape,
	}
	if len(code) == 4 && strings.HasPrefix(code, "Key") {
		return libghostty.Key(int(libghostty.KeyA) + int(code[3]-'A')), true
	}
	if len(code) == 6 && strings.HasPrefix(code, "Digit") {
		return libghostty.Key(int(libghostty.KeyDigit0) + int(code[5]-'0')), true
	}
	key, ok := keys[code]
	return key, ok
}

func (b *ghosttyBackend) Scroll(delta int) error {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.term.ScrollViewportDelta(delta)
	return nil
}

func (b *ghosttyBackend) Buffer() ([]string, error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.linesLocked()
}

func (b *ghosttyBackend) CurrentLine() (string, error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	lines, err := b.linesLocked()
	if err != nil {
		return "", err
	}
	y, err := b.state.CursorViewportY()
	if err != nil {
		return "", fmt.Errorf("read Ghostty cursor row: %w", err)
	}
	if int(y) >= len(lines) {
		return "", nil
	}
	return lines[y], nil
}

func (b *ghosttyBackend) linesLocked() ([]string, error) {
	if err := b.state.Update(b.term); err != nil {
		return nil, fmt.Errorf("update Ghostty render state: %w", err)
	}
	cells, _, _, err := b.snapshotLocked()
	if err != nil {
		return nil, err
	}
	lines := make([]string, len(cells))
	for y, row := range cells {
		var line strings.Builder
		for _, cell := range row {
			line.WriteString(cell.text)
		}
		lines[y] = strings.TrimRight(line.String(), " ")
	}
	return lines, nil
}

func (b *ghosttyBackend) Capture() ([]byte, []byte, error) {
	b.mu.Lock()
	defer b.mu.Unlock()

	if err := b.state.Update(b.term); err != nil {
		return nil, nil, fmt.Errorf("update Ghostty render state: %w", err)
	}
	dirty, err := b.state.Dirty()
	if err != nil {
		return nil, nil, fmt.Errorf("read Ghostty dirty state: %w", err)
	}
	cursor := image.NewRGBA(image.Rect(0, 0, b.width, b.height))
	if b.cachedText == nil || dirty != libghostty.RenderStateDirtyFalse {
		cells, cols, rows, err := b.snapshotLocked()
		if err != nil {
			return nil, nil, err
		}
		text := image.NewRGBA(image.Rect(0, 0, b.width, b.height))
		draw.Draw(text, text.Bounds(), image.NewUniform(b.background), image.Point{}, draw.Src)

		for y := 0; y < rows; y++ {
			for x := 0; x < cols; x++ {
				cell := cells[y][x]
				rect := image.Rect(x*b.cellWidth, y*b.cellHeight, (x+1)*b.cellWidth, (y+1)*b.cellHeight)
				draw.Draw(text, rect, image.NewUniform(cell.background), image.Point{}, draw.Src)
			}
			b.drawRow(text, cells[y], y)
		}
		b.cachedText, err = encodePNG(text)
		if err != nil {
			return nil, nil, err
		}
		if err := b.state.SetDirty(libghostty.RenderStateDirtyFalse); err != nil {
			return nil, nil, fmt.Errorf("clear Ghostty render state: %w", err)
		}
	}
	if err := b.drawCursor(cursor); err != nil {
		return nil, nil, err
	}

	cursorPNG, err := encodePNG(cursor)
	if err != nil {
		return nil, nil, err
	}
	return b.cachedText, cursorPNG, nil
}

func (b *ghosttyBackend) snapshotLocked() ([][]renderedCell, int, int, error) {
	colsValue, err := b.state.Cols()
	if err != nil {
		return nil, 0, 0, fmt.Errorf("read Ghostty columns: %w", err)
	}
	rowsValue, err := b.state.Rows()
	if err != nil {
		return nil, 0, 0, fmt.Errorf("read Ghostty rows: %w", err)
	}
	colors, err := b.state.Colors()
	if err != nil {
		return nil, 0, 0, fmt.Errorf("read Ghostty colors: %w", err)
	}
	defaultForeground := rgba(colors.Foreground)
	defaultBackground := rgba(colors.Background)

	rowIterator, err := libghostty.NewRenderStateRowIterator()
	if err != nil {
		return nil, 0, 0, fmt.Errorf("create Ghostty row iterator: %w", err)
	}
	defer rowIterator.Close()
	rowCells, err := libghostty.NewRenderStateRowCells()
	if err != nil {
		return nil, 0, 0, fmt.Errorf("create Ghostty row cells: %w", err)
	}
	defer rowCells.Close()
	if err := b.state.RowIterator(rowIterator); err != nil {
		return nil, 0, 0, fmt.Errorf("initialize Ghostty row iterator: %w", err)
	}

	cols, rows := int(colsValue), int(rowsValue)
	result := make([][]renderedCell, 0, rows)
	for rowIterator.Next() {
		if err := rowIterator.Cells(rowCells); err != nil {
			return nil, 0, 0, fmt.Errorf("read Ghostty row cells: %w", err)
		}
		row := make([]renderedCell, 0, cols)
		for rowCells.Next() {
			graphemes, err := rowCells.Graphemes()
			if err != nil {
				return nil, 0, 0, fmt.Errorf("read Ghostty graphemes: %w", err)
			}
			style, err := rowCells.Style()
			if err != nil {
				return nil, 0, 0, fmt.Errorf("read Ghostty cell style: %w", err)
			}
			foreground := defaultForeground
			resolvedForeground, err := rowCells.FgColor()
			if err != nil {
				return nil, 0, 0, fmt.Errorf("read resolved Ghostty foreground: %w", err)
			}
			if resolvedForeground != nil {
				foreground = rgba(*resolvedForeground)
			}
			background := defaultBackground
			resolvedBackground, err := rowCells.BgColor()
			if err != nil {
				return nil, 0, 0, fmt.Errorf("read resolved Ghostty background: %w", err)
			}
			if resolvedBackground != nil {
				background = rgba(*resolvedBackground)
			}
			if style.Inverse() {
				foreground, background = background, foreground
			}
			runes := make([]rune, len(graphemes))
			for i, grapheme := range graphemes {
				runes[i] = validRune(grapheme)
			}
			text := string(runes)
			if text == "" {
				raw, err := rowCells.Raw()
				if err != nil {
					return nil, 0, 0, fmt.Errorf("read raw Ghostty cell: %w", err)
				}
				wide, err := raw.Wide()
				if err != nil {
					return nil, 0, 0, fmt.Errorf("read Ghostty cell width: %w", err)
				}
				if wide != libghostty.CellWideSpacerTail && wide != libghostty.CellWideSpacerHead {
					text = " "
				}
			}
			row = append(row, renderedCell{
				text:          text,
				foreground:    foreground,
				background:    background,
				bold:          style.Bold(),
				italic:        style.Italic(),
				faint:         style.Faint(),
				invisible:     style.Invisible(),
				strikethrough: style.Strikethrough(),
				overline:      style.Overline(),
				underline:     style.Underline(),
			})
		}
		for len(row) < cols {
			row = append(row, renderedCell{foreground: defaultForeground, background: defaultBackground})
		}
		result = append(result, row)
	}
	for len(result) < rows {
		row := make([]renderedCell, cols)
		for i := range row {
			row[i] = renderedCell{foreground: defaultForeground, background: defaultBackground}
		}
		result = append(result, row)
	}
	return result, cols, rows, nil
}

func rgba(c libghostty.ColorRGB) color.RGBA {
	return color.RGBA{R: c.R, G: c.G, B: c.B, A: 0xff}
}

func (b *ghosttyBackend) drawRow(target draw.Image, cells []renderedCell, row int) {
	for start := 0; start < len(cells); {
		style := cells[start]
		if b.drawCellGeometry(target, start, row, style) {
			b.drawDecorations(target, start, start+1, row, style)
			start++
			continue
		}
		end := start + 1
		for end < len(cells) &&
			sameTextStyle(style, cells[end]) &&
			!isCellGeometry(cells[end].text) {
			end++
		}
		if !style.invisible {
			var text strings.Builder
			for _, cell := range cells[start:end] {
				text.WriteString(cell.text)
			}
			b.drawTextRun(target, text.String(), start*b.cellWidth, row*b.cellHeight, style)
		}
		b.drawDecorations(target, start, end, row, style)
		start = end
	}
}

func (b *ghosttyBackend) drawCellGeometry(target draw.Image, col, row int, cell renderedCell) bool {
	rects, ok := cellGeometryRects(
		cell.text,
		image.Rect(col*b.cellWidth, row*b.cellHeight, (col+1)*b.cellWidth, (row+1)*b.cellHeight),
		max(1, b.options.FontSize/14),
	)
	if !ok {
		return false
	}
	if cell.invisible {
		return true
	}
	foreground := cell.foreground
	if cell.faint {
		foreground.A = 0x80
	}
	for _, rect := range rects {
		draw.Draw(target, rect, image.NewUniform(foreground), image.Point{}, draw.Over)
	}
	return true
}

func isCellGeometry(text string) bool {
	_, ok := cellGeometryRects(text, image.Rect(0, 0, 8, 8), 1)
	return ok
}

func cellGeometryRects(text string, bounds image.Rectangle, thickness int) ([]image.Rectangle, bool) {
	runes := []rune(text)
	if len(runes) != 1 {
		return nil, false
	}
	x0, y0, x1, y1 := bounds.Min.X, bounds.Min.Y, bounds.Max.X, bounds.Max.Y
	width, height := bounds.Dx(), bounds.Dy()
	fractionX := func(n int) int { return x0 + (width*n+7)/8 }
	fractionY := func(n int) int { return y0 + (height*n+7)/8 }

	switch char := runes[0]; {
	case char == '▀':
		return []image.Rectangle{image.Rect(x0, y0, x1, fractionY(4))}, true
	case char >= '▁' && char <= '█':
		eighths := int(char-'▁') + 1
		return []image.Rectangle{image.Rect(x0, y1-(height*eighths+7)/8, x1, y1)}, true
	case char >= '▉' && char <= '▏':
		eighths := 7 - int(char-'▉')
		return []image.Rectangle{image.Rect(x0, y0, fractionX(eighths), y1)}, true
	case char == '▐':
		return []image.Rectangle{image.Rect(fractionX(4), y0, x1, y1)}, true
	case char == '▔':
		return []image.Rectangle{image.Rect(x0, y0, x1, fractionY(1))}, true
	case char == '▕':
		return []image.Rectangle{image.Rect(fractionX(7), y0, x1, y1)}, true
	case char >= '▖' && char <= '▟':
		return quadrantRects(char, bounds), true
	default:
		return boxDrawingRects(char, bounds, thickness)
	}
}

func boxDrawingRects(char rune, bounds image.Rectangle, thickness int) ([]image.Rectangle, bool) {
	if char >= '╭' && char <= '╰' {
		return roundedCornerRects(char, bounds, thickness), true
	}
	conn, ok := boxDrawingConnections[char]
	if !ok {
		if char == '┈' {
			return dashedHorizontalRects(bounds, thickness), true
		}
		return nil, false
	}
	if conn.heavy {
		thickness *= 2
	}

	x0, y0, x1, y1 := bounds.Min.X, bounds.Min.Y, bounds.Max.X, bounds.Max.Y
	centerX, centerY := x0+bounds.Dx()/2, y0+bounds.Dy()/2
	leftX, rightX := centerX-thickness/2, centerX+(thickness+1)/2
	topY, bottomY := centerY-thickness/2, centerY+(thickness+1)/2
	rects := make([]image.Rectangle, 0, 4)
	if conn.left && conn.right {
		rects = append(rects, image.Rect(x0, topY, x1, bottomY))
	} else if conn.left {
		rects = append(rects, image.Rect(x0, topY, rightX, bottomY))
	} else if conn.right {
		rects = append(rects, image.Rect(leftX, topY, x1, bottomY))
	}
	if conn.up && conn.down {
		rects = append(rects, image.Rect(leftX, y0, rightX, y1))
	} else if conn.up {
		rects = append(rects, image.Rect(leftX, y0, rightX, bottomY))
	} else if conn.down {
		rects = append(rects, image.Rect(leftX, topY, rightX, y1))
	}
	return rects, true
}

func roundedCornerRects(char rune, bounds image.Rectangle, thickness int) []image.Rectangle {
	x0, y0, x1, y1 := bounds.Min.X, bounds.Min.Y, bounds.Max.X, bounds.Max.Y
	midX, midY := x0+bounds.Dx()/2, y0+bounds.Dy()/2
	top := char == '╭' || char == '╮'
	left := char == '╭' || char == '╰'
	startY, endY := y0, midY
	if top {
		startY, endY = midY, y1
	}
	centerX := float64(x0)
	if left {
		centerX = float64(x1)
	}
	centerY := float64(y0)
	if top {
		centerY = float64(y1)
	}
	radiusX := float64(bounds.Dx()) / 2
	radiusY := float64(bounds.Dy()) / 2
	rects := make([]image.Rectangle, 0, endY-startY)
	previousX := midX
	for y := startY; y < endY; y++ {
		normalizedY := (float64(y) + 0.5 - centerY) / radiusY
		offsetX := radiusX * math.Sqrt(max(0, 1-normalizedY*normalizedY))
		x := int(math.Round(centerX + offsetX))
		if left {
			x = int(math.Round(centerX - offsetX))
		}
		minX, maxX := min(previousX, x), max(previousX, x)
		rects = append(rects, image.Rect(
			max(x0, minX-thickness/2),
			y,
			min(x1, maxX+(thickness+1)/2),
			y+1,
		))
		previousX = x
	}
	return rects
}

func dashedHorizontalRects(bounds image.Rectangle, thickness int) []image.Rectangle {
	y := bounds.Min.Y + bounds.Dy()/2
	rects := make([]image.Rectangle, 0, 4)
	for eighth := 0; eighth < 8; eighth += 2 {
		x0 := bounds.Min.X + bounds.Dx()*eighth/8
		x1 := bounds.Min.X + bounds.Dx()*(eighth+1)/8
		rects = append(rects, image.Rect(x0, y-thickness/2, x1, y+(thickness+1)/2))
	}
	return rects
}

func quadrantRects(char rune, bounds image.Rectangle) []image.Rectangle {
	x0, y0, x1, y1 := bounds.Min.X, bounds.Min.Y, bounds.Max.X, bounds.Max.Y
	midX := x0 + (bounds.Dx()+1)/2
	midY := y0 + (bounds.Dy()+1)/2
	quadrants := map[rune][4]bool{
		'▖': {false, false, true, false},
		'▗': {false, false, false, true},
		'▘': {true, false, false, false},
		'▙': {true, false, true, true},
		'▚': {true, false, false, true},
		'▛': {true, true, true, false},
		'▜': {true, true, false, true},
		'▝': {false, true, false, false},
		'▞': {false, true, true, false},
		'▟': {false, true, true, true},
	}
	rects := make([]image.Rectangle, 0, 4)
	for i, rect := range []image.Rectangle{
		image.Rect(x0, y0, midX, midY),
		image.Rect(midX, y0, x1, midY),
		image.Rect(x0, midY, midX, y1),
		image.Rect(midX, midY, x1, y1),
	} {
		if quadrants[char][i] {
			rects = append(rects, rect)
		}
	}
	return rects
}

func sameTextStyle(a, b renderedCell) bool {
	return a.foreground == b.foreground &&
		a.bold == b.bold &&
		a.italic == b.italic &&
		a.faint == b.faint &&
		a.invisible == b.invisible &&
		a.strikethrough == b.strikethrough &&
		a.overline == b.overline &&
		a.underline == b.underline
}

func (b *ghosttyBackend) drawTextRun(target draw.Image, text string, x, y int, style renderedCell) {
	if strings.TrimSpace(text) == "" {
		return
	}
	fm := b.fontMaps[fontStyle{bold: style.bold, italic: style.italic}]
	runes := []rune(text)
	inputRun := shaping.Input{
		Text:     runes,
		RunStart: 0,
		RunEnd:   len(runes),
		Size:     fixed.I(b.options.FontSize),
	}
	segmenter := shaping.Segmenter{}
	shaper := shaping.HarfbuzzShaper{}
	runs := segmenter.Split(inputRun, fm)
	output := make([]shaping.Output, len(runs))
	for i, run := range runs {
		output[i] = shaper.Shape(run)
	}
	sort.Slice(output, func(i, j int) bool { return output[i].VisualIndex < output[j].VisualIndex })

	foreground := style.foreground
	if style.faint {
		foreground.A = 0x80
	}
	b.renderer.Color = foreground
	layer := image.NewRGBA(image.Rect(0, 0, target.Bounds().Dx()-x, b.cellHeight))
	drawX := 0
	for _, run := range output {
		drawX = b.renderer.DrawShapedRunAt(run, layer, drawX, b.baseline)
	}
	draw.Draw(target, image.Rect(x, y, target.Bounds().Dx(), y+b.cellHeight), layer, image.Point{}, draw.Over)
}

func (b *ghosttyBackend) drawDecorations(target draw.Image, start, end, row int, style renderedCell) {
	if style.invisible {
		return
	}
	x0, x1 := start*b.cellWidth, end*b.cellWidth
	y0 := row * b.cellHeight
	line := func(y, thickness int) {
		draw.Draw(target, image.Rect(x0, y, x1, min(y+thickness, y0+b.cellHeight)),
			image.NewUniform(style.foreground), image.Point{}, draw.Src)
	}
	thickness := max(1, b.options.FontSize/14)
	if style.overline {
		line(y0, thickness)
	}
	if style.strikethrough {
		line(y0+b.baseline-b.options.FontSize/3, thickness)
	}
	if style.underline != libghostty.UnderlineNone {
		line(min(y0+b.cellHeight-thickness, y0+b.baseline+b.options.FontSize/8), thickness)
		if style.underline == libghostty.UnderlineDouble {
			line(min(y0+b.cellHeight-thickness, y0+b.baseline+b.options.FontSize/8+thickness*2), thickness)
		}
	}
}

func (b *ghosttyBackend) drawCursor(target draw.Image) error {
	visible, err := b.state.CursorVisible()
	if err != nil {
		return fmt.Errorf("read Ghostty cursor visibility: %w", err)
	}
	if !visible {
		return nil
	}
	blinking, err := b.state.CursorBlinking()
	if err != nil {
		return fmt.Errorf("read Ghostty cursor blinking state: %w", err)
	}
	if b.options.CursorBlink && blinking && int(time.Since(b.blinkStart)/(500*time.Millisecond))%2 == 1 {
		return nil
	}
	hasPosition, err := b.state.CursorViewportHasValue()
	if err != nil {
		return fmt.Errorf("read Ghostty cursor position state: %w", err)
	}
	if !hasPosition {
		return nil
	}
	x, err := b.state.CursorViewportX()
	if err != nil {
		return fmt.Errorf("read Ghostty cursor column: %w", err)
	}
	y, err := b.state.CursorViewportY()
	if err != nil {
		return fmt.Errorf("read Ghostty cursor row: %w", err)
	}
	style, err := b.state.CursorVisualStyle()
	if err != nil {
		return fmt.Errorf("read Ghostty cursor style: %w", err)
	}
	left, top := int(x)*b.cellWidth, int(y)*b.cellHeight
	rect := image.Rect(left, top, left+b.cellWidth, top+b.cellHeight)
	switch style {
	case libghostty.CursorVisualStyleBlock:
	case libghostty.CursorVisualStyleBar:
		rect.Max.X = min(rect.Max.X, rect.Min.X+max(1, b.cellWidth/8))
	case libghostty.CursorVisualStyleUnderline:
		rect.Min.Y = max(rect.Min.Y, rect.Max.Y-max(1, b.cellHeight/10))
	case libghostty.CursorVisualStyleBlockHollow:
		thickness := max(1, b.cellWidth/10)
		draw.Draw(target, image.Rect(rect.Min.X, rect.Min.Y, rect.Max.X, rect.Min.Y+thickness), image.NewUniform(b.cursor), image.Point{}, draw.Src)
		draw.Draw(target, image.Rect(rect.Min.X, rect.Max.Y-thickness, rect.Max.X, rect.Max.Y), image.NewUniform(b.cursor), image.Point{}, draw.Src)
		draw.Draw(target, image.Rect(rect.Min.X, rect.Min.Y, rect.Min.X+thickness, rect.Max.Y), image.NewUniform(b.cursor), image.Point{}, draw.Src)
		draw.Draw(target, image.Rect(rect.Max.X-thickness, rect.Min.Y, rect.Max.X, rect.Max.Y), image.NewUniform(b.cursor), image.Point{}, draw.Src)
		return nil
	}
	draw.Draw(target, rect, image.NewUniform(b.cursor), image.Point{}, draw.Src)
	return nil
}

func encodePNG(img image.Image) ([]byte, error) {
	var buf bytes.Buffer
	if err := png.Encode(&buf, img); err != nil {
		return nil, fmt.Errorf("encode Ghostty frame: %w", err)
	}
	return buf.Bytes(), nil
}

func (b *ghosttyBackend) Terminate() error {
	if b.command == nil || b.command.Process == nil {
		return nil
	}
	if err := b.command.Process.Kill(); err != nil {
		return fmt.Errorf("terminate Ghostty shell: %w", err)
	}
	return nil
}

func (b *ghosttyBackend) Close() error {
	var closeErr error
	if b.pty != nil {
		closeErr = b.pty.Close()
	}
	b.mu.Lock()
	defer b.mu.Unlock()
	if b.event != nil {
		b.event.Close()
	}
	if b.encoder != nil {
		b.encoder.Close()
	}
	if b.state != nil {
		b.state.Close()
	}
	if b.term != nil {
		b.term.Close()
	}
	if closeErr != nil {
		return fmt.Errorf("close Ghostty PTY: %w", closeErr)
	}
	return nil
}

func checkedUint32(value int) (uint32, error) {
	if value < 0 || uint64(value) > math.MaxUint32 {
		return 0, fmt.Errorf("%d is outside the uint32 range", value)
	}
	return uint32(value), nil
}

func boundedUint16(value int) uint16 {
	switch {
	case value <= 0:
		return 0
	case value >= math.MaxUint16:
		return math.MaxUint16
	default:
		return uint16(value)
	}
}

func validRune(value uint32) rune {
	if value > utf8.MaxRune {
		return utf8.RuneError
	}
	return rune(value)
}