main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <pwd.h>

#if defined(__APPLE__)
#include <util.h>
#else
#include <pty.h>
#endif

#include "raylib.h"
#include <ghostty/vt.h>

// Embed the font file directly into the binary at compile time.
// The header is generated by CMake from fonts/JetBrainsMono-Regular.ttf
// so we don't need to locate it at runtime.
#include "font_jetbrains_mono.h"

// ---------------------------------------------------------------------------
// PTY helpers
// ---------------------------------------------------------------------------

// Spawn the user's default shell in a new pseudo-terminal.
//
// Creates a pty pair via forkpty(), sets the initial window size, execs the
// shell in the child, and puts the master fd into non-blocking mode so we
// can poll it each frame without stalling the render loop.
//
// The shell is chosen by checking, in order:
//   1. $SHELL environment variable
//   2. The pw_shell field from the passwd database
//   3. /bin/sh as a last resort
//
// Returns the master fd on success (>= 0) and stores the child pid in
// *child_out.  Returns -1 on failure.
static int pty_spawn(pid_t *child_out, uint16_t cols, uint16_t rows,
                     int cell_width, int cell_height)
{
    int pty_fd;
    struct winsize ws = {
        .ws_row = rows,
        .ws_col = cols,
        .ws_xpixel = (unsigned short)(cols * cell_width),
        .ws_ypixel = (unsigned short)(rows * cell_height),
    };

    // forkpty() combines openpty + fork + login_tty into one call.
    // In the child it sets up the slave side as stdin/stdout/stderr.
    pid_t child = forkpty(&pty_fd, NULL, NULL, &ws);
    if (child < 0) {
        perror("forkpty");
        return -1;
    }
    if (child == 0) {
        // Determine the user's preferred shell.  We try $SHELL first (the
        // standard convention), then fall back to the passwd entry, and
        // finally to /bin/sh if nothing else is available.
        const char *shell = getenv("SHELL");
        if (!shell || shell[0] == '\0') {
            struct passwd *pw = getpwuid(getuid());
            if (pw && pw->pw_shell && pw->pw_shell[0] != '\0')
                shell = pw->pw_shell;
            else
                shell = "/bin/sh";
        }

        // Extract just the program name for argv[0] (e.g. "/bin/zsh" → "zsh").
        const char *shell_name = strrchr(shell, '/');
        shell_name = shell_name ? shell_name + 1 : shell;

        // Child process — replace ourselves with the shell.
        // TERM tells programs what escape sequences we understand.
        setenv("TERM", "xterm-256color", 1);
        execl(shell, shell_name, NULL);
        _exit(127); // execl only returns on error
    }

    // Parent — make the master fd non-blocking so read() returns EAGAIN
    // instead of blocking when there's no data, letting us poll each frame.
    int flags = fcntl(pty_fd, F_GETFL);
    if (flags < 0 || fcntl(pty_fd, F_SETFL, flags | O_NONBLOCK) < 0) {
        perror("fcntl O_NONBLOCK");
        close(pty_fd);
        return -1;
    }

    *child_out = child;
    return pty_fd;
}

// Best-effort write to the pty master fd.  Because the fd is
// non-blocking, write() may return short or fail with EAGAIN.  We
// retry on EINTR, advance past partial writes, and silently drop
// data if the kernel buffer is full (EAGAIN) — this matches what
// most terminal emulators do under back-pressure.
static void pty_write(int pty_fd, const char *buf, size_t len)
{
    while (len > 0) {
        ssize_t n = write(pty_fd, buf, len);
        if (n > 0) {
            buf += n;
            len -= (size_t)n;
        } else if (n < 0) {
            if (errno == EINTR)
                continue;
            // EAGAIN or real error — drop the remainder.
            break;
        }
    }
}

// Result of draining the pty master fd.
typedef enum {
    PTY_READ_OK,    // data was drained (or EAGAIN, i.e. nothing available right now)
    PTY_READ_EOF,   // the child closed its end of the pty
    PTY_READ_ERROR, // a real read error occurred
} PtyReadResult;

// Drain all available output from the pty master and feed it into the
// ghostty terminal.  The terminal's VT parser will process any escape
// sequences and update its internal screen/cursor/style state.
//
// Because the fd is non-blocking, read() returns -1 with EAGAIN once
// the kernel buffer is empty, at which point we stop.
static PtyReadResult pty_read(int pty_fd, GhosttyTerminal terminal)
{
    uint8_t buf[4096];
    for (;;) {
        ssize_t n = read(pty_fd, buf, sizeof(buf));
        if (n > 0) {
            ghostty_terminal_vt_write(terminal, buf, (size_t)n);
        } else if (n == 0) {
            // EOF — the child closed its side of the pty.
            return PTY_READ_EOF;
        } else {
            // n == -1: distinguish "no data right now" from real errors.
            if (errno == EAGAIN)
                return PTY_READ_OK;
            if (errno == EINTR)
                continue; // retry the read
            // On Linux, the slave closing often produces EIO rather
            // than a clean EOF (read returning 0).  Treat it the same.
            if (errno == EIO)
                return PTY_READ_EOF;
            perror("pty read");
            return PTY_READ_ERROR;
        }
    }
}

// ---------------------------------------------------------------------------
// Input handling
// ---------------------------------------------------------------------------

// Map a raylib key constant to a GhosttyKey code.
// Returns GHOSTTY_KEY_UNIDENTIFIED for keys we don't handle.
static GhosttyKey raylib_key_to_ghostty(int rl_key)
{
    // Letters — raylib KEY_A..KEY_Z are contiguous, and so are
    // GHOSTTY_KEY_A..GHOSTTY_KEY_Z.
    if (rl_key >= KEY_A && rl_key <= KEY_Z)
        return GHOSTTY_KEY_A + (rl_key - KEY_A);

    // Digits — raylib KEY_ZERO..KEY_NINE are contiguous.
    if (rl_key >= KEY_ZERO && rl_key <= KEY_NINE)
        return GHOSTTY_KEY_DIGIT_0 + (rl_key - KEY_ZERO);

    // Function keys — raylib KEY_F1..KEY_F12 are contiguous.
    if (rl_key >= KEY_F1 && rl_key <= KEY_F12)
        return GHOSTTY_KEY_F1 + (rl_key - KEY_F1);

    switch (rl_key) {
    case KEY_SPACE:       return GHOSTTY_KEY_SPACE;
    case KEY_ENTER:       return GHOSTTY_KEY_ENTER;
    case KEY_TAB:         return GHOSTTY_KEY_TAB;
    case KEY_BACKSPACE:   return GHOSTTY_KEY_BACKSPACE;
    case KEY_DELETE:      return GHOSTTY_KEY_DELETE;
    case KEY_ESCAPE:      return GHOSTTY_KEY_ESCAPE;
    case KEY_UP:          return GHOSTTY_KEY_ARROW_UP;
    case KEY_DOWN:        return GHOSTTY_KEY_ARROW_DOWN;
    case KEY_LEFT:        return GHOSTTY_KEY_ARROW_LEFT;
    case KEY_RIGHT:       return GHOSTTY_KEY_ARROW_RIGHT;
    case KEY_HOME:        return GHOSTTY_KEY_HOME;
    case KEY_END:         return GHOSTTY_KEY_END;
    case KEY_PAGE_UP:     return GHOSTTY_KEY_PAGE_UP;
    case KEY_PAGE_DOWN:   return GHOSTTY_KEY_PAGE_DOWN;
    case KEY_INSERT:      return GHOSTTY_KEY_INSERT;
    case KEY_MINUS:       return GHOSTTY_KEY_MINUS;
    case KEY_EQUAL:       return GHOSTTY_KEY_EQUAL;
    case KEY_LEFT_BRACKET:  return GHOSTTY_KEY_BRACKET_LEFT;
    case KEY_RIGHT_BRACKET: return GHOSTTY_KEY_BRACKET_RIGHT;
    case KEY_BACKSLASH:   return GHOSTTY_KEY_BACKSLASH;
    case KEY_SEMICOLON:   return GHOSTTY_KEY_SEMICOLON;
    case KEY_APOSTROPHE:  return GHOSTTY_KEY_QUOTE;
    case KEY_COMMA:       return GHOSTTY_KEY_COMMA;
    case KEY_PERIOD:      return GHOSTTY_KEY_PERIOD;
    case KEY_SLASH:       return GHOSTTY_KEY_SLASH;
    case KEY_GRAVE:       return GHOSTTY_KEY_BACKQUOTE;
    default:              return GHOSTTY_KEY_UNIDENTIFIED;
    }
}

// Build a GhosttyMods bitmask from the current raylib modifier key state.
static GhosttyMods get_ghostty_mods(void)
{
    GhosttyMods mods = 0;
    if (IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT))
        mods |= GHOSTTY_MODS_SHIFT;
    if (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_RIGHT_CONTROL))
        mods |= GHOSTTY_MODS_CTRL;
    if (IsKeyDown(KEY_LEFT_ALT) || IsKeyDown(KEY_RIGHT_ALT))
        mods |= GHOSTTY_MODS_ALT;
    if (IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_RIGHT_SUPER))
        mods |= GHOSTTY_MODS_SUPER;
    return mods;
}

// Return the unshifted Unicode codepoint for a raylib key, i.e. the
// character the key produces with no modifiers on a US layout.  The
// Kitty keyboard protocol requires this to identify keys.  Returns 0
// for keys that don't have a natural codepoint (arrows, F-keys, etc.).
static uint32_t raylib_key_unshifted_codepoint(int rl_key)
{
    if (rl_key >= KEY_A && rl_key <= KEY_Z)
        return 'a' + (uint32_t)(rl_key - KEY_A);
    if (rl_key >= KEY_ZERO && rl_key <= KEY_NINE)
        return '0' + (uint32_t)(rl_key - KEY_ZERO);

    switch (rl_key) {
    case KEY_SPACE:          return ' ';
    case KEY_MINUS:          return '-';
    case KEY_EQUAL:          return '=';
    case KEY_LEFT_BRACKET:   return '[';
    case KEY_RIGHT_BRACKET:  return ']';
    case KEY_BACKSLASH:      return '\\';
    case KEY_SEMICOLON:      return ';';
    case KEY_APOSTROPHE:     return '\'';
    case KEY_COMMA:          return ',';
    case KEY_PERIOD:         return '.';
    case KEY_SLASH:          return '/';
    case KEY_GRAVE:          return '`';
    default:                 return 0;
    }
}

// Encode a single Unicode codepoint into a UTF-8 byte buffer.
// Returns the number of bytes written (1–4).
// Invalid codepoints (> U+10FFFF) are replaced with U+FFFD.
static int utf8_encode(uint32_t cp, char out[4])
{
    // Unicode defines the maximum valid codepoint as U+10FFFF.
    // Codepoints above this value are invalid and should be replaced
    // with the Unicode replacement character U+FFFD.
    const uint32_t MAX_UNICODE = 0x10FFFF;
    const uint32_t REPLACEMENT_CHAR = 0xFFFD;

    if (cp > MAX_UNICODE) {
        cp = REPLACEMENT_CHAR;
    }

    if (cp < 0x80) {
        out[0] = (char)cp;
        return 1;
    } else if (cp < 0x800) {
        out[0] = (char)(0xC0 | (cp >> 6));
        out[1] = (char)(0x80 | (cp & 0x3F));
        return 2;
    } else if (cp < 0x10000) {
        out[0] = (char)(0xE0 | (cp >> 12));
        out[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
        out[2] = (char)(0x80 | (cp & 0x3F));
        return 3;
    } else {
        out[0] = (char)(0xF0 | (cp >> 18));
        out[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
        out[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
        out[3] = (char)(0x80 | (cp & 0x3F));
        return 4;
    }
}

// Map a raylib mouse button to a GhosttyMouseButton.
static GhosttyMouseButton raylib_mouse_to_ghostty(int rl_button)
{
    switch (rl_button) {
    case MOUSE_BUTTON_LEFT:    return GHOSTTY_MOUSE_BUTTON_LEFT;
    case MOUSE_BUTTON_RIGHT:   return GHOSTTY_MOUSE_BUTTON_RIGHT;
    case MOUSE_BUTTON_MIDDLE:  return GHOSTTY_MOUSE_BUTTON_MIDDLE;
    case MOUSE_BUTTON_SIDE:    return GHOSTTY_MOUSE_BUTTON_FOUR;
    case MOUSE_BUTTON_EXTRA:   return GHOSTTY_MOUSE_BUTTON_FIVE;
    case MOUSE_BUTTON_FORWARD: return GHOSTTY_MOUSE_BUTTON_SIX;
    case MOUSE_BUTTON_BACK:    return GHOSTTY_MOUSE_BUTTON_SEVEN;
    default:                   return GHOSTTY_MOUSE_BUTTON_UNKNOWN;
    }
}

// Encode a mouse event and write the resulting escape sequence to the pty.
// If the encoder produces no output (e.g. tracking is disabled), this is
// a no-op.
static void mouse_encode_and_write(int pty_fd, GhosttyMouseEncoder encoder,
                                   GhosttyMouseEvent event)
{
    char buf[128];
    size_t written = 0;
    GhosttyResult res = ghostty_mouse_encoder_encode(
        encoder, event, buf, sizeof(buf), &written);
    if (res == GHOSTTY_SUCCESS && written > 0)
        pty_write(pty_fd, buf, written);
}

// Poll raylib for mouse events and use the libghostty mouse encoder
// to produce the correct VT escape sequences, which are then written
// to the pty.  The encoder handles tracking mode (X10, normal, button,
// any-event) and output format (X10, UTF8, SGR, URxvt, SGR-Pixels)
// based on what the terminal application has requested.
static void handle_mouse(int pty_fd, GhosttyMouseEncoder encoder,
                         GhosttyMouseEvent event, GhosttyTerminal terminal,
                         int cell_width, int cell_height, int pad)
{
    // Sync encoder tracking mode and format from terminal state so
    // mode changes (e.g. applications enabling SGR mouse reporting)
    // are honoured automatically.
    ghostty_mouse_encoder_setopt_from_terminal(encoder, terminal);

    // Provide the encoder with the current terminal geometry so it
    // can convert pixel positions to cell coordinates.
    int scr_w = GetScreenWidth();
    int scr_h = GetScreenHeight();
    GhosttyMouseEncoderSize enc_size = {
        .size          = sizeof(GhosttyMouseEncoderSize),
        .screen_width  = (uint32_t)scr_w,
        .screen_height = (uint32_t)scr_h,
        .cell_width    = (uint32_t)cell_width,
        .cell_height   = (uint32_t)cell_height,
        .padding_top   = (uint32_t)pad,
        .padding_bottom = (uint32_t)pad,
        .padding_left  = (uint32_t)pad,
        .padding_right = (uint32_t)pad,
    };
    ghostty_mouse_encoder_setopt(encoder,
        GHOSTTY_MOUSE_ENCODER_OPT_SIZE, &enc_size);

    // Track whether any button is currently held — the encoder uses
    // this to distinguish drags from plain motion.
    bool any_pressed = IsMouseButtonDown(MOUSE_BUTTON_LEFT)
                    || IsMouseButtonDown(MOUSE_BUTTON_RIGHT)
                    || IsMouseButtonDown(MOUSE_BUTTON_MIDDLE);
    ghostty_mouse_encoder_setopt(encoder,
        GHOSTTY_MOUSE_ENCODER_OPT_ANY_BUTTON_PRESSED, &any_pressed);

    // Enable motion deduplication so the encoder suppresses redundant
    // motion events within the same cell.
    bool track_cell = true;
    ghostty_mouse_encoder_setopt(encoder,
        GHOSTTY_MOUSE_ENCODER_OPT_TRACK_LAST_CELL, &track_cell);

    GhosttyMods mods = get_ghostty_mods();
    Vector2 pos = GetMousePosition();
    ghostty_mouse_event_set_mods(event, mods);
    ghostty_mouse_event_set_position(event,
        (GhosttyMousePosition){ .x = pos.x, .y = pos.y });

    // Check each mouse button for press/release events.
    static const int buttons[] = {
        MOUSE_BUTTON_LEFT, MOUSE_BUTTON_RIGHT, MOUSE_BUTTON_MIDDLE,
        MOUSE_BUTTON_SIDE, MOUSE_BUTTON_EXTRA, MOUSE_BUTTON_FORWARD,
        MOUSE_BUTTON_BACK,
    };
    for (size_t i = 0; i < sizeof(buttons) / sizeof(buttons[0]); i++) {
        int rl_btn = buttons[i];
        GhosttyMouseButton gbtn = raylib_mouse_to_ghostty(rl_btn);
        if (gbtn == GHOSTTY_MOUSE_BUTTON_UNKNOWN)
            continue;

        if (IsMouseButtonPressed(rl_btn)) {
            ghostty_mouse_event_set_action(event, GHOSTTY_MOUSE_ACTION_PRESS);
            ghostty_mouse_event_set_button(event, gbtn);
            mouse_encode_and_write(pty_fd, encoder, event);
        } else if (IsMouseButtonReleased(rl_btn)) {
            ghostty_mouse_event_set_action(event, GHOSTTY_MOUSE_ACTION_RELEASE);
            ghostty_mouse_event_set_button(event, gbtn);
            mouse_encode_and_write(pty_fd, encoder, event);
        }
    }

    // Mouse motion — send a motion event with whatever button is held
    // (or no button for pure motion in any-event tracking mode).
    Vector2 delta = GetMouseDelta();
    if (delta.x != 0.0f || delta.y != 0.0f) {
        ghostty_mouse_event_set_action(event, GHOSTTY_MOUSE_ACTION_MOTION);
        if (IsMouseButtonDown(MOUSE_BUTTON_LEFT))
            ghostty_mouse_event_set_button(event, GHOSTTY_MOUSE_BUTTON_LEFT);
        else if (IsMouseButtonDown(MOUSE_BUTTON_RIGHT))
            ghostty_mouse_event_set_button(event, GHOSTTY_MOUSE_BUTTON_RIGHT);
        else if (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE))
            ghostty_mouse_event_set_button(event, GHOSTTY_MOUSE_BUTTON_MIDDLE);
        else
            ghostty_mouse_event_clear_button(event);
        mouse_encode_and_write(pty_fd, encoder, event);
    }

    // Scroll wheel handling.  When a mouse tracking mode is active the
    // wheel events are forwarded to the application as button 4/5
    // press+release pairs.  Otherwise we scroll the viewport through
    // the scrollback buffer so the user can review history.
    float wheel = GetMouseWheelMove();
    if (wheel != 0.0f) {
        // Check whether any mouse tracking mode is enabled.  If so,
        // the application wants to handle scroll events itself.
        bool mouse_tracking = false;
        ghostty_terminal_get(terminal, GHOSTTY_TERMINAL_DATA_MOUSE_TRACKING, &mouse_tracking);

        if (mouse_tracking) {
            // Forward to the application via the mouse encoder.
            GhosttyMouseButton scroll_btn = (wheel > 0.0f)
                ? GHOSTTY_MOUSE_BUTTON_FOUR
                : GHOSTTY_MOUSE_BUTTON_FIVE;
            ghostty_mouse_event_set_button(event, scroll_btn);
            ghostty_mouse_event_set_action(event, GHOSTTY_MOUSE_ACTION_PRESS);
            mouse_encode_and_write(pty_fd, encoder, event);
            ghostty_mouse_event_set_action(event, GHOSTTY_MOUSE_ACTION_RELEASE);
            mouse_encode_and_write(pty_fd, encoder, event);
        } else {
            // Scroll the viewport through scrollback.  Scroll 3 rows
            // per wheel tick for a comfortable pace.  Delta is negative
            // to scroll up (into history), positive to scroll down.
            int delta = (wheel > 0.0f) ? -3 : 3;
            GhosttyTerminalScrollViewport sv = {
                .tag = GHOSTTY_SCROLL_VIEWPORT_DELTA,
                .value = { .delta = delta },
            };
            ghostty_terminal_scroll_viewport(terminal, sv);
        }
    }
}

// Poll raylib for keyboard events and use the libghostty key encoder
// to produce the correct VT escape sequences, which are then written
// to the pty.  The encoder respects terminal modes (cursor key
// application mode, Kitty keyboard protocol, etc.) so we don't need
// to maintain our own escape-sequence tables.
static void handle_input(int pty_fd, GhosttyKeyEncoder encoder,
                         GhosttyKeyEvent event, GhosttyTerminal terminal)
{
    // Sync encoder options from the terminal so mode changes (e.g.
    // application cursor keys, Kitty keyboard protocol) are honoured.
    ghostty_key_encoder_setopt_from_terminal(encoder, terminal);

    // Drain printable characters from raylib's input queue.  We collect
    // them into a single UTF-8 buffer so the encoder can attach text
    // to the key event.
    char char_utf8[64];
    int char_utf8_len = 0;
    int ch;
    while ((ch = GetCharPressed()) != 0) {
        char u8[4];
        int n = utf8_encode(ch, u8);
        if (char_utf8_len + n < (int)sizeof(char_utf8)) {
            memcpy(&char_utf8[char_utf8_len], u8, n);
            char_utf8_len += n;
        }
    }

    // All raylib keys we want to check for press/repeat events.
    // Letters and digits are handled via ranges; everything else is
    // enumerated explicitly.
    static const int special_keys[] = {
        KEY_SPACE, KEY_ENTER, KEY_TAB, KEY_BACKSPACE, KEY_DELETE,
        KEY_ESCAPE, KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT,
        KEY_HOME, KEY_END, KEY_PAGE_UP, KEY_PAGE_DOWN, KEY_INSERT,
        KEY_MINUS, KEY_EQUAL, KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET,
        KEY_BACKSLASH, KEY_SEMICOLON, KEY_APOSTROPHE, KEY_COMMA,
        KEY_PERIOD, KEY_SLASH, KEY_GRAVE,
        KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6,
        KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12,
    };

    // Build the set of raylib keys to scan: letters + digits + specials.
    int keys_to_check[26 + 10 + sizeof(special_keys) / sizeof(special_keys[0])];
    int num_keys = 0;
    for (int k = KEY_A; k <= KEY_Z; k++)
        keys_to_check[num_keys++] = k;
    for (int k = KEY_ZERO; k <= KEY_NINE; k++)
        keys_to_check[num_keys++] = k;
    for (size_t i = 0; i < sizeof(special_keys) / sizeof(special_keys[0]); i++)
        keys_to_check[num_keys++] = special_keys[i];

    GhosttyMods mods = get_ghostty_mods();

    for (int i = 0; i < num_keys; i++) {
        int rl_key = keys_to_check[i];
        bool pressed  = IsKeyPressed(rl_key);
        bool repeated = IsKeyPressedRepeat(rl_key);
        bool released = IsKeyReleased(rl_key);
        if (!pressed && !repeated && !released)
            continue;

        GhosttyKey gkey = raylib_key_to_ghostty(rl_key);
        if (gkey == GHOSTTY_KEY_UNIDENTIFIED)
            continue;

        GhosttyKeyAction action = released  ? GHOSTTY_KEY_ACTION_RELEASE
                                : pressed   ? GHOSTTY_KEY_ACTION_PRESS
                                            : GHOSTTY_KEY_ACTION_REPEAT;

        ghostty_key_event_set_key(event, gkey);
        ghostty_key_event_set_action(event, action);
        ghostty_key_event_set_mods(event, mods);

        // The unshifted codepoint is the character the key produces
        // with no modifiers.  The Kitty protocol needs it to identify
        // keys independent of the current shift state.
        uint32_t ucp = raylib_key_unshifted_codepoint(rl_key);
        ghostty_key_event_set_unshifted_codepoint(event, ucp);

        // Consumed mods are modifiers the platform's text input
        // already accounted for when producing the UTF-8 text.
        // For printable keys, shift is consumed (it turns 'a' → 'A').
        // For non-printable keys nothing is consumed.
        GhosttyMods consumed = 0;
        if (ucp != 0 && (mods & GHOSTTY_MODS_SHIFT))
            consumed |= GHOSTTY_MODS_SHIFT;
        ghostty_key_event_set_consumed_mods(event, consumed);

        // Attach any UTF-8 text that raylib produced for this frame.
        // For unmodified printable keys this is the character itself;
        // for special keys or ctrl combos there's typically no text.
        // Release events never carry text.
        if (char_utf8_len > 0 && !released) {
            ghostty_key_event_set_utf8(event, char_utf8, (size_t)char_utf8_len);
            // Only attach the text to the first key event this frame
            // to avoid duplicating it.
            char_utf8_len = 0;
        } else {
            ghostty_key_event_set_utf8(event, NULL, 0);
        }

        char buf[128];
        size_t written = 0;
        GhosttyResult res = ghostty_key_encoder_encode(
            encoder, event, buf, sizeof(buf), &written);
        if (res == GHOSTTY_SUCCESS && written > 0) {
            pty_write(pty_fd, buf, written);
            // Text was consumed by the encoder — clear it so the
            // fallback below doesn't double-send.
            char_utf8_len = 0;
        }
    }

    // Fallback: on some platforms (e.g. VMs) the character event arrives
    // a frame after the key-press event.  If we collected UTF-8 text but
    // no key event consumed it, write it directly to the PTY so input
    // isn't silently dropped.
    if (char_utf8_len > 0)
        pty_write(pty_fd, char_utf8, char_utf8_len);
}

// Handle scrollbar drag-to-scroll.  When the user clicks in the
// scrollbar region we begin tracking; while held we map the mouse Y
// position directly to an absolute scroll offset so the thumb follows
// the cursor exactly.
//
// Returns true while a drag is in progress so the caller can skip
// normal mouse handling if desired.
static bool handle_scrollbar(GhosttyTerminal terminal,
                             GhosttyRenderState render_state,
                             bool *dragging)
{
    // Query scrollbar geometry from the terminal.
    GhosttyTerminalScrollbar scrollbar = {0};
    if (ghostty_terminal_get(terminal, GHOSTTY_TERMINAL_DATA_SCROLLBAR,
                             &scrollbar) != GHOSTTY_SUCCESS)
        return false;

    // Nothing to drag when the viewport covers all content.
    if (scrollbar.total <= scrollbar.len) {
        *dragging = false;
        return false;
    }

    int scr_w = GetScreenWidth();
    int scr_h = GetScreenHeight();
    const int bar_width = 6;
    const int bar_margin = 2;
    int bar_left = scr_w - bar_width - bar_margin;
    // Use a wider hit region for easier grabbing.
    int hit_left = bar_left - 8;
    Vector2 mpos = GetMousePosition();

    // Start a drag when the user clicks inside the hit region.
    if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)
        && mpos.x >= hit_left && mpos.x <= scr_w) {
        *dragging = true;
    }

    if (*dragging && IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
        // Map mouse Y directly to an absolute scroll offset.
        // Y=0 → top of scrollback (offset 0), Y=scr_h → bottom
        // (offset = total - len).
        uint64_t scrollable = scrollbar.total - scrollbar.len;
        double frac = (double)mpos.y / (double)scr_h;
        if (frac < 0.0) frac = 0.0;
        if (frac > 1.0) frac = 1.0;
        int64_t target = (int64_t)(frac * (double)scrollable);

        intptr_t delta = (intptr_t)(target - (int64_t)scrollbar.offset);
        if (delta != 0) {
            GhosttyTerminalScrollViewport sv = {
                .tag = GHOSTTY_SCROLL_VIEWPORT_DELTA,
                .value = { .delta = delta },
            };
            ghostty_terminal_scroll_viewport(terminal, sv);
            ghostty_render_state_update(render_state, terminal);
        }
    }

    if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT))
        *dragging = false;

    return *dragging;
}

// Deferred texture cleanup — textures uploaded during a frame can't be
// freed until after EndDrawing() flushes the draw commands to the GPU.
#define MAX_DEFERRED_TEXTURES 256
static Texture2D deferred_textures[MAX_DEFERRED_TEXTURES];
static int deferred_texture_count = 0;

static void defer_unload_texture(Texture2D tex)
{
    if (deferred_texture_count < MAX_DEFERRED_TEXTURES)
        deferred_textures[deferred_texture_count++] = tex;
    else
        UnloadTexture(tex); // overflow fallback — may glitch but won't leak
}

static void flush_deferred_textures(void)
{
    for (int i = 0; i < deferred_texture_count; i++)
        UnloadTexture(deferred_textures[i]);
    deferred_texture_count = 0;
}

// Draw all Kitty graphics placements for a given z-layer.
//
// The layer filter is applied by the iterator itself via
// ghostty_kitty_graphics_placement_iterator_set(), so we only see
// placements matching the requested layer.
//
// WARNING: This is deliberately simple but very inefficient.  Every
// visible image is re-uploaded to the GPU every frame and destroyed
// right after.  A real implementation should cache Texture2D objects
// keyed by image ID and only re-upload when the image is re-transmitted
// or evicted from the terminal's storage.
static void render_kitty_images(GhosttyTerminal terminal,
                                GhosttyKittyGraphics graphics,
                                GhosttyKittyGraphicsPlacementIterator placement_iter,
                                int cell_width, int cell_height, int pad,
                                GhosttyKittyPlacementLayer layer)
{
    // Configure the layer filter on the iterator so
    // placement_next() only yields matching placements.
    ghostty_kitty_graphics_placement_iterator_set(placement_iter,
        GHOSTTY_KITTY_GRAPHICS_PLACEMENT_ITERATOR_OPTION_LAYER, &layer);

    // Re-populate the iterator for this layer scan.
    if (ghostty_kitty_graphics_get(graphics,
            GHOSTTY_KITTY_GRAPHICS_DATA_PLACEMENT_ITERATOR,
            &placement_iter) != GHOSTTY_SUCCESS)
        return;

    while (ghostty_kitty_graphics_placement_next(placement_iter)) {
        // Look up the image for this placement.
        uint32_t image_id = 0;
        ghostty_kitty_graphics_placement_get(placement_iter,
            GHOSTTY_KITTY_GRAPHICS_PLACEMENT_DATA_IMAGE_ID, &image_id);

        GhosttyKittyGraphicsImage image_handle =
            ghostty_kitty_graphics_image(graphics, image_id);
        if (!image_handle)
            continue;

        // Get viewport-relative position.  Returns NO_VALUE when the
        // placement is entirely off-screen or is a virtual (unicode
        // placeholder) placement, so both cases are handled in one call.
        int32_t vp_col = 0, vp_row = 0;
        if (ghostty_kitty_graphics_placement_viewport_pos(
                placement_iter, image_handle, terminal,
                &vp_col, &vp_row) != GHOSTTY_SUCCESS)
            continue;

        // Read image dimensions and pixel data.  We only handle RGBA
        // (the PNG decoder we registered converts everything to RGBA).
        uint32_t img_w = 0, img_h = 0;
        ghostty_kitty_graphics_image_get(image_handle,
            GHOSTTY_KITTY_IMAGE_DATA_WIDTH, &img_w);
        ghostty_kitty_graphics_image_get(image_handle,
            GHOSTTY_KITTY_IMAGE_DATA_HEIGHT, &img_h);
        if (img_w == 0 || img_h == 0)
            continue;

        GhosttyKittyImageFormat fmt = GHOSTTY_KITTY_IMAGE_FORMAT_RGBA;
        ghostty_kitty_graphics_image_get(image_handle,
            GHOSTTY_KITTY_IMAGE_DATA_FORMAT, &fmt);
        if (fmt != GHOSTTY_KITTY_IMAGE_FORMAT_RGBA)
            continue;

        const uint8_t *data_ptr = NULL;
        size_t data_len = 0;
        ghostty_kitty_graphics_image_get(image_handle,
            GHOSTTY_KITTY_IMAGE_DATA_DATA_PTR, &data_ptr);
        ghostty_kitty_graphics_image_get(image_handle,
            GHOSTTY_KITTY_IMAGE_DATA_DATA_LEN, &data_len);
        if (!data_ptr || data_len < (size_t)img_w * img_h * 4)
            continue;

        // Compute grid cell count for rendered size.
        uint32_t grid_cols = 0, grid_rows = 0;
        if (ghostty_kitty_graphics_placement_grid_size(
                placement_iter, image_handle, terminal,
                &grid_cols, &grid_rows) != GHOSTTY_SUCCESS)
            continue;
        if (grid_cols == 0 || grid_rows == 0)
            continue;

        uint32_t dest_w = grid_cols * (uint32_t)cell_width;
        uint32_t dest_h = grid_rows * (uint32_t)cell_height;

        // Get the resolved source rectangle (handles "0 = full image"
        // semantics and clamps to image bounds).
        uint32_t src_x = 0, src_y = 0, src_w = 0, src_h = 0;
        if (ghostty_kitty_graphics_placement_source_rect(
                placement_iter, image_handle,
                &src_x, &src_y, &src_w, &src_h) != GHOSTTY_SUCCESS)
            continue;

        // Read the sub-cell pixel offsets.
        uint32_t x_offset = 0, y_offset = 0;
        ghostty_kitty_graphics_placement_get(placement_iter,
            GHOSTTY_KITTY_GRAPHICS_PLACEMENT_DATA_X_OFFSET, &x_offset);
        ghostty_kitty_graphics_placement_get(placement_iter,
            GHOSTTY_KITTY_GRAPHICS_PLACEMENT_DATA_Y_OFFSET, &y_offset);

        // Upload the RGBA data to a temporary texture, draw, and free.
        Image img = {
            .data    = (void *)(uintptr_t)data_ptr,
            .width   = (int)img_w,
            .height  = (int)img_h,
            .mipmaps = 1,
            .format  = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
        };
        Texture2D tex = LoadTextureFromImage(img);
        SetTextureFilter(tex, TEXTURE_FILTER_BILINEAR);

        int dest_x = pad + (int)vp_col * cell_width  + (int)x_offset;
        int dest_y = pad + (int)vp_row * cell_height + (int)y_offset;

        Rectangle src_rect = {
            (float)src_x, (float)src_y,
            (float)src_w, (float)src_h
        };
        Rectangle dst_rect = {
            (float)dest_x, (float)dest_y,
            (float)dest_w, (float)dest_h
        };
        DrawTexturePro(tex, src_rect, dst_rect,
                       (Vector2){0, 0}, 0.0f, WHITE);

        defer_unload_texture(tex);
    }
}

// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------

// Render the current terminal screen using the RenderState API.
//
// For each row/cell we read the grapheme codepoints and the cell's style,
// resolve foreground/background colors via the palette, and draw each
// character individually with DrawTextEx.  This supports per-cell colors
// from SGR sequences (bold, 256-color, 24-bit RGB, etc.).
//
// cell_width and cell_height are the measured dimensions of a single
// monospace glyph at the current font size, in screen (logical) pixels.
// font_size is the logical font size (before DPI scaling).
// pad is the pixel margin between the window edges and the terminal grid.
//
// If scrollbar is non-NULL, a scrollbar indicator is drawn on the right
// edge of the window.
static void render_terminal(GhosttyRenderState render_state,
                            GhosttyRenderStateRowIterator row_iter,
                            GhosttyRenderStateRowCells cells,
                            Font font,
                            int cell_width, int cell_height,
                            int font_size,
                            int pad,
                            const GhosttyTerminalScrollbar *scrollbar,
                            GhosttyTerminal terminal,
                            GhosttyKittyGraphicsPlacementIterator placement_iter)
{
    // Grab colors (palette, default fg/bg) from the render state so we
    // can resolve palette-indexed cell colors.
    GhosttyRenderStateColors colors = GHOSTTY_INIT_SIZED(GhosttyRenderStateColors);
    if (ghostty_render_state_colors_get(render_state, &colors) != GHOSTTY_SUCCESS)
        return;

    // Obtain the Kitty graphics storage from the terminal.  This is a
    // borrowed pointer valid until the next mutating terminal call.
    GhosttyKittyGraphics kitty_gfx = NULL;
    bool has_kitty = (ghostty_terminal_get(terminal,
        GHOSTTY_TERMINAL_DATA_KITTY_GRAPHICS, &kitty_gfx) == GHOSTTY_SUCCESS
        && kitty_gfx != NULL);

    // Populate the row iterator from the current render state snapshot.
    if (ghostty_render_state_get(render_state,
            GHOSTTY_RENDER_STATE_DATA_ROW_ITERATOR, &row_iter) != GHOSTTY_SUCCESS)
        return;

    // --- Layer 1: images below cell backgrounds (z < INT32_MIN/2) ---
    if (has_kitty && placement_iter) {
        render_kitty_images(terminal, kitty_gfx, placement_iter,
                            cell_width, cell_height, pad,
                            GHOSTTY_KITTY_PLACEMENT_LAYER_BELOW_BG);
    }

    // Small padding from the window edges.
    int y = pad;

    while (ghostty_render_state_row_iterator_next(row_iter)) {
        // Get the cells for this row (reuses the same cells handle).
        if (ghostty_render_state_row_get(row_iter,
                GHOSTTY_RENDER_STATE_ROW_DATA_CELLS, &cells) != GHOSTTY_SUCCESS)
            continue;

        int x = pad;

        while (ghostty_render_state_row_cells_next(cells)) {
            // How many codepoints make up the grapheme? 0 = empty cell.
            uint32_t grapheme_len = 0;
            ghostty_render_state_row_cells_get(cells,
                GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_GRAPHEMES_LEN, &grapheme_len);

            if (grapheme_len == 0) {
                // The cell has no text, but it might have a background
                // color (e.g. from an erase with a color set).  The
                // BG_COLOR data query resolves content-tag bg colors
                // and palette indices for us, returning INVALID_VALUE
                // when the cell has no background.
                GhosttyColorRgb bg = {0};
                if (ghostty_render_state_row_cells_get(cells,
                        GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_BG_COLOR, &bg) == GHOSTTY_SUCCESS) {
                    DrawRectangle(x, y, cell_width, cell_height,
                                  (Color){ bg.r, bg.g, bg.b, 255 });
                }

                x += cell_width;
                continue;
            }

            // Read the grapheme codepoints.
            uint32_t codepoints[16];
            uint32_t len = grapheme_len < 16 ? grapheme_len : 16;
            ghostty_render_state_row_cells_get(cells,
                GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_GRAPHEMES_BUF, codepoints);

            // Build a UTF-8 string from the grapheme codepoints.
            char text[64];
            int pos = 0;
            for (uint32_t i = 0; i < len && pos < 60; i++) {
                char u8[4];
                int n = utf8_encode(codepoints[i], u8);
                memcpy(&text[pos], u8, n);
                pos += n;
            }
            text[pos] = '\0';

            // Resolve foreground and background colors using the new
            // per-cell color queries.  These flatten style colors,
            // content-tag colors, and palette lookups into a single RGB
            // value, returning INVALID_VALUE when the cell has no
            // explicit color (in which case we use the terminal default).
            GhosttyColorRgb fg = colors.foreground;
            ghostty_render_state_row_cells_get(cells,
                GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_FG_COLOR, &fg);

            GhosttyColorRgb bg_rgb = colors.background;
            bool has_bg = ghostty_render_state_row_cells_get(cells,
                GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_BG_COLOR, &bg_rgb) == GHOSTTY_SUCCESS;

            // Read the style for flags (inverse, bold, italic) — color
            // resolution is handled above via the new API.
            GhosttyStyle style = GHOSTTY_INIT_SIZED(GhosttyStyle);
            ghostty_render_state_row_cells_get(cells,
                GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_STYLE, &style);

            // Inverse (reverse video): swap foreground and background colors.
            if (style.inverse) {
                GhosttyColorRgb tmp = fg;
                fg = bg_rgb;
                bg_rgb = tmp;
                has_bg = true;
            }

            Color ray_fg = { fg.r, fg.g, fg.b, 255 };

            // Draw a background rectangle if the cell has a non-default bg
            // or if inverse mode forced a swap.
            if (has_bg) {
                DrawRectangle(x, y, cell_width, cell_height, (Color){ bg_rgb.r, bg_rgb.g, bg_rgb.b, 255 });
            }

            // Italic: apply a simple shear by shifting the top of the glyph
            // to the right.  The offset is proportional to font size so it
            // looks reasonable at any scale.
            int italic_offset = style.italic ? (font_size / 6) : 0;

            DrawTextEx(font, text, (Vector2){x + italic_offset, y}, font_size, 0, ray_fg);

            // Bold: draw the text a second time shifted 1 pixel to the
            // right to thicken the strokes ("fake bold").
            if (style.bold) {
                DrawTextEx(font, text, (Vector2){x + italic_offset + 1, y}, font_size, 0, ray_fg);
            }

            x += cell_width;
        }

        // Clear per-row dirty flag after rendering it.
        bool clean = false;
        ghostty_render_state_row_set(row_iter,
            GHOSTTY_RENDER_STATE_ROW_OPTION_DIRTY, &clean);

        y += cell_height;
    }

    // --- Layer 2: images below text (INT32_MIN/2 <= z < 0) ---
    // Drawn after cell backgrounds but before the cursor and any
    // above-text images.  In our single-pass renderer the cell text
    // has already been drawn, but this still achieves the correct
    // visual for the common case where images sit behind text.
    if (has_kitty && placement_iter) {
        render_kitty_images(terminal, kitty_gfx, placement_iter,
                            cell_width, cell_height, pad,
                            GHOSTTY_KITTY_PLACEMENT_LAYER_BELOW_TEXT);
    }

    // Draw the cursor.
    bool cursor_visible = false;
    ghostty_render_state_get(render_state,
        GHOSTTY_RENDER_STATE_DATA_CURSOR_VISIBLE, &cursor_visible);
    bool cursor_in_viewport = false;
    ghostty_render_state_get(render_state,
        GHOSTTY_RENDER_STATE_DATA_CURSOR_VIEWPORT_HAS_VALUE, &cursor_in_viewport);

    if (cursor_visible && cursor_in_viewport) {
        uint16_t cx = 0, cy = 0;
        ghostty_render_state_get(render_state,
            GHOSTTY_RENDER_STATE_DATA_CURSOR_VIEWPORT_X, &cx);
        ghostty_render_state_get(render_state,
            GHOSTTY_RENDER_STATE_DATA_CURSOR_VIEWPORT_Y, &cy);

        // Draw the cursor using the foreground color (or explicit cursor
        // color if the terminal set one).
        GhosttyColorRgb cur_rgb = colors.foreground;
        if (colors.cursor_has_value)
            cur_rgb = colors.cursor;
        int cur_x = pad + cx * cell_width;
        int cur_y = pad + cy * cell_height;
        DrawRectangle(cur_x, cur_y, cell_width, cell_height, (Color){ cur_rgb.r, cur_rgb.g, cur_rgb.b, 128 });
    }

    // --- Layer 3: images above text (z >= 0) ---
    if (has_kitty && placement_iter) {
        render_kitty_images(terminal, kitty_gfx, placement_iter,
                            cell_width, cell_height, pad,
                            GHOSTTY_KITTY_PLACEMENT_LAYER_ABOVE_TEXT);
    }

    // Draw the scrollbar when there is scrollback content to scroll through.
    if (scrollbar && scrollbar->total > scrollbar->len) {
        int scr_w = GetScreenWidth();
        int scr_h = GetScreenHeight();

        // Scrollbar track spans the full window height; the thumb
        // is proportional to the visible fraction of the total content.
        const int bar_width = 6;
        const int bar_margin = 2;
        int bar_x = scr_w - bar_width - bar_margin;

        double visible_frac = (double)scrollbar->len / (double)scrollbar->total;
        int thumb_height = (int)(scr_h * visible_frac);
        if (thumb_height < 10) thumb_height = 10;

        // Offset: 0 = scrolled all the way up (oldest), total-len =
        // bottom (most recent).  Map to y so bottom-of-viewport aligns
        // with the bottom of the track.
        double scroll_frac = (scrollbar->total > scrollbar->len)
            ? (double)scrollbar->offset / (double)(scrollbar->total - scrollbar->len)
            : 1.0;
        int thumb_y = (int)(scroll_frac * (scr_h - thumb_height));

        DrawRectangle(bar_x, thumb_y, bar_width, thumb_height,
                      (Color){ 200, 200, 200, 128 });
    }

    // Reset global dirty state so the next update reports changes accurately.
    GhosttyRenderStateDirty clean_state = GHOSTTY_RENDER_STATE_DIRTY_FALSE;
    ghostty_render_state_set(render_state,
        GHOSTTY_RENDER_STATE_OPTION_DIRTY, &clean_state);
}

// ---------------------------------------------------------------------------
// Build info
// ---------------------------------------------------------------------------

// Log compile-time build info from libghostty-vt so we can quickly tell
// whether the library was built with SIMD, and in which optimization mode.
static void log_build_info(void)
{
    bool simd = false;
    ghostty_build_info(GHOSTTY_BUILD_INFO_SIMD, &simd);

    GhosttyOptimizeMode opt = GHOSTTY_OPTIMIZE_DEBUG;
    ghostty_build_info(GHOSTTY_BUILD_INFO_OPTIMIZE, &opt);

    const char *opt_str;
    switch (opt) {
    case GHOSTTY_OPTIMIZE_DEBUG:        opt_str = "Debug";        break;
    case GHOSTTY_OPTIMIZE_RELEASE_SAFE: opt_str = "ReleaseSafe";  break;
    case GHOSTTY_OPTIMIZE_RELEASE_SMALL: opt_str = "ReleaseSmall"; break;
    case GHOSTTY_OPTIMIZE_RELEASE_FAST: opt_str = "ReleaseFast";  break;
    default:                            opt_str = "Unknown";       break;
    }

    TraceLog(LOG_INFO, "ghostty-vt: simd:     %s", simd ? "enabled" : "disabled");
    TraceLog(LOG_INFO, "ghostty-vt: optimize: %s", opt_str);
}

// ---------------------------------------------------------------------------
// System callbacks (process-global, set once at startup)
// ---------------------------------------------------------------------------

// decode_png — decodes raw PNG data into RGBA pixels using Raylib's
// stb_image-based decoder.  The output buffer is allocated through the
// provided GhosttyAllocator so the library can free it later.
static bool decode_png(void *userdata,
                       const GhosttyAllocator *allocator,
                       const uint8_t *data,
                       size_t data_len,
                       GhosttySysImage *out)
{
    (void)userdata;

    // Raylib's LoadImageFromMemory decodes the PNG via stb_image.
    Image img = LoadImageFromMemory(".png", data, (int)data_len);
    if (img.data == NULL) return false;

    // Convert to uncompressed R8G8B8A8 so we have a known pixel layout.
    ImageFormat(&img, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8);

    const size_t pixel_len = (size_t)img.width * (size_t)img.height * 4;
    uint8_t *pixels = ghostty_alloc(allocator, pixel_len);
    if (!pixels) {
        UnloadImage(img);
        return false;
    }
    memcpy(pixels, img.data, pixel_len);
    UnloadImage(img);

    out->width    = (uint32_t)img.width;
    out->height   = (uint32_t)img.height;
    out->data     = pixels;
    out->data_len = pixel_len;
    return true;
}

// ---------------------------------------------------------------------------
// Effects callbacks
// ---------------------------------------------------------------------------

// Context passed through the terminal's userdata pointer to all effect
// callbacks so they can reach the pty fd (and anything else they need)
// without global state.
typedef struct {
    int pty_fd;
    int cell_width;
    int cell_height;
    uint16_t cols;
    uint16_t rows;
} EffectsContext;

// write_pty effect — the terminal calls this whenever a VT sequence
// requires a response back to the application (device status reports,
// mode queries, device attributes, etc.).  Without this, programs like
// vim and tmux that probe terminal capabilities would hang.
static void effect_write_pty(GhosttyTerminal terminal, void *userdata,
                             const uint8_t *data, size_t len)
{
    (void)terminal;
    EffectsContext *ctx = (EffectsContext *)userdata;
    pty_write(ctx->pty_fd, (const char *)data, len);
}

// size effect — responds to XTWINOPS size queries (CSI 14/16/18 t)
// so programs can discover the terminal geometry in cells and pixels.
static bool effect_size(GhosttyTerminal terminal, void *userdata,
                        GhosttySizeReportSize *out_size)
{
    (void)terminal;
    EffectsContext *ctx = (EffectsContext *)userdata;
    out_size->rows = ctx->rows;
    out_size->columns = ctx->cols;
    out_size->cell_width = (uint32_t)ctx->cell_width;
    out_size->cell_height = (uint32_t)ctx->cell_height;
    return true;
}

// device_attributes effect — responds to DA1/DA2/DA3 queries so
// terminal applications can identify the terminal's capabilities.
// We report VT220-level conformance with a modest feature set.
static bool effect_device_attributes(GhosttyTerminal terminal, void *userdata,
                                     GhosttyDeviceAttributes *out_attrs)
{
    (void)terminal;
    (void)userdata;

    // DA1: VT220-level with a few common features.
    out_attrs->primary.conformance_level = GHOSTTY_DA_CONFORMANCE_VT220;
    out_attrs->primary.features[0] = GHOSTTY_DA_FEATURE_COLUMNS_132;
    out_attrs->primary.features[1] = GHOSTTY_DA_FEATURE_SELECTIVE_ERASE;
    out_attrs->primary.features[2] = GHOSTTY_DA_FEATURE_ANSI_COLOR;
    out_attrs->primary.num_features = 3;

    // DA2: VT220-type, version 1, no ROM cartridge.
    out_attrs->secondary.device_type = GHOSTTY_DA_DEVICE_TYPE_VT220;
    out_attrs->secondary.firmware_version = 1;
    out_attrs->secondary.rom_cartridge = 0;

    // DA3: arbitrary unit id.
    out_attrs->tertiary.unit_id = 0;

    return true;
}

// xtversion effect — responds to CSI > q with our application name.
static GhosttyString effect_xtversion(GhosttyTerminal terminal, void *userdata)
{
    (void)terminal;
    (void)userdata;
    return (GhosttyString){ .ptr = (const uint8_t *)"ghostling", .len = 9 };
}

// title_changed effect — updates the raylib window title whenever the
// terminal receives an OSC 0 or OSC 2 title-setting sequence.
static void effect_title_changed(GhosttyTerminal terminal, void *userdata)
{
    (void)userdata;
    GhosttyString title = {0};
    if (ghostty_terminal_get(terminal, GHOSTTY_TERMINAL_DATA_TITLE, &title) != GHOSTTY_SUCCESS)
        return;

    // SetWindowTitle expects a NUL-terminated string, so copy into a
    // stack buffer.  Truncate quietly if the title is absurdly long.
    char buf[256];
    size_t len = title.len < sizeof(buf) - 1 ? title.len : sizeof(buf) - 1;
    memcpy(buf, title.ptr, len);
    buf[len] = '\0';
    SetWindowTitle(buf);
}

// color_scheme effect — responds to CSI ? 996 n.  Raylib has no API to
// query the OS color scheme, so we return false to silently ignore the
// query rather than guessing.
static bool effect_color_scheme(GhosttyTerminal terminal, void *userdata,
                                GhosttyColorScheme *out_scheme)
{
    (void)terminal;
    (void)userdata;
    (void)out_scheme;
    return false;
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

int main(void)
{
    log_build_info();

    // Desired font size in logical (screen) points — the actual texture
    // will be rasterized at font_size * dpi_scale so glyphs stay crisp on
    // HiDPI / Retina displays.
    const int font_size = 16;

    // Enable HiDPI *before* creating the window so raylib can set up the
    // framebuffer at the native display resolution.
    SetConfigFlags(FLAG_WINDOW_HIGHDPI);

    // Initialize window
    InitWindow(800, 600, "ghostling");
    SetWindowState(FLAG_WINDOW_RESIZABLE);
    SetTargetFPS(60);

    // Query the DPI scale so we can rasterize the font at the true pixel
    // size.  On a 2× Retina display this returns {2.0, 2.0}.
    Vector2 dpi_scale = GetWindowScaleDPI();

    // Load the embedded monospace font at the native pixel size so every
    // glyph maps 1:1 to screen pixels — no texture scaling, no blur.
    int font_size_px = (int)(font_size * dpi_scale.y);
    Font mono_font = LoadFontFromMemory(".ttf", font_jetbrains_mono,
                         (int)sizeof(font_jetbrains_mono), font_size_px, NULL, 0);

    // Use bilinear filtering; the texture is already at native resolution
    // so there's no magnification blur, and this avoids jagged edges when
    // fractional positioning occurs.
    SetTextureFilter(mono_font.texture, TEXTURE_FILTER_BILINEAR);

    // Measure a representative glyph to derive the monospace cell size.
    // MeasureTextEx returns logical-pixel dimensions (already accounts for
    // the font's internal scaling), so divide by the DPI scale to get the
    // screen-space cell size we use for layout.
    Vector2 glyph_size = MeasureTextEx(mono_font, "M", font_size_px, 0);
    int cell_width  = (int)(glyph_size.x / dpi_scale.x);
    int cell_height = (int)(glyph_size.y / dpi_scale.y);

    // Guard against zero cell dimensions — these would cause division
    // by zero when computing the terminal grid.
    if (cell_width < 1) cell_width = 1;
    if (cell_height < 1) cell_height = 1;

    // Small padding from window edges, in pixels.  Passed to render_terminal()
    // and handle_mouse() so all layout uses a single value.
    const int pad = 4;

    // Compute the initial grid from the window size and measured cell
    // metrics.
    int scr_w = GetScreenWidth();
    int scr_h = GetScreenHeight();
    uint16_t term_cols = (uint16_t)((scr_w - 2 * pad) / cell_width);
    uint16_t term_rows = (uint16_t)((scr_h - 2 * pad) / cell_height);
    if (term_cols < 1) term_cols = 1;
    if (term_rows < 1) term_rows = 1;

    // Initialize all resource handles to safe defaults so the cleanup
    // label can free only what was successfully allocated.
    GhosttyTerminal terminal = NULL;
    pid_t child = -1;
    int pty_fd = -1;
    GhosttyKeyEncoder key_encoder = NULL;
    GhosttyKeyEvent key_event = NULL;
    GhosttyMouseEncoder mouse_encoder = NULL;
    GhosttyMouseEvent mouse_event = NULL;
    GhosttyRenderState render_state = NULL;
    GhosttyRenderStateRowIterator row_iter = NULL;
    GhosttyRenderStateRowCells row_cells = NULL;
    GhosttyKittyGraphicsPlacementIterator placement_iter = NULL;
    int exit_code = 0;

    // Install the PNG decoder via the sys interface so the terminal can
    // handle PNG images in the Kitty Graphics Protocol.  This is a
    // process-global setting and must be done before any terminal is
    // created.
    ghostty_sys_set(GHOSTTY_SYS_OPT_DECODE_PNG, (const void *)decode_png);

    // Create a ghostty virtual terminal with the computed grid and 1000
    // lines of scrollback.  This holds all the parsed screen state (cells,
    // cursor, styles, modes) but knows nothing about the pty or the window.
    GhosttyTerminalOptions opts = { .cols = term_cols, .rows = term_rows, .max_scrollback = 1000 };
    GhosttyResult err = ghostty_terminal_new(NULL, &terminal, opts);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_terminal_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    // The terminal options don't include cell pixel dimensions, so
    // issue an initial resize to set them.  Without this, Kitty
    // graphics placement_rect would divide by zero cell sizes.
    ghostty_terminal_resize(terminal, term_cols, term_rows,
                            (uint32_t)cell_width, (uint32_t)cell_height);

    // Spawn a child shell connected to a pseudo-terminal.  The master fd
    // is what we read/write; the child's stdin/stdout/stderr are wired to
    // the slave side.
    pty_fd = pty_spawn(&child, term_cols, term_rows, cell_width, cell_height);
    if (pty_fd < 0) {
        exit_code = 1;
        goto cleanup;
    }

    // Register effects so the terminal can respond to VT queries (device
    // attributes, mode reports, size queries, etc.) that programs like
    // vim, tmux, and htop send during startup.  Without these, query
    // sequences are silently dropped and those programs may hang or
    // fall back to degraded behavior.
    EffectsContext effects_ctx = {
        .pty_fd = pty_fd,
        .cell_width = cell_width,
        .cell_height = cell_height,
        .cols = term_cols,
        .rows = term_rows,
    };
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_USERDATA,
        &effects_ctx);

    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_WRITE_PTY,
        (const void *)effect_write_pty);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_SIZE,
        (const void *)effect_size);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_DEVICE_ATTRIBUTES,
        (const void *)effect_device_attributes);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_XTVERSION,
        (const void *)effect_xtversion);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_TITLE_CHANGED,
        (const void *)effect_title_changed);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_COLOR_SCHEME,
        (const void *)effect_color_scheme);

    // Enable Kitty graphics by setting a storage limit.  Without this the
    // terminal rejects all image data.  64 MiB is a generous default.
    uint64_t kitty_storage_limit = 64 * 1024 * 1024;
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_KITTY_IMAGE_STORAGE_LIMIT,
        &kitty_storage_limit);

    // Allow images to be transmitted via file, temp file, and shared
    // memory mediums in addition to the default inline (direct) medium.
    bool medium_enabled = true;
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_KITTY_IMAGE_MEDIUM_FILE,
        &medium_enabled);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_KITTY_IMAGE_MEDIUM_TEMP_FILE,
        &medium_enabled);
    ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_KITTY_IMAGE_MEDIUM_SHARED_MEM,
        &medium_enabled);

    // Create the key encoder and a reusable key event for input handling.
    // The encoder translates key events into the correct VT escape
    // sequences, respecting terminal modes like application cursor keys
    // and the Kitty keyboard protocol.
    err = ghostty_key_encoder_new(NULL, &key_encoder);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_key_encoder_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    err = ghostty_key_event_new(NULL, &key_event);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_key_event_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    // Create the mouse encoder and a reusable mouse event for input
    // handling.  The encoder translates mouse events into the correct
    // VT escape sequences, respecting terminal modes like SGR mouse
    // reporting and tracking mode (normal, button, any-event).
    err = ghostty_mouse_encoder_new(NULL, &mouse_encoder);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_mouse_encoder_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    err = ghostty_mouse_event_new(NULL, &mouse_event);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_mouse_event_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    // Create the render state and its reusable iterator/cells handles once
    // up front.  These are updated each frame rather than recreated.
    err = ghostty_render_state_new(NULL, &render_state);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_render_state_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    err = ghostty_render_state_row_iterator_new(NULL, &row_iter);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_render_state_row_iterator_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    err = ghostty_render_state_row_cells_new(NULL, &row_cells);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_render_state_row_cells_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    err = ghostty_kitty_graphics_placement_iterator_new(NULL, &placement_iter);
    if (err != GHOSTTY_SUCCESS) {
        fprintf(stderr, "ghostty_kitty_graphics_placement_iterator_new failed (%d)\n", err);
        exit_code = 1;
        goto cleanup;
    }

    // Track window size so we only recalculate the grid on actual changes.
    int prev_width = scr_w;
    int prev_height = scr_h;

    // Track focus state so we only send focus events on transitions.
    // Initialize from the actual window state to avoid a spurious
    // focus-lost event on startup.
    bool prev_focused = IsWindowFocused();

    // Scrollbar drag state — when the user clicks and drags the
    // scrollbar thumb we continuously reposition the viewport.
    bool scrollbar_dragging = false;

    // Set when the pty signals EOF/error — the child's side is closed.
    bool child_exited = false;
    // Set once waitpid() successfully reaps the child.
    bool child_reaped = false;
    int child_exit_status = -1;

    // Each frame: handle resize → read pty → process input → render.
    while (!WindowShouldClose()) {
        // Recalculate grid dimensions when the window is resized.
        // We update both the ghostty terminal (so it reflows text) and the
        // pty's winsize (so the child shell knows about the new size and
        // can send SIGWINCH to its foreground process group).
        if (IsWindowResized()) {
            int w = GetScreenWidth();
            int h = GetScreenHeight();
            if (w != prev_width || h != prev_height) {
                int cols = (w - 2 * pad) / cell_width;
                int rows = (h - 2 * pad) / cell_height;
                if (cols < 1) cols = 1;
                if (rows < 1) rows = 1;
                term_cols = (uint16_t)cols;
                term_rows = (uint16_t)rows;
                ghostty_terminal_resize(terminal, term_cols, term_rows,
                                        (uint32_t)cell_width, (uint32_t)cell_height);
                // Keep the effects context in sync so size queries
                // report the current geometry.
                effects_ctx.cols = term_cols;
                effects_ctx.rows = term_rows;
                struct winsize new_ws = {
                    .ws_row = term_rows,
                    .ws_col = term_cols,
                    .ws_xpixel = (unsigned short)(term_cols * cell_width),
                    .ws_ypixel = (unsigned short)(term_rows * cell_height),
                };
                ioctl(pty_fd, TIOCSWINSZ, &new_ws);
                prev_width = w;
                prev_height = h;
            }
        }

        // Send focus in/out events when the window focus state changes,
        // but only if the application has enabled focus reporting
        // (DECSET 1004).  Sending CSI I / CSI O unconditionally would
        // inject unexpected escape sequences into shells that never
        // asked for them.
        bool focused = IsWindowFocused();
        if (focused != prev_focused) {
            bool focus_mode = false;
            if (!child_exited
                && ghostty_terminal_mode_get(terminal,
                       GHOSTTY_MODE_FOCUS_EVENT, &focus_mode) == GHOSTTY_SUCCESS
                && focus_mode) {
                GhosttyFocusEvent focus_event = focused
                    ? GHOSTTY_FOCUS_GAINED : GHOSTTY_FOCUS_LOST;
                char focus_buf[8];
                size_t focus_written = 0;
                GhosttyResult focus_res = ghostty_focus_encode(
                    focus_event, focus_buf, sizeof(focus_buf), &focus_written);
                if (focus_res == GHOSTTY_SUCCESS && focus_written > 0)
                    pty_write(pty_fd, focus_buf, focus_written);
            }
            prev_focused = focused;
        }

        // Drain any pending output from the shell and update terminal state.
        // Once the child has exited we stop reading — the fd may be closed.
        if (!child_exited) {
            PtyReadResult pty_rc = pty_read(pty_fd, terminal);
            if (pty_rc != PTY_READ_OK) {
                // EOF or error — the child's side of the pty is closed.
                child_exited = true;
            }
        }

        // Try to reap the child each frame until we succeed.  The pty
        // EOF can arrive before the child is waitable, so a single
        // WNOHANG attempt right at EOF may miss.  We also check for
        // signal death so the banner can report it properly.
        if (child_exited && !child_reaped) {
            int wstatus = 0;
            pid_t wp = waitpid(child, &wstatus, WNOHANG);
            if (wp > 0) {
                child_reaped = true;
                if (WIFEXITED(wstatus))
                    child_exit_status = WEXITSTATUS(wstatus);
                else if (WIFSIGNALED(wstatus))
                    child_exit_status = 128 + WTERMSIG(wstatus);
            }
        }

        // Handle scrollbar drag-to-scroll before mouse forwarding so
        // clicks on the scrollbar region don't leak into terminal apps
        // (e.g. vim, tmux) as spurious mouse events.
        bool scrollbar_consumed = handle_scrollbar(terminal, render_state,
                                                   &scrollbar_dragging);

        // Forward keyboard/mouse input only while the child is alive.
        if (!child_exited) {
            handle_input(pty_fd, key_encoder, key_event, terminal);
            if (!scrollbar_consumed)
                handle_mouse(pty_fd, mouse_encoder, mouse_event, terminal,
                             cell_width, cell_height, pad);
        }

        // Snapshot the terminal state into our render state.  This is the
        // only point where we need access to the terminal; after this the
        // render state owns everything we need to draw the frame.
        ghostty_render_state_update(render_state, terminal);

        // Get the terminal's background color from the render state.
        GhosttyRenderStateColors bg_colors = GHOSTTY_INIT_SIZED(GhosttyRenderStateColors);
        ghostty_render_state_colors_get(render_state, &bg_colors);
        Color win_bg = { bg_colors.background.r, bg_colors.background.g, bg_colors.background.b, 255 };

        // Query scrollbar state for the renderer.
        GhosttyTerminalScrollbar scrollbar = {0};
        GhosttyTerminalScrollbar *scrollbar_ptr = NULL;
        if (ghostty_terminal_get(terminal, GHOSTTY_TERMINAL_DATA_SCROLLBAR,
                                 &scrollbar) == GHOSTTY_SUCCESS)
            scrollbar_ptr = &scrollbar;

        // Draw the current terminal screen.
        BeginDrawing();
        ClearBackground(win_bg);
        render_terminal(render_state, row_iter, row_cells, mono_font,
                        cell_width, cell_height, font_size, pad,
                        scrollbar_ptr, terminal, placement_iter);

        // Show a banner when the child process has exited so the user
        // knows the shell is gone (they can still scroll / inspect output).
        if (child_exited) {
            char exit_msg[128];
            if (child_exit_status >= 0)
                snprintf(exit_msg, sizeof(exit_msg),
                         "[process exited with status %d]", child_exit_status);
            else
                snprintf(exit_msg, sizeof(exit_msg), "[process exited]");

            Vector2 msg_size = MeasureTextEx(mono_font, exit_msg, font_size, 0);
            int screen_w = GetScreenWidth();
            int screen_h = GetScreenHeight();
            int banner_h = (int)msg_size.y + 8;
            DrawRectangle(0, screen_h - banner_h, screen_w, banner_h,
                          (Color){0, 0, 0, 180});
            DrawTextEx(mono_font, exit_msg,
                       (Vector2){(screen_w - msg_size.x) / 2,
                                 screen_h - banner_h + 4},
                       font_size, 0, WHITE);
        }

        EndDrawing();

        // Free any textures that were uploaded during this frame's
        // kitty image rendering.  Safe now that EndDrawing() has
        // flushed all draw commands to the GPU.
        flush_deferred_textures();
    }

cleanup:
    UnloadFont(mono_font);
    CloseWindow();
    if (pty_fd >= 0)
        close(pty_fd);
    if (child > 0 && !child_reaped) {
        // If the child is still running, ask it to exit.  Then do a
        // blocking waitpid to reap it and avoid leaving a zombie.
        if (!child_exited)
            kill(child, SIGHUP);
        waitpid(child, NULL, 0);
    }
    if (placement_iter) ghostty_kitty_graphics_placement_iterator_free(placement_iter);
    if (mouse_event)    ghostty_mouse_event_free(mouse_event);
    if (mouse_encoder)  ghostty_mouse_encoder_free(mouse_encoder);
    if (key_event)      ghostty_key_event_free(key_event);
    if (key_encoder)    ghostty_key_encoder_free(key_encoder);
    if (row_cells)      ghostty_render_state_row_cells_free(row_cells);
    if (row_iter)       ghostty_render_state_row_iterator_free(row_iter);
    if (render_state)   ghostty_render_state_free(render_state);
    if (terminal)       ghostty_terminal_free(terminal);
    return exit_code;
}