summaryrefslogtreecommitdiff
path: root/src/term/terminal.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/term/terminal.zig')
-rw-r--r--src/term/terminal.zig3411
1 files changed, 3411 insertions, 0 deletions
diff --git a/src/term/terminal.zig b/src/term/terminal.zig
new file mode 100644
index 00000000..bc5e7fd6
--- /dev/null
+++ b/src/term/terminal.zig
@@ -0,0 +1,3411 @@
+//! A terminal pane: its VT emulator, prompt rows, the edit overlay
+//! typed over shell rows, and the Filter that recolours output to the theme.
+const panes = @import("../panes.zig");
+const std = @import("std");
+const pardes = @import("../pardes.zig");
+const config = @import("../config.zig");
+const Pardes = pardes.Pardes;
+const Surface = pardes.Surface;
+const modal = @import("../modal.zig");
+const tracy = @import("../tracy.zig");
+const tagline = @import("../tagline.zig");
+const Key = pardes.Key;
+const Pane = panes.Pane;
+const EditText = panes.EditText;
+const File = panes.File;
+
+const ghostty_vt = @import("ghostty-vt");
+
+const EditBuffer = panes.Text.EditBuffer;
+const Snapshot = panes.Text.Snapshot;
+const history_max = panes.Text.history_max;
+
+pub const VtSlot = ghostty_vt.Terminal;
+/// A cell of an emulator's pages, as `getCell` reads it (src/term/echo.zig).
+pub const PageCell = ghostty_vt.PageList.Cell;
+/// Kitty graphics: a program's images are placements, as a kind's are.
+pub const images_enabled = true;
+pub const TerminalImages = if (images_enabled) @import("TerminalImages.zig") else void;
+pub const StreamSlot = ghostty_vt.Stream(MarkedHandler);
+
+/// The `aid` pardes's injected bash and fish marks carry (host_io.zig).
+pub const prompt_aid = "pardes";
+
+/// ghostty's handler, plus where the shell is in its command cycle as
+/// its OSC 133 marks tell it: ghostty parses D's exit status and drops
+/// it, and /pane/<n>/pty/run waits on exactly that. Only marks carrying
+/// pardes's own `aid` move it, so fish's native marks, a nested shell's
+/// and a stray `133;D` in some file being printed all pass it by.
+pub const MarkedHandler = struct {
+ inner: ghostty_vt.TerminalStream.Handler,
+ phase: enum { none, prompt, input, running } = .none,
+ /// Counts commands started (C at the input phase).
+ started: u32 = 0,
+ /// Counts prompts drawn (B), so a line the shell refused without
+ /// running (a fish syntax error: no C, no D, a new prompt) shows.
+ prompts: u32 = 0,
+ /// D marks outside a running command: the shell handled a line
+ /// without starting it (bash on a syntax error prints no C).
+ declined: u32 = 0,
+ /// The newest prompt continues an unfinished line (bash's PS2, marked
+ /// `k=c`): the shell still holds the start of the command.
+ continuation: bool = false,
+ /// Where the newest command's output began (its C) and ended (its
+ /// D) on the primary screen, pinned so scrolling keeps them.
+ out_start: ?*ghostty_vt.Pin = null,
+ out_end: ?*ghostty_vt.Pin = null,
+ /// The running command's output was erased under it -- a clear, ED 3,
+ /// a reset -- so the pins no longer span what it printed. ED 3 flags a
+ /// pin on an erased history row `garbage` (ghostty 1.4), but `pinTop`
+ /// re-pins the start at the screen's top, so the flag is gone with the
+ /// old pin: this remembers it, as it does for a reset or a pin that
+ /// could not be made.
+ lost: bool = false,
+
+ /// The newest command to end: which one, and its status if given.
+ finished: ?struct { seq: u32, status: ?i32 } = null,
+
+ const Action = ghostty_vt.TerminalStream.Action;
+
+ /// Move one of the output pins to the cursor. Only the primary screen
+ /// is pinned: a command's own full-screen display is not its output.
+ fn pinCursor(self: *@This(), slot: *?*ghostty_vt.Pin, now: bool) void {
+ const screen = self.inner.terminal.screens.get(.primary) orelse return;
+ if (slot.*) |old| screen.pages.untrackPin(old);
+ slot.* = null;
+ if (!now or self.inner.terminal.screens.active_key != .primary) return;
+ slot.* = screen.pages.trackPin(screen.cursor.page_pin.*) catch null;
+ }
+
+ pub fn vt(self: *@This(), comptime action: Action.Tag, value: Action.Value(action)) void {
+ if (comptime action == .semantic_prompt) mark: {
+ const aid = value.readOption(.aid) orelse break :mark;
+ if (!std.mem.eql(u8, aid, prompt_aid)) break :mark;
+ switch (value.action) {
+ .fresh_line_new_prompt => {
+ self.phase = .prompt;
+ self.continuation = value.readOption(.prompt_kind) == .continuation;
+ },
+ .end_prompt_start_input => {
+ self.phase = .input;
+ self.prompts +%= 1;
+ },
+ // bash's DEBUG trap also fires on its own PROMPT_COMMAND,
+ // outside the input phase; only a C that ends input counts
+ .end_input_start_output => if (self.phase == .input) {
+ self.phase = .running;
+ self.started +%= 1;
+ self.lost = false;
+ self.pinCursor(&self.out_start, true);
+ self.pinCursor(&self.out_end, false);
+ },
+ .end_command => if (self.phase == .running) {
+ self.phase = .none;
+ self.finished = .{ .seq = self.started, .status = value.readOption(.exit_code) };
+ self.pinCursor(&self.out_end, true);
+ } else {
+ self.declined +%= 1;
+ },
+ else => {},
+ }
+ }
+ if (comptime action == .erase_display_complete or action == .erase_display_scrollback or
+ action == .erase_display_scroll_complete or action == .full_reset)
+ {
+ self.inner.vt(action, value);
+ // A `clear` under a running command: its output is what it
+ // prints from here, the screen's top, not lost. Only what the
+ // scrollback later loses is (the pin goes `garbage`).
+ if (self.phase == .running) self.pinTop(&self.out_start);
+ return;
+ }
+ self.inner.vt(action, value);
+ }
+
+ /// Pins `slot` to the primary screen's top-left; lost when it cannot be.
+ fn pinTop(self: *@This(), slot: *?*ghostty_vt.Pin) void {
+ const screen = self.inner.terminal.screens.get(.primary) orelse return;
+ if (slot.*) |old| screen.pages.untrackPin(old);
+ slot.* = null;
+ if (self.inner.terminal.screens.active_key != .primary) {
+ self.lost = true;
+ return;
+ }
+ const top = screen.pages.pin(.{ .active = .{} }) orelse {
+ self.lost = true;
+ return;
+ };
+ slot.* = screen.pages.trackPin(top) catch null;
+ if (slot.* == null) self.lost = true;
+ }
+
+ pub fn deinit(self: *@This()) void {
+ self.inner.deinit();
+ }
+};
+
+fn ptyReport(handler: *ghostty_vt.TerminalStream.Handler, data: []const u8) void {
+ const state: *State = @alignCast(@fieldParentPtr("vt", handler.terminal));
+ const room = state.reply.len - state.reply_len;
+ // A cut answer is worse than none: the program would read the start of
+ // a sequence and wait, or misparse what follows.
+ if (data.len > room) {
+ state.reply_dropped +|= 1;
+ return;
+ }
+ @memcpy(state.reply[state.reply_len..][0..data.len], data);
+ state.reply_len += @intCast(data.len);
+}
+
+fn ptyDeviceAttrs(_: *ghostty_vt.TerminalStream.Handler) ghostty_vt.device_attributes.Attributes {
+ return .{};
+}
+
+/// CSI 14/16/18 t: the pane's size, and its cells' in pixels, which a
+/// program sizes its kitty graphics by (yazi asks 16 t). Unknown, not asked.
+fn ptySize(handler: *ghostty_vt.TerminalStream.Handler) ?ghostty_vt.size_report.Size {
+ const t = handler.terminal;
+ if (t.width_px == 0 or t.height_px == 0 or t.cols == 0 or t.rows == 0) return null;
+ return .{ .rows = t.rows, .columns = t.cols, .cell_width = t.width_px / t.cols, .cell_height = t.height_px / t.rows };
+}
+
+pub const State = struct {
+ /// What the emulator and this struct are allocated with: the core's,
+ /// but on a screen-state replica the C heap (`emulator_gpa`), outside
+ /// its rollback epoch: written by deltas while a copy is held, no part
+ /// of it is ever a copy's to save or put back.
+ gpa: std.mem.Allocator,
+ vt: VtSlot,
+ stream: StreamSlot,
+ /// The emulator's answers to its program (DSR, DA, kitty graphics, ...)
+ /// from one read of its output, written to its pty after it. Room for
+ /// a read's worth of kitty answers (yazi or `kitten icat` asking about
+ /// a batch of images in one write); an answer that does not fit whole
+ /// is dropped whole, never cut short (`reply_dropped` counts them).
+ reply: [4096]u8 = undefined,
+ reply_len: u16 = 0,
+ reply_dropped: u32 = 0,
+ /// The grid cell the program last heard the mouse at, so motion is
+ /// reported once per cell.
+ mouse_cell: ?ghostty_vt.Coordinate = null,
+ /// The kitty graphics its program placed, as drawn (TerminalImages.zig).
+ images: TerminalImages = if (images_enabled) .{} else {},
+ /// Counts the emulator's writes (output, a resize, its view scrolled):
+ /// a new count is a new state for its replicas (screen_state.Track).
+ changes: u32 = 0,
+ /// A step read its rows (its history too): a replica replaying that
+ /// step must hold them, so its authority sends the ones it does not
+ /// before the step's unit (replica.Screens.fill).
+ read: bool = false,
+ /// The size a step gave it, on an authority with screen-state replicas:
+ /// made after the step's unit (`resizeDeferred`), so that the rest of
+ /// the step reads the grid it had, as its replicas' replays do, and the
+ /// rows sent them for it (Screens.fill) are of that grid's numbering.
+ resize_to: ?struct { cols: u16, rows: u16 } = null,
+
+ /// The emulator as its program has made it, for the replay digest
+ /// (src/walk.zig): the active screen's text, how much history is above
+ /// it and where the view is, the cursor, the answers not yet written.
+ /// Not its pages (their addresses are its own), nor the history's text
+ /// (the screen's was all of it once, and a session's digest is taken
+ /// every step), nor the kitty images, whose media is read off the host:
+ /// a replica's terminal is the authority's screen state from phase 5
+ /// on (docs/next-daemon.md).
+ pub fn digest(s: *const State, h: *pardes.walk.Hasher) void {
+ // Under screen-state terminals the emulator is the authority's, and
+ // a replica's is what the last delta made it: compared as screens
+ // (test/replicas.zig), not step by step.
+ if (pardes.tape.screenState()) return;
+ s.digestScreen(h, true);
+ }
+
+ /// `view`: where its view is too (a replica's speculation may move it).
+ pub fn digestScreen(s: *const State, h: *pardes.walk.Hasher, view: bool) void {
+ const screen = s.vt.screens.active;
+ const sb = screen.pages.scrollbar();
+ const cur = screen.cursor;
+ const offset = if (view) sb.offset else 0;
+ const facts = .{ sb.total, offset, sb.len, cur.x, cur.y, s.vt.modes.get(.cursor_visible), s.vt.screens.active_key, s.reply_dropped };
+ inline for (facts) |fact| h.update(std.mem.asBytes(&fact));
+ h.update(s.reply[0..s.reply_len]);
+ var buf: [4096]u8 = undefined;
+ var text: std.Io.Writer.Hashing(pardes.walk.Hasher) = .initHasher(h.*, &buf);
+ if (screen.pages.getBottomRight(.active)) |br|
+ screen.dumpString(&text.writer, .{ .tl = screen.pages.getTopLeft(.active), .br = br, .unwrap = false }) catch unreachable; // a hashing writer never fails
+ text.writer.flush() catch unreachable; // a hashing writer never fails
+ h.* = text.hasher;
+ }
+
+ /// What the dump keeps of a terminal beside its emulator, by name as
+ /// every dump is (src/walk.zig).
+ const Parts = struct {
+ reply: []const u8 = "",
+ reply_dropped: u32 = 0,
+ mouse_cell: ?ghostty_vt.Coordinate = null,
+ petscii: bool = false,
+ /// The view's top row, counted from the top of the history.
+ view: usize = 0,
+ phase: @FieldType(MarkedHandler, "phase") = .none,
+ started: u32 = 0,
+ prompts: u32 = 0,
+ declined: u32 = 0,
+ continuation: bool = false,
+ lost: bool = false,
+ finished: @FieldType(MarkedHandler, "finished") = null,
+ out_start: ?ghostty_vt.Coordinate = null,
+ out_end: ?ghostty_vt.Coordinate = null,
+ };
+
+ fn pinAt(s: *const State, slot: ?*ghostty_vt.Pin) ?ghostty_vt.Coordinate {
+ const pin = slot orelse return null;
+ const screen = s.vt.screens.get(.primary) orelse return null;
+ return (screen.pages.pointFromPin(.screen, pin.*) orelse return null).screen;
+ }
+
+ /// The dump's: ghostty's snapshot of the emulator (both screens, their
+ /// history, styles, links and kitty images), then `Parts`. A sequence
+ /// its program had begun and not ended is not kept: the snapshot is at
+ /// the ground state.
+ pub fn dumpWrite(s: *const State, gpa: std.mem.Allocator, w: *std.Io.Writer) !void {
+ const h = &s.stream.handler;
+ const parts: Parts = .{
+ .reply = s.reply[0..s.reply_len],
+ .reply_dropped = s.reply_dropped,
+ .mouse_cell = s.mouse_cell,
+ .petscii = if (comptime images_enabled) s.images.petscii else false,
+ .view = s.vt.screens.active.pages.scrollbar().offset,
+ .phase = h.phase,
+ .started = h.started,
+ .prompts = h.prompts,
+ .declined = h.declined,
+ .continuation = h.continuation,
+ .lost = h.lost,
+ .finished = h.finished,
+ .out_start = s.pinAt(h.out_start),
+ .out_end = s.pinAt(h.out_end),
+ };
+ const bytes = try pardes.walk.save(Parts, gpa, &parts);
+ defer gpa.free(bytes);
+ try w.writeAll(std.mem.asBytes(&@as(u64, bytes.len)));
+ try w.writeAll(bytes);
+ // A join's (dump.zig `dumpJoin`): its size alone, an emulator made
+ // afresh there, which its first delta replaces.
+ if (pardes.dump.slim_terminals) return w.writeAll(std.mem.asBytes(&[2]u16{ s.vt.cols, s.vt.rows }));
+ try ghostty_vt.snapshot.encode(gpa, w, &s.vt, .{ .continuation = .ground });
+ }
+
+ /// What `dumpRead` made, freed: a load that failed after it.
+ pub fn dumpFree(s: *State, gpa: std.mem.Allocator) void {
+ if (comptime images_enabled) s.images.deinit(gpa);
+ s.stream.deinit();
+ s.vt.deinit(gpa);
+ }
+
+ /// `dumpWrite`'s back into `out`, a new State, as `create` makes one.
+ pub fn dumpRead(out: *State, gpa: std.mem.Allocator, bytes: []const u8) !void {
+ if (bytes.len < 8) return error.EndOfDump;
+ const n = std.math.cast(usize, std.mem.bytesToValue(u64, bytes[0..8])) orelse return error.EndOfDump;
+ if (bytes.len - 8 < n) return error.EndOfDump;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const parts = try pardes.walk.load(Parts, arena.allocator(), bytes[8..][0..n], null);
+ var reader: std.Io.Reader = .fixed(bytes[8 + n ..]);
+ if (reader.buffer.len == 4) {
+ const size = std.mem.bytesToValue([2]u16, bytes[8 + n ..][0..4]);
+ out.* = .{ .gpa = gpa, .vt = try emulator(gpa, @max(1, size[0]), @max(1, size[1])), .stream = undefined };
+ } else {
+ var decoded = try ghostty_vt.snapshot.decodeExact(gpa, terminalIo(), &reader, .{
+ .max_continuation_bytes = 0,
+ .kitty_image_storage_limit = if (images_enabled) TerminalImages.storage_limit else 0,
+ });
+ defer decoded.deinit(gpa);
+ out.* = .{ .gpa = gpa, .vt = decoded.toOwned(), .stream = undefined };
+ }
+ if (comptime images_enabled) inline for (.{ .primary, .alternate }) |key| {
+ if (out.vt.screens.get(key)) |screen| screen.kitty_images.image_limits = .allWithTempDir(tempDir());
+ };
+ out.wire();
+ const reply = parts.reply[0..@min(parts.reply.len, out.reply.len)];
+ @memcpy(out.reply[0..reply.len], reply);
+ out.reply_len = @intCast(reply.len);
+ out.reply_dropped = parts.reply_dropped;
+ out.mouse_cell = parts.mouse_cell;
+ out.images = if (images_enabled) .{ .petscii = parts.petscii } else {};
+ const h = &out.stream.handler;
+ h.phase = parts.phase;
+ h.started = parts.started;
+ h.prompts = parts.prompts;
+ h.declined = parts.declined;
+ h.continuation = parts.continuation;
+ h.lost = parts.lost;
+ h.finished = parts.finished;
+ if (out.vt.screens.get(.primary)) |screen| {
+ inline for (.{ .{ "out_start", parts.out_start }, .{ "out_end", parts.out_end } }) |pair| if (pair[1]) |at| {
+ if (screen.pages.pin(.{ .screen = at })) |pin| @field(h, pair[0]) = screen.pages.trackPin(pin) catch null;
+ };
+ }
+ const screen = out.vt.screens.active;
+ const bottom = screen.pages.scrollbar().offset;
+ screen.scroll(.{ .delta_row = @as(isize, @intCast(parts.view)) - @as(isize, @intCast(bottom)) });
+ }
+
+ /// The stream over the emulator, its answers to the program and its
+ /// size reports routed here, PNG decoded: what `create` and a dump's
+ /// load both do once the emulator is in place.
+ fn wire(s: *State) void {
+ s.stream = .init(.{ .handler = .{ .inner = s.vt.vtHandler() }, .allocator = s.gpa });
+ s.stream.handler.inner.effects.write_pty = ptyReport;
+ s.stream.handler.inner.effects.device_attributes = ptyDeviceAttrs;
+ s.stream.handler.inner.effects.size = ptySize;
+ if (comptime images_enabled) TerminalImages.installPngDecoder();
+ }
+};
+
+const GColor = ghostty_vt.color;
+
+const FilterPaletteKey = struct {
+ bg: GColor.RGB,
+ fg: GColor.RGB,
+ base: [16]GColor.RGB,
+};
+
+pub const FilterPalette = LivePalette;
+
+const LivePalette = struct {
+ key: ?FilterPaletteKey = null,
+ colors: GColor.Palette = GColor.default,
+
+ fn get(self: *LivePalette, theme: *const pardes.Theme) *const GColor.Palette {
+ const bg = asGhostRgb(theme.bg orelse theme.tag_bg);
+ const fg = asGhostRgb(theme.fg orelse theme.tag_fg);
+ var base: [16]GColor.RGB = undefined;
+ if (theme.palette) |palette| {
+ for (&base, palette) |*dst, src| dst.* = asGhostRgb(src);
+ } else {
+ const synthesized = [16][3]u8{
+ theme.bg orelse theme.tag_bg,
+ theme.kw,
+ theme.str,
+ theme.num,
+ theme.box,
+ theme.sel_bg,
+ theme.comment,
+ theme.fg orelse theme.tag_fg,
+ theme.lineno,
+ theme.kw,
+ theme.str,
+ theme.num,
+ theme.scroll_thumb,
+ theme.sel_fg,
+ theme.tag_fg,
+ theme.fg orelse theme.tag_fg,
+ };
+ for (&base, synthesized) |*dst, src| dst.* = asGhostRgb(src);
+ }
+
+ const key: FilterPaletteKey = .{ .bg = bg, .fg = fg, .base = base };
+ if (self.key) |old| if (std.meta.eql(old, key)) return &self.colors;
+
+ var seed = GColor.default;
+ for (base, 0..) |rgb, i| seed[i] = rgb;
+ self.colors = GColor.generate256Color(seed, .empty, bg, fg, false);
+ self.key = key;
+ return &self.colors;
+ }
+};
+
+fn asGhostRgb(rgb: [3]u8) GColor.RGB {
+ return .{ .r = rgb[0], .g = rgb[1], .b = rgb[2] };
+}
+
+pub const PendingCommand = struct {
+ bytes: []u8 = &.{},
+ wait: enum { none, spawn, input } = .none,
+};
+
+pub fn armShellSpawn(pane: *Pane) void {
+ std.debug.assert(pane.pending_command.bytes.len == 0);
+ pane.pending_command.wait = .spawn;
+}
+
+/// Remembers a line pardes types into this terminal as the command it
+/// started, for Kill: it runs from the shell's next C mark to its D.
+/// ponytail: of several lines queued for a shell not up yet, only the last
+/// is remembered, as the first of them.
+pub fn noteCommand(pane: *Pane, line: []const u8) void {
+ const state = pane.terminal orelse return;
+ const word = std.mem.trim(u8, line, " \t")[0 .. std.mem.indexOfAny(u8, std.mem.trim(u8, line, " \t"), " \t") orelse std.mem.trim(u8, line, " \t").len];
+ var sent: @typeInfo(@FieldType(Pane, "sent_command")).optional.child = .{ .seq = state.stream.handler.started +% 1 };
+ sent.len = @intCast(@min(word.len, sent.word.len));
+ @memcpy(sent.word[0..sent.len], word[0..sent.len]);
+ pane.sent_command = sent;
+}
+
+/// Whether the command pardes last typed here is running now.
+pub fn commandRunning(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ const sent = pane.sent_command orelse return false;
+ const marks = &state.stream.handler;
+ return marks.phase == .running and marks.started == sent.seq;
+}
+
+pub fn queuePendingCommand(pane: *Pane, command: []const u8) !bool {
+ if (pane.pending_command.wait == .none) return false;
+ const old_len = pane.pending_command.bytes.len;
+ const new_len = try std.math.add(usize, old_len, try std.math.add(usize, command.len, 1));
+ const bytes = if (old_len == 0)
+ try pane.gpa.alloc(u8, new_len)
+ else
+ try pane.gpa.realloc(pane.pending_command.bytes, new_len);
+ @memcpy(bytes[old_len..][0..command.len], command);
+ bytes[new_len - 1] = '\r';
+ pane.pending_command.bytes = bytes;
+ pane.greet = false;
+ return true;
+}
+
+pub fn shellSpawned(p: *Pardes, id: usize, prompt_marks: bool) void {
+ const pane = p.panes[id] orelse return;
+ if (!pane.isTerminal() or pane.pending_command.wait != .spawn) return;
+ if (prompt_marks) {
+ pane.pending_command.wait = .input;
+ releasePendingCommand(p, id, pane, false);
+ } else {
+ pane.greet = false;
+ releasePendingCommand(p, id, pane, true);
+ }
+}
+
+pub fn releasePendingCommandIfReady(p: *Pardes, id: usize, pane: *Pane) void {
+ if (pane.pending_command.wait == .input)
+ releasePendingCommand(p, id, pane, pardes.tape.value(.prompt, promptInputReady, .{pane}));
+}
+
+fn releasePendingCommand(p: *Pardes, id: usize, pane: *Pane, ready: bool) void {
+ if (!ready) return;
+ const bytes = pane.pending_command.bytes;
+ pane.pending_command = .{};
+ if (bytes.len > 0) {
+ p.emitWrite(id, bytes);
+ pane.gpa.free(bytes);
+ }
+}
+
+pub fn deinitPendingCommand(pane: *Pane) void {
+ if (pane.pending_command.bytes.len > 0)
+ pane.gpa.free(pane.pending_command.bytes);
+ pane.pending_command = .{};
+}
+
+/// Where a kitty client puts its temporary files: `$TMPDIR`, else /tmp
+/// (which ghostty accepts whatever this says). The environment block lives
+/// as long as the process and pardes never edits it (ChildEnv.exportVar).
+fn tempDir() []const u8 {
+ const dir = std.c.getenv("TMPDIR") orelse return "/tmp";
+ const path = std.mem.span(dir);
+ return if (path.len > 0 and path[0] == '/') path else "/tmp";
+}
+
+pub fn terminalIo() std.Io {
+ return std.Io.Threaded.global_single_threaded.io();
+}
+
+/// The three numbers ghostty's scrollbar reports; all zero without an emulator.
+pub const Scrollbar = struct { total: usize = 0, offset: usize = 0, len: usize = 0 };
+
+pub fn scrollbar(pane: *const Pane) Scrollbar {
+ const state = pane.terminal orelse return .{};
+ const sb = state.vt.screens.active.pages.scrollbar();
+ return .{ .total = sb.total, .offset = sb.offset, .len = sb.len };
+}
+
+/// The emulator's viewport offset, in SHELL rows: the top of what it shows.
+pub fn gridOffset(pane: *const Pane) i32 {
+ return @intCast(scrollbar(pane).offset);
+}
+
+/// Where the emulator itself puts the cursor, in active-area cells — the origin
+/// without one, which is where an empty pane's cursor belongs anyway.
+pub const GridCursor = struct { x: u16 = 0, y: u16 = 0 };
+
+pub fn gridCursor(pane: *const Pane) GridCursor {
+ const state = pane.terminal orelse return .{};
+ const cur = state.vt.screens.active.cursor;
+ return .{ .x = @intCast(cur.x), .y = @intCast(cur.y) };
+}
+
+pub fn visibleCursor(pane: *const Pane) ?GridCursor {
+ const state = pane.terminal orelse return null;
+ if (!state.vt.modes.get(.cursor_visible)) return null;
+ const cur = state.vt.screens.active.cursor;
+ const sb = scrollbar(pane);
+ const row = sb.total - sb.len + cur.y;
+ if (row < sb.offset + pane.pan or row - sb.offset >= sb.len) return null;
+ return .{ .x = @intCast(cur.x), .y = @intCast(row - sb.offset - pane.pan) };
+}
+
+/// The rows terminal `pane`'s top is passed over by in a view whose rect
+/// `r` is shorter than it, one that does not size it (Pardes.sizes): as
+/// many as keep its cursor's row in sight, as tmux pans a bigger window in
+/// a smaller client. 0 in the view that sizes it, and in one tall enough.
+pub fn panFor(p: *const Pardes, pane: *const Pane, r: pardes.Rect) u16 {
+ if (pane.sized_by == p.live or pane.collapsed or !pane.isTerminal()) return 0;
+ const shown = r.h -| pane.tag_rows;
+ if (shown == 0 or shown >= pane.rows) return 0;
+ const state = pane.terminal orelse return 0;
+ const sb = scrollbar(pane);
+ // The cursor's row in the viewport; past its end (scrolled back), its
+ // last row.
+ const row = sb.total - sb.len + state.vt.screens.active.cursor.y;
+ const at: usize = if (row < sb.offset) 0 else @min(row - sb.offset, pane.rows - 1);
+ return @intCast(@min(pane.rows - shown, (at + 1) -| shown));
+}
+
+/// What pardes made of a terminal's stream that its emulator does not hold
+/// (the OSC 133 cycle, MarkedHandler), for a replica's delta: phase u8,
+/// started, prompts, declined u32, continuation and lost u8, a finished
+/// command's seq u32 and status i32 (all ones: none; i32 min: no status).
+// ponytail: the output pins stay the authority's (its 9P pty/run reads them).
+pub const marks_len = 1 + 4 * 3 + 2 + 4 + 4;
+
+pub fn marksOf(state: *const State, buf: *[marks_len]u8) []const u8 {
+ const m = &state.stream.handler;
+ var w: std.Io.Writer = .fixed(buf);
+ w.writeByte(@backingInt(m.phase)) catch unreachable;
+ inline for (.{ m.started, m.prompts, m.declined }) |n| w.writeInt(u32, n, .little) catch unreachable;
+ w.writeAll(&.{ @intFromBool(m.continuation), @intFromBool(m.lost) }) catch unreachable;
+ w.writeInt(u32, if (m.finished) |f| f.seq else std.math.maxInt(u32), .little) catch unreachable;
+ w.writeInt(i32, if (m.finished) |f| f.status orelse std.math.minInt(i32) else 0, .little) catch unreachable;
+ return w.buffered();
+}
+
+/// A replica's terminal takes its authority's marks (`marksOf`).
+pub fn takeMarks(state: *State, bytes: []const u8) void {
+ if (bytes.len != marks_len) return;
+ const m = &state.stream.handler;
+ m.phase = @fromBackingInt(@intCast(bytes[0]));
+ m.started = std.mem.readInt(u32, bytes[1..5], .little);
+ m.prompts = std.mem.readInt(u32, bytes[5..9], .little);
+ m.declined = std.mem.readInt(u32, bytes[9..13], .little);
+ m.continuation = bytes[13] != 0;
+ m.lost = bytes[14] != 0;
+ const seq = std.mem.readInt(u32, bytes[15..19], .little);
+ const status = std.mem.readInt(i32, bytes[19..23], .little);
+ m.finished = if (seq == std.math.maxInt(u32)) null else .{ .seq = seq, .status = if (status == std.math.minInt(i32)) null else status };
+}
+
+/// A screen-state replica's emulators' allocator (`State.gpa`).
+pub const emulator_gpa = std.heap.c_allocator;
+
+/// What a terminal's emulator is made with, by `create` or a pane's load
+/// (dump.loadPane, a closed terminal brought back): `gpa`, but on a screen-
+/// state replica `emulator_gpa`.
+pub fn emulatorGpa(gpa: std.mem.Allocator) std.mem.Allocator {
+ return if (pardes.tape.screenReplica()) emulator_gpa else gpa;
+}
+
+/// A replica's speculation leaves an emulator be: it is the authority's
+/// (docs/next-daemon.md, phase 5), so the input waits for its order.
+fn authorityOnly(comptime why: []const u8) bool {
+ if (!pardes.tape.speculating()) return false;
+ pardes.tape.poison(why);
+ return true;
+}
+
+/// A speculation that moves a terminal's view: a screen-state replica's
+/// may (its rollback puts the view back, replica.zig `views`, and a delta
+/// sets it), any other stops (`authorityOnly`).
+fn viewOnly(comptime why: []const u8) bool {
+ if (!pardes.tape.speculating()) return false;
+ if (pardes.tape.screenState()) {
+ pardes.tape.touchTerminal();
+ return false;
+ }
+ pardes.tape.poison(why);
+ return true;
+}
+
+/// Where a terminal's view is: its top row counted from the top of its
+/// history, or null following its output (a replica's rollback copy,
+/// which holds no emulator, keeps it so).
+pub fn viewOf(pane: *const Pane) ?usize {
+ const state = pane.terminal orelse return null;
+ const pages = &state.vt.screens.active.pages;
+ if (pages.viewport == .active) return null;
+ return pages.scrollbar().offset;
+}
+
+pub fn viewTo(pane: *Pane, at: ?usize) void {
+ const state = pane.terminal orelse return;
+ state.vt.screens.active.scroll(if (at) |row| .{ .row = row } else .active);
+}
+
+/// Move the emulator's viewport by `delta` shell rows (negative scrolls back).
+pub fn scrollGrid(pane: *Pane, delta: i32) void {
+ if (viewOnly("scroll a terminal")) return;
+ const state = pane.terminal orelse return;
+ state.vt.screens.active.scroll(.{ .delta_row = delta });
+ state.changes +%= 1;
+}
+
+/// Is the viewport already showing the last row of output?
+pub fn atBottom(pane: *const Pane) bool {
+ const sb = scrollbar(pane);
+ return sb.offset + sb.len >= sb.total;
+}
+
+/// Snap the viewport back onto live output.
+pub fn followOutput(pane: *Pane) void {
+ if (viewOnly("follow a terminal")) return;
+ const state = pane.terminal orelse return;
+ const moved = state.vt.screens.active.pages.viewport != .active;
+ state.vt.screens.active.scroll(.active);
+ state.changes +%= @intFromBool(moved);
+}
+
+/// Reflow the grid. A failed reflow keeps the grid it had rather than dropping
+/// a scrollback; the next resize retries with the same numbers.
+pub fn resizeGrid(pane: *Pane, cols: u16, rows: u16) void {
+ if (authorityOnly("resize a terminal")) return;
+ const state = pane.terminal orelse return;
+ if (cols != pane.cols) for (0..pane.sel.len) |button| {
+ pane.clearPointerSelection(button);
+ pane.sel[button].state = .none;
+ };
+ // A replica's emulator is sized by its authority: the next delta says.
+ if (pardes.tape.screenReplica()) return;
+ // ...and the authority's once the step's unit is out (a client typing
+ // at another size than the last typist's read history rows its replay
+ // held as holes, and the rows came renumbered, 2026-10-30).
+ if (pardes.tape.screenAuthority()) {
+ state.resize_to = .{ .cols = cols, .rows = rows };
+ return;
+ }
+ state.changes +%= 1;
+ state.vt.resize(state.gpa, .{ .cols = cols, .rows = rows }) catch {};
+}
+
+/// The sizes steps gave terminals (`resizeGrid`), made: between units, on an
+/// authority with screen-state replicas (replica.Peers.unit).
+pub fn resizeDeferred(p: *Pardes) void {
+ for (p.panes) |slot| if (slot) |pane| if (pane.terminal) |state| if (state.resize_to) |size| {
+ state.resize_to = null;
+ state.changes +%= 1;
+ p.shell_rows.markStale(pane);
+ state.vt.resize(state.gpa, .{ .cols = size.cols, .rows = size.rows }) catch {};
+ };
+}
+
+/// DECSET 2004: the program wants its pastes bracketed.
+pub fn bracketedPaste(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return state.vt.modes.get(.bracketed_paste);
+}
+
+/// The program tracks the mouse itself, so a click in its body is its event.
+pub fn reportsMouse(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return state.vt.flags.mouse_event != .none;
+}
+
+/// A paste as xterm makes one (ghostty's encoder): the control bytes a
+/// paste could smuggle a command in by (ESC, so no ESC[201~ can end
+/// 2004's brackets early, NUL, ^C and the rest of xterm's list) become
+/// spaces, then the text goes inside the brackets when the program set
+/// 2004, else with its newlines as Returns. `text` is rewritten in place.
+pub fn encodePaste(pane: *const Pane, text: []u8) [3][]const u8 {
+ return ghostty_vt.input.encodePaste(text, .{ .bracketed = bracketedPaste(pane) });
+}
+
+/// DECSET 1004: the program wants to hear when it gains and loses focus.
+pub fn reportsFocus(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return state.vt.modes.get(.focus_event);
+}
+
+/// ...every move of it, a button down or not (1003).
+pub fn tracksAllMotion(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return state.vt.flags.mouse_event == .any;
+}
+
+/// A wheel over the program is the program's: it tracks the mouse, or it is
+/// on the alternate screen, which has no scrollback, with alternate scroll
+/// (DECSET 1007, on unless turned off) asking for arrow keys instead.
+pub fn ownsWheel(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return reportsMouse(pane) or
+ (state.vt.screens.active_key == .alternate and state.vt.modes.get(.mouse_alternate_scroll));
+}
+
+pub const MouseMods = struct { shift: bool = false, alt: bool = false, ctrl: bool = false };
+pub const MouseButton = enum { left, middle, right, wheel_up, wheel_down, wheel_left, wheel_right };
+pub const MouseAction = enum { press, release, motion };
+
+/// One mouse event for the program, as xterm reports it (ctlseqs; ghostty's
+/// encoder): the tracking mode it set (1000 clicks, 1002 drags, 1003 all
+/// motion) decides whether it hears of it, the format it set (1006 SGR,
+/// 1015 urxvt, 1005 UTF-8, else X10) how, modifiers as shift+4, meta+8,
+/// ctrl+16. `col`,`row` are the 0-based grid cell; a drag that left the
+/// grid is reported clamped to its edge, motion only when the cell
+/// changed. Empty when the program does not hear of it.
+pub fn mouseBytes(pane: *Pane, buf: *[64]u8, action: MouseAction, button: ?MouseButton, mods: MouseMods, col: i32, row: i32, any_pressed: bool) []const u8 {
+ const state = pane.terminal orelse return &.{};
+ const input = ghostty_vt.input;
+ var writer = std.Io.Writer.fixed(buf);
+ var opts: input.MouseEncodeOptions = .{
+ .event = state.vt.flags.mouse_event,
+ .format = state.vt.flags.mouse_format,
+ .size = .{
+ .screen = .{ .width = state.vt.cols, .height = state.vt.rows },
+ .cell = .{ .width = 1, .height = 1 },
+ .padding = .{},
+ },
+ .any_button_pressed = any_pressed,
+ .last_cell = &state.mouse_cell,
+ };
+ // A release is always reported; the rest only over the grid, or held.
+ if (action == .release) opts.any_button_pressed = true;
+ input.encodeMouse(&writer, .{
+ .action = switch (action) {
+ .press => .press,
+ .release => .release,
+ .motion => .motion,
+ },
+ .button = if (button) |b| switch (b) {
+ .left => .left,
+ .middle => .middle,
+ .right => .right,
+ .wheel_up => .four,
+ .wheel_down => .five,
+ .wheel_left => .six,
+ .wheel_right => .seven,
+ } else null,
+ .mods = .{ .shift = mods.shift, .alt = mods.alt, .ctrl = mods.ctrl },
+ .pos = .{ .x = @as(f32, @floatFromInt(col)) + 0.5, .y = @as(f32, @floatFromInt(row)) + 0.5 },
+ }, opts) catch return &.{}; // no report rather than half of one
+ return writer.buffered();
+}
+
+/// The bytes a wheel turn at grid cell `col`,`row` (0-based) sends the
+/// program: its mouse report while it tracks the mouse, else, on the
+/// alternate screen, an arrow key in the cursor keys' mode (none for a
+/// sideways turn). Null when the wheel is not the program's (`ownsWheel`).
+pub fn wheelBytes(pane: *Pane, buf: *[64]u8, wheel: MouseButton, col: u16, row: u16, mods: MouseMods) ?[]const u8 {
+ const state = pane.terminal orelse return null;
+ if (!ownsWheel(pane)) return null;
+ const m = &state.vt.modes;
+ if (!reportsMouse(pane)) return switch (wheel) {
+ .wheel_up => if (m.get(.cursor_keys)) "\x1bOA" else "\x1b[A",
+ .wheel_down => if (m.get(.cursor_keys)) "\x1bOB" else "\x1b[B",
+ else => null,
+ };
+ return mouseBytes(pane, buf, .press, wheel, mods, col, row, false);
+}
+
+/// The whole scrollback as plain text, `gpa`-owned: what a terminal's body
+/// reads and `Save` writes out. Logical lines: rows the terminal wrapped
+/// are joined again (ghostty's wrap flags, as pty/run's output is), and
+/// the last line ends with a newline.
+pub fn screenTextAlloc(pane: *Pane, gpa: std.mem.Allocator) ![]const u8 {
+ var out: std.Io.Writer.Allocating = .init(gpa);
+ errdefer out.deinit();
+ try writeScreenText(pane, &out.writer);
+ return out.toOwnedSlice();
+}
+
+fn writeScreenText(pane: *Pane, w: *std.Io.Writer) !void {
+ const state = pane.terminal orelse return;
+ const screen = state.vt.screens.active;
+ const br = screen.pages.getBottomRight(.screen) orelse return;
+ var both: TeeWriter = .{ .a = w };
+ try screen.dumpString(&both.writer, .{ .tl = screen.pages.getTopLeft(.screen), .br = br, .unwrap = true });
+ if (both.count > 0 and both.final != '\n') try w.writeByte('\n');
+}
+
+/// Passes bytes through, remembering how many and the last one.
+const TeeWriter = struct {
+ a: *std.Io.Writer,
+ count: usize = 0,
+ final: u8 = 0,
+ writer: std.Io.Writer = .{ .vtable = &.{ .drain = drain }, .buffer = &.{} },
+
+ fn drain(w: *std.Io.Writer, data: []const []const u8, splat: usize) std.Io.Writer.Error!usize {
+ const t: *TeeWriter = @alignCast(@fieldParentPtr("writer", w));
+ var n: usize = 0;
+ for (data[0 .. data.len - 1]) |bytes| {
+ try t.a.writeAll(bytes);
+ t.note(bytes);
+ n += bytes.len;
+ }
+ const pattern = data[data.len - 1];
+ for (0..splat) |_| {
+ try t.a.writeAll(pattern);
+ t.note(pattern);
+ n += pattern.len;
+ }
+ return n;
+ }
+
+ fn note(t: *TeeWriter, bytes: []const u8) void {
+ if (bytes.len == 0) return;
+ t.count += bytes.len;
+ t.final = bytes[bytes.len - 1];
+ }
+};
+
+/// How long `screenTextAlloc` would be, counted without keeping it: the
+/// length a terminal's body reads as, which its ctl line reports.
+pub fn screenTextLen(pane: *Pane) usize {
+ var buf: [256]u8 = undefined;
+ var counting: std.Io.Writer.Discarding = .init(&buf);
+ writeScreenText(pane, &counting.writer) catch unreachable; // a discarding writer never fails
+ return @intCast(counting.fullCount());
+}
+
+/// Release the emulator's heap. The Pane allocation itself is the core's.
+pub fn deinitEmulator(pane: *Pane, gpa: std.mem.Allocator) void {
+ // A pane with none (a file's, a picker's, a preview's) closes in a
+ // speculation as anywhere.
+ const state = pane.terminal orelse return;
+ if (authorityOnly("close a terminal")) return;
+ if (comptime images_enabled) state.images.deinit(gpa);
+ state.stream.deinit();
+ const own = state.gpa;
+ state.vt.deinit(own);
+ own.destroy(state);
+ pane.terminal = null;
+}
+
+/// A terminal pane's emulator, `cols` by `rows`, as `create` makes one.
+fn emulator(gpa: std.mem.Allocator, cols: u16, rows: u16) !ghostty_vt.Terminal {
+ return ghostty_vt.Terminal.init(terminalIo(), gpa, .{
+ .cols = cols,
+ .rows = rows,
+ .max_scrollback_bytes = 16 * 1024 * 1024,
+ .kitty_image_storage_limit = if (images_enabled) TerminalImages.storage_limit else 0,
+ // Every kitty medium, as ghostty and kitty take them: a file (t=f),
+ // a temporary file it then deletes (t=t, in the temp directory and
+ // named as one) and shared memory (t=s), beside direct data. libghostty
+ // defaults to direct alone, which `kitten icat` and timg detect and
+ // fall back from, base64 through the pty. What the program can read
+ // it could send itself: it runs as the user, under pardes.
+ .kitty_image_loading_limits = if (images_enabled) .allWithTempDir(tempDir()) else if (@FieldType(ghostty_vt.Terminal.Options, "kitty_image_loading_limits") == void) {} else .direct,
+ });
+}
+
+/// Allocate the live emulator half of a terminal pane. Slot ownership, serial
+/// assignment, and spawn effects remain core lifecycle invariants.
+pub fn create(gpa: std.mem.Allocator, cols: u16, rows: u16) !*Pane {
+ if (authorityOnly("open a terminal")) return error.OutOfMemory;
+ const pane = try createDoc(gpa, cols, rows);
+ errdefer gpa.destroy(pane);
+ const own = emulatorGpa(gpa);
+ const state = try own.create(State);
+ errdefer own.destroy(state);
+ // Every other field its default, never what the heap had: a digest
+ // reads them, and two replicas must agree (src/replica.zig).
+ state.* = .{ .gpa = own, .vt = try emulator(own, cols, rows), .stream = undefined };
+ state.wire();
+ pane.terminal = state;
+ pane.tty_filter = true;
+ return pane;
+}
+
+pub fn createDoc(gpa: std.mem.Allocator, cols: u16, rows: u16) !*Pane {
+ const pane = try gpa.create(Pane);
+ pane.* = .{
+ .gpa = gpa,
+ .cols = cols,
+ .rows = rows,
+ };
+ return pane;
+}
+
+/// Where a restored terminal's history ends and its new shell begins.
+pub const restored_banner = "\x1b[0m\r\n\x1b[2m\u{2500}\u{2500} restored history \u{2500}\u{2500}\x1b[0m\r\n";
+
+/// A terminal loaded from a dump, its shell not there, made ready for a new
+/// one: its program's screen modes reset (the old program is gone), its
+/// history marked off from what the new shell prints, and the pane waiting
+/// for it like any new terminal (a line queued for the old one goes to it).
+pub fn reviveShell(pane: *Pane) void {
+ if (pane.terminal == null) return;
+ // The primary screen, keys, cursor and mouse as a shell starts with
+ // them, the cursor where it was (a soft reset, or leaving a primary
+ // screen for itself, would take it home).
+ if (pane.terminal.?.vt.screens.active_key == .alternate) ingest(pane, "\x1b[?1049l");
+ ingest(pane, "\x1b[?1l\x1b>\x1b[?25h\x1b[?7h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?2004l\x1b[<u");
+ ingest(pane, restored_banner);
+ // What the old shell was, ran and said is gone with it: the REPL it
+ // ran, the Term+ word naming it.
+ pane.shell_spoke = false;
+ pane.had_shell = false;
+ pane.shell_failed = false;
+ pane.shell_tail_len = 0;
+ pane.repl = null;
+ pane.sent_command = null;
+ pane.pending_command.wait = .spawn;
+}
+
+/// Feed the emulator. Live output and restoration share this byte path,
+/// then apply different views.
+fn ingest(pane: *Pane, bytes: []const u8) void {
+ pane.terminal.?.stream.nextSlice(bytes);
+ pane.terminal.?.changes +%= 1;
+}
+
+/// What a pane says when a position kept over its terminal's rows could
+/// not follow the output (no memory for its pin), so it was reset.
+const positions_lost = "terminal edit position reset: out of memory";
+
+/// Record and parse one live pty read, invalidate its motion surface, and
+/// follow it only when the body (possibly parked under a tag edit) is raw.
+pub fn feedOutput(p: *Pardes, pane: *Pane, bytes: []const u8) void {
+ // There are no pty reads at all without an emulator to parse them into.
+ if (pane.terminal == null) return;
+ if (authorityOnly("a terminal's output")) return;
+ const has_positions = pane.ovl != null or pane.body.cur_pinned or pane.body.vsel.active or
+ pane.body.nsel > 0 or pane.body.last_edit != null or pane.look_at != null or
+ pane.body.ed_undo_len > 0 or pane.body.ed_redo_len > 0 or pointerRowCount(pane) > 0;
+ // A replica's emulator is what the authority's deltas make it; what
+ // pardes keeps over it moves as the authority's ingest told it.
+ if (pardes.tape.screenReplica()) {
+ if (has_positions and ingestWithPositions(pane, bytes)) if (panes.paneIdOf(p, pane)) |id| p.setMessage(id, positions_lost);
+ return;
+ }
+ // Sticky bottom, as every other terminal does it: output drags the
+ // viewport down only when the viewport was already on the last row, so
+ // a reader scrolled back into the scrollback stays where they scrolled.
+ const at_bottom = atBottom(pane);
+ syncPixels(p, pane);
+ if (!has_positions) {
+ ingest(pane, bytes);
+ } else if (ingestWithPositions(pane, bytes)) if (panes.paneIdOf(p, pane)) |id| p.setMessage(id, positions_lost);
+ p.shell_rows.markStale(pane);
+ if (pane.body.mode == .tty and at_bottom) followOutput(pane);
+}
+
+const RowPin = struct { pin: ?*ghostty_vt.Pin = null, offset: i32 = 0 };
+const PositionPin = struct {
+ target: *i32,
+ row: RowPin,
+ overlay: ?*EditBuffer,
+ edit_row: ?i32 = null,
+};
+
+fn trackRow(maybe_pages: ?*ghostty_vt.PageList, row: i32, failed: *bool) RowPin {
+ // A screen-state replica's: told by the tape, not its emulator.
+ const pages = maybe_pages orelse return .{ .offset = row };
+ if (row < 0) return .{ .offset = row };
+ const bounded: usize = @min(@as(usize, @intCast(row)), pages.total_rows - 1);
+ var left = pages.total_rows - 1 - bounded;
+ var node = pages.pages.last.?;
+ while (left >= node.rows()) {
+ left -= node.rows();
+ node = node.prev.?;
+ }
+ const pin = pages.trackPin(.{ .node = node, .y = @intCast(node.rows() - 1 - left) }) catch {
+ failed.* = true;
+ return .{};
+ };
+ return .{ .pin = pin, .offset = row - @as(i32, @intCast(bounded)) };
+}
+
+fn pinnedRow(pages: ?*ghostty_vt.PageList, row: RowPin) i32 {
+ const pin = row.pin orelse return row.offset;
+ const alive = pages orelse return 0;
+ if (pin.garbage) return 0;
+ var after: usize = 0;
+ var node = alive.pages.last;
+ while (node) |item| : (node = item.prev) {
+ if (item == pin.node)
+ return @as(i32, @intCast(alive.total_rows - after - item.rows() + pin.y)) +| row.offset;
+ after += item.rows();
+ }
+ return 0;
+}
+
+fn trackPosition(pages: ?*ghostty_vt.PageList, target: *i32, overlay: ?*EditBuffer, failed: *bool) PositionPin {
+ var grid = target.*;
+ if (overlay) |edit| {
+ const lines: i32 = @intCast(modal.lineCount(edit.text));
+ if (grid >= edit.row and grid < edit.row +| lines)
+ return .{ .target = target, .row = .{}, .overlay = edit, .edit_row = grid - edit.row };
+ if (grid > edit.row) grid = grid -| lines +| edit.rows;
+ }
+ return .{ .target = target, .row = trackRow(pages, grid, failed), .overlay = overlay };
+}
+
+fn pointerRowCount(pane: *const Pane) usize {
+ var count: usize = 0;
+ for (pane.sel) |gesture| if (pane.pointerSelection(gesture)) |rows| {
+ count += rows.len;
+ };
+ return count;
+}
+
+/// What an ingest told the positions over it (`ingestWithPositions`): each
+/// tracked row where it is after it (the spans' starts and ends, the
+/// positions, the pointer rows, in that order) and whether the program
+/// erased it, whether the screen was cleared, whether its pages lived and
+/// whether a pin could not be made. Taped: a screen-state replica, which
+/// ingests nothing, is told the authority's.
+pub const Told = struct { rows: []const i32, erased: []const bool, cleared: bool, alive: bool, failed: bool };
+
+fn told(t: Told) Told {
+ return t;
+}
+
+/// `ingest`, with every position kept over the rows (the edit copy, the
+/// cursors and selections, their undo, the pointer's rows) moved as the
+/// rows move. True when one could not be kept (no memory for its pin).
+fn ingestWithPositions(pane: *Pane, bytes: []const u8) bool {
+ const screens = &pane.terminal.?.vt.screens;
+ const key = screens.active_key;
+ const generation = screens.generation(key);
+ const replica = pardes.tape.screenReplica();
+ const pages: ?*ghostty_vt.PageList = if (replica) null else &screens.active.pages;
+ const Group = struct { overlay: ?*EditBuffer, cursor: *i32, selection: *panes.Text.CharSel };
+ var groups: [history_max * 2 + 1]Group = undefined;
+ groups[0] = .{
+ .overlay = if (pane.ovl) |*overlay| overlay else null,
+ .cursor = &pane.body.cur_row,
+ .selection = &pane.body.vsel,
+ };
+ var ngroups: usize = 1;
+ for ([_][]Snapshot{ pane.body.ed_undo[0..pane.body.ed_undo_len], pane.body.ed_redo[0..pane.body.ed_redo_len] }) |history| {
+ for (history) |*snapshot| {
+ groups[ngroups] = .{
+ .overlay = if (snapshot.ovl) |*overlay| overlay else null,
+ .cursor = &snapshot.cur_row,
+ .selection = &snapshot.vsel,
+ };
+ ngroups += 1;
+ }
+ }
+ const Span = struct { overlay: *EditBuffer, start: RowPin, end: RowPin };
+ var spans: [groups.len]Span = undefined;
+ var nspans: usize = 0;
+ var positions: [groups.len * 2 + panes.Text.max_selections * 2 + 4]PositionPin = undefined;
+ var npositions: usize = 0;
+ var failed = false;
+ for (groups[0..ngroups]) |group| {
+ if (group.overlay) |overlay| {
+ spans[nspans] = .{
+ .overlay = overlay,
+ .start = trackRow(pages, overlay.row, &failed),
+ .end = trackRow(pages, overlay.row +| (overlay.rows - 1), &failed),
+ };
+ nspans += 1;
+ }
+ positions[npositions] = trackPosition(pages, group.cursor, group.overlay, &failed);
+ npositions += 1;
+ if (group.selection.active) {
+ positions[npositions] = trackPosition(pages, &group.selection.row, group.overlay, &failed);
+ npositions += 1;
+ }
+ }
+ const overlay = groups[0].overlay;
+ // Where the live pane's own selections sit in `positions`: one whose
+ // row the program erased goes (below), as the edited copy does.
+ const vsel_at: ?usize = if (pane.body.vsel.active) 1 else null;
+ const sels_at = npositions;
+ var extra: [panes.Text.max_selections * 2 + 2]*i32 = undefined;
+ var nextra: usize = 0;
+ for (pane.body.sels[0..pane.body.nsel]) |*selection| {
+ extra[nextra] = &selection.row;
+ extra[nextra + 1] = &selection.arow;
+ nextra += 2;
+ }
+ if (pane.body.last_edit) |*at| {
+ extra[nextra] = &at.row;
+ nextra += 1;
+ }
+ if (pane.look_at) |*at| {
+ extra[nextra] = &at.row;
+ nextra += 1;
+ }
+ for (extra[0..nextra]) |target| {
+ positions[npositions] = trackPosition(pages, target, overlay, &failed);
+ npositions += 1;
+ }
+ const pointer_positions = pane.gpa.alloc(PositionPin, pointerRowCount(pane)) catch null;
+ defer if (pointer_positions) |pins| pane.gpa.free(pins);
+ if (pointer_positions) |pins| {
+ var index: usize = 0;
+ for (pane.sel) |gesture| if (pane.pointerSelection(gesture)) |rows| {
+ for (rows) |*row| {
+ pins[index] = trackPosition(pages, &row.row, if (row.raw_terminal) null else overlay, &failed);
+ index += 1;
+ }
+ };
+ } else failed = true;
+ var cleared = false;
+ var alive: ?*ghostty_vt.PageList = null;
+ if (!replica) {
+ // Whether the program cleared the screen (ED 2, a switch of
+ // screens); pardes reads the flag nowhere else.
+ pane.terminal.?.vt.flags.dirty.clear = false;
+ ingest(pane, bytes);
+ cleared = pane.terminal.?.vt.flags.dirty.clear;
+ // RIS can destroy the alternate screen and every pin it owned.
+ alive = if (screens.generation(key) == generation) pages else null;
+ }
+ const pointers: []PositionPin = pointer_positions orelse &.{};
+ const n = 2 * nspans + npositions + pointers.len;
+ // On the stack, as the local path never allocated here but for the
+ // pointer's rows.
+ var rows_buf: [512]i32 = undefined;
+ var erased_buf: [512]bool = undefined;
+ const rows_after = if (n <= rows_buf.len) rows_buf[0..n] else pane.gpa.alloc(i32, n) catch return true;
+ defer if (n > rows_buf.len) pane.gpa.free(rows_after);
+ const erased_after = if (n <= erased_buf.len) erased_buf[0..n] else pane.gpa.alloc(bool, n) catch return true;
+ defer if (n > erased_buf.len) pane.gpa.free(erased_after);
+ @memset(rows_after, 0);
+ @memset(erased_after, false);
+ if (!replica) {
+ var k: usize = 0;
+ for (spans[0..nspans]) |span| for ([_]RowPin{ span.start, span.end }) |rp| {
+ rows_after[k] = pinnedRow(alive, rp);
+ erased_after[k] = alive != null and rp.pin != null and rp.pin.?.garbage;
+ k += 1;
+ };
+ for ([_][]PositionPin{ positions[0..npositions], pointers }) |batch| for (batch) |position| {
+ rows_after[k] = pinnedRow(alive, position.row);
+ erased_after[k] = alive != null and position.row.pin != null and position.row.pin.?.garbage;
+ k += 1;
+ };
+ }
+ const after = pardes.tape.value(.positions, told, .{Told{ .rows = rows_after, .erased = erased_after, .cleared = cleared, .alive = alive != null, .failed = failed }});
+ if (after.rows.len != n or after.erased.len != n) return false; // a replica its authority's states apart (diverged)
+ failed = after.failed;
+ const at_position = 2 * nspans;
+ const at_pointer = at_position + npositions;
+ var moved = false;
+ var pointer_rows_lost = !after.alive or pointer_positions == null;
+ for (0..pointers.len) |i| if (after.erased[at_pointer + i]) {
+ pointer_rows_lost = true;
+ };
+ // The program cleared the screen, or the rows the live copy stood on are
+ // gone (pruned, a reset): the copy goes with them, as what the program
+ // drew next. Kept, ghostty would move its rows to the top of what is
+ // left, over the program's new text.
+ var copy_lost = after.cleared or !after.alive;
+ for (spans[0..nspans], 0..) |span, i| {
+ if (span.overlay == overlay and after.erased[2 * i]) copy_lost = true;
+ const start = after.rows[2 * i];
+ const rows = @max(1, after.rows[2 * i + 1] -| start +| 1);
+ moved = moved or start != span.overlay.row or rows != span.overlay.rows;
+ span.overlay.row = start;
+ span.overlay.rows = rows;
+ if (alive) |owner| {
+ if (span.start.pin) |pin| owner.untrackPin(pin);
+ if (span.end.pin) |pin| owner.untrackPin(pin);
+ }
+ }
+ // The rule above for the copy holds for the selections: one whose row
+ // is gone (ED 3 erased its history row, which ghostty flags `garbage`)
+ // goes too, rather than being clamped to the top.
+ const erased = after.erased[at_position..];
+ const vsel_lost = if (vsel_at) |i|
+ erased[i] or (copy_lost and positions[i].edit_row != null)
+ else
+ false;
+ var sels_keep: [panes.Text.max_selections]bool = undefined;
+ for (0..pane.body.nsel) |i| sels_keep[i] = !(erased[sels_at + 2 * i] or erased[sels_at + 2 * i + 1]);
+ for ([_][]PositionPin{ positions[0..npositions], pointers }, [_]usize{ at_position, at_pointer }) |batch, first| for (batch, first..) |position, k| {
+ var row = after.rows[k];
+ if (position.overlay) |edit| {
+ if (position.edit_row) |relative| {
+ row = edit.row +| relative;
+ } else if (row > edit.row) {
+ row = if (row < edit.row +| edit.rows)
+ edit.row
+ else
+ row -| edit.rows +| @as(i32, @intCast(modal.lineCount(edit.text)));
+ }
+ }
+ moved = moved or row != position.target.*;
+ position.target.* = row;
+ if (alive) |owner| if (position.row.pin) |pin| owner.untrackPin(pin);
+ };
+ if (pointer_rows_lost) for (0..pane.sel.len) |button| {
+ pane.clearPointerSelection(button);
+ pane.sel[button].state = .none;
+ };
+ if (vsel_lost) {
+ pane.body.vsel.active = false;
+ moved = true;
+ }
+ if (pane.body.nsel > 0) {
+ var kept: u16 = 0;
+ for (0..pane.body.nsel) |i| if (sels_keep[i]) {
+ pane.body.sels[kept] = pane.body.sels[i];
+ kept += 1;
+ };
+ if (kept != pane.body.nsel) {
+ moved = true;
+ if (kept == 0) pane.body.dropSels() else pane.body.nsel = kept;
+ }
+ }
+ if (copy_lost) if (pane.ovl) |copy| {
+ pane.gpa.free(copy.text);
+ pane.ovl = null;
+ moved = true;
+ };
+ if (moved) pane.nsel_snap = 0; // Saved regex-preview offsets name the old flat text.
+ return failed;
+}
+
+/// A full-screen program has the emulator on its alternate screen.
+pub fn onAlternateScreen(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return state.vt.screens.active_key == .alternate;
+}
+
+/// Whether a new terminal's greeting may be typed now: only at the shell's
+/// first prompt (pardes's own marks: no command started; a prompt drawn
+/// again for a resize is the same first prompt), with nothing
+/// typed at it and no program on the alternate screen. Any later moment is `.never`, for good: something has run or
+/// been typed first, and an `ls` then would go into it. A shell pardes
+/// cannot mark has no first prompt to find, and is never greeted.
+pub fn greeting(pane: *const Pane) enum { wait, now, never } {
+ if (pane.fs.unmarked) return .never;
+ // Text typed into the edit buffer that stands in for the prompt row.
+ if (pane.ovl) |o| if (o.text.len > 0) return .never;
+ const state = pane.terminal orelse return .wait;
+ const marks = &state.stream.handler;
+ // (Not `declined`: bash's first prompt comes after a D of its own.)
+ if (marks.started > 0) return .never;
+ // At a prompt's input (ghostty's semantic marks, pardes's or the
+ // shell's own), before any command pardes's marks saw run.
+ if (!promptInputReady(pane)) return .wait;
+ return if (promptInputEmpty(pane)) .now else .never;
+}
+
+/// At a prompt's input: on the alternate screen too, where a program killed
+/// there (htop, `sig KILL`) left the emulator and the shell then drew its
+/// prompt, marks and all. A full-screen program draws no prompt marks.
+pub fn promptInputReady(pane: *const Pane) bool {
+ const state = pane.terminal orelse return false;
+ return state.vt.screens.active.cursor.semantic_content == .input;
+}
+
+pub const CommandOutput = struct {
+ /// Owned by the caller.
+ text: [:0]const u8,
+ /// Whether `text` starts where the command did. It does not when that
+ /// start is not there to read: cut off by `max_rows`, scrolled out of
+ /// the history or erased from it by ED 3 (ghostty flags the pin
+ /// `garbage`; an erased end leaves no text at all), erased under it
+ /// while it ran (`MarkedHandler.lost`), or never pinned (a C or D that
+ /// came on the alternate screen).
+ whole: bool,
+};
+
+/// What the newest finished command printed: the screen text between its
+/// C and D marks, read from at most `max_rows` rows above its end, so a
+/// command that printed the whole history costs no more than its tail.
+/// The shell exited in the middle of a command (its `exit 3`): no end mark
+/// will come, so the command's output ends where the cursor is.
+pub fn endOutputHere(pane: *Pane) void {
+ const state = pane.terminal orelse return;
+ const marks = &state.stream.handler;
+ if (marks.phase == .running and marks.out_end == null) marks.pinCursor(&marks.out_end, true);
+}
+
+pub fn commandOutput(pane: *Pane, gpa: std.mem.Allocator, max_rows: usize) !CommandOutput {
+ // Unless there is text to read, whether the nothing it printed is the
+ // whole of it.
+ const whole = printed: {
+ const state = pane.terminal orelse break :printed true;
+ const marks = &state.stream.handler;
+ const start = marks.out_start orelse break :printed false;
+ const end = marks.out_end orelse break :printed false;
+ const screen = state.vt.screens.get(.primary) orelse break :printed false;
+ if (end.garbage) break :printed false;
+ var whole = !marks.lost and !start.garbage;
+ // Nothing printed: the whole of it.
+ if (start.eql(end.*)) break :printed whole;
+ // D is where the next prompt begins: the output ends a cell before.
+ // An end at the very top, or before the start, is output a redraw
+ // moved (a prompt drawn over it in a window two rows high): how
+ // much is not known, so it is not called whole.
+ const last = end.leftWrap(1) orelse break :printed false;
+ if (last.before(start.*)) break :printed false;
+ var from = start.*;
+ if (last.up(max_rows)) |floor| if (from.before(floor)) {
+ from = floor;
+ from.x = 0;
+ whole = false;
+ };
+ return .{
+ .text = try screen.selectionString(gpa, .{ .sel = ghostty_vt.Selection.init(from, last, false) }),
+ .whole = whole,
+ };
+ };
+ return .{ .text = try gpa.dupeSentinel(u8, "", 0), .whole = whole };
+}
+
+/// At a prompt with nothing typed on its line: no input left of the
+/// cursor and none under it (text typed and then Ctrl-A'd starts at the
+/// cursor). Nothing further right counts: that is where fish draws a
+/// right prompt, and fish suggests nothing on an empty line.
+pub fn promptInputEmpty(pane: *const Pane) bool {
+ if (!promptInputReady(pane)) return false;
+ const cursor = &pane.terminal.?.vt.screens.active.cursor;
+ const row = cursor.page_pin.cells(.all);
+ for (row[0..@min(cursor.x + 1, row.len)]) |cell|
+ if (cell.semantic_content == .input and !cell.isEmpty()) return false;
+ return true;
+}
+
+/// Encode one key for the program that owns a raw terminal and queue its pty
+/// write, respecting the application's keyboard protocol and terminal modes.
+pub fn forwardKey(p: *Pardes, id: usize, key: Key) void {
+ const pane = p.panes[id] orelse return;
+ const state = pane.terminal orelse return;
+ const input = ghostty_vt.input;
+ const function_keys = comptime keys: {
+ var keys: [Key.f25 - Key.f1 + 1]input.Key = undefined;
+ for (&keys, 1..) |*k, n| k.* = @field(input.Key, std.fmt.comptimePrint("f{d}", .{n}));
+ break :keys keys;
+ };
+ const physical: input.Key = switch (key.cp) {
+ Key.enter => .enter,
+ Key.backspace => .backspace,
+ Key.tab => .tab,
+ Key.escape => .escape,
+ Key.up => .arrow_up,
+ Key.down => .arrow_down,
+ Key.left => .arrow_left,
+ Key.right => .arrow_right,
+ Key.home => .home,
+ Key.end => .end,
+ Key.page_up => .page_up,
+ Key.page_down => .page_down,
+ Key.delete => .delete,
+ Key.insert => .insert,
+ Key.print_screen => .print_screen,
+ Key.scroll_lock => .scroll_lock,
+ Key.pause => .pause,
+ Key.menu => .context_menu,
+ Key.f1...Key.f25 => function_keys[key.cp - Key.f1],
+ else => if (key.cp < 128) input.Key.fromASCII(@intCast(key.cp)) orelse .unidentified else .unidentified,
+ };
+ var utf8: [4]u8 = undefined;
+ const text_cp = if (key.shift and key.cp >= 'a' and key.cp <= 'z') key.cp - 'a' + 'A' else key.cp;
+ // A key with no text of its own types its code point only when that
+ // is a character: the kitty keyboard protocol numbers function and
+ // modifier keys in the private use area (F3 is U+E016), and a shell
+ // was typed those as junk.
+ const text = if (key.text.len > 0) key.text else if (key.cp >= 32 and key.cp < Key.up and key.cp != Key.backspace and !(key.cp >= 0xE000 and key.cp <= 0xF8FF))
+ utf8[0 .. std.unicode.utf8Encode(text_cp, &utf8) catch return]
+ else
+ "";
+ // A key's text has no bound of its own (an input method's commit, a
+ // paste as one key): past the stack's room the encoding grows on the
+ // heap, and emitWrite cuts it into writes.
+ var room: [256]u8 = undefined;
+ var first: std.heap.BufferFirstAllocator = .init(&room, p.gpa);
+ var out: std.Io.Writer.Allocating = .init(first.allocator());
+ defer out.deinit();
+ input.encodeKey(&out.writer, .{
+ .key = physical,
+ .mods = .{ .ctrl = key.ctrl, .alt = key.alt, .shift = key.shift },
+ .consumed_mods = .{ .shift = key.text.len > 0 and key.shift },
+ .utf8 = text,
+ .unshifted_codepoint = if (key.cp >= 'A' and key.cp <= 'Z') key.cp - 'A' + 'a' else if (key.cp < Key.up) key.cp else 0,
+ }, options: {
+ var opts = input.KeyEncodeOptions.fromTerminal(&state.vt);
+ // fromTerminal cannot know this one and says so, defaulting to
+ // "option is not alt" — right for an app that lets macOS do the
+ // unicode translation and hands the encoder the composed text.
+ // Every pardes shell resolves the modifier itself and hands the
+ // core the BASE key with the alt bit and no text at all (see
+ // PardesView.keyDown, and app.mjs doing the same with the same
+ // two bits), so by the time this runs alt already means alt.
+ // Left at the default, a macOS build drops the ESC prefix on
+ // the floor and forwards Alt-n to the child as a bare `n`.
+ opts.macos_option_as_alt = .true;
+ break :options opts;
+ }) catch |err| return p.reportError(id, "key", err);
+ if (out.written().len > 0) p.emitWrite(id, out.written());
+}
+
+pub fn enterTty(p: *Pardes, id: usize) void {
+ const pane = p.panes[id] orelse return;
+ const selected = pane.rawPointerText(pane.sel[@backingInt(config.select_button)]) != null;
+ if (!selected and pane.terminal != null and pane.body.cur_pinned and pane.terminal.?.vt.cursorIsAtPrompt()) handoff: {
+ const screen = pane.terminal.?.vt.screens.active;
+ const goff: i32 = @intCast(screen.pages.scrollbar().offset);
+ const vp_row = pane.gridRow(pane.body.cur_row) - goff;
+ if (vp_row < 0) break :handoff;
+
+ var grid_col: i32 = @max(0, pane.body.cur_col);
+ if (screen.pages.pin(.{ .viewport = .{ .x = 0, .y = @intCast(vp_row) } })) |row_pin| {
+ if (row_pin.rowAndCell().row.semantic_prompt != .none) switch (promptCut(row_pin)) {
+ .cut => |cols| grid_col += @intCast(cols),
+ .keep, .blank => {},
+ };
+ }
+ const click_pin = screen.pages.pin(.{
+ .viewport = .{ .x = @intCast(grid_col), .y = @intCast(vp_row) },
+ }) orelse break :handoff;
+ const cursor_pin = screen.cursor.page_pin.*;
+ var prompts = cursor_pin.promptIterator(.left_up, null);
+ const prompt_pin = prompts.next() orelse break :handoff;
+ if (click_pin.before(prompt_pin)) break :handoff;
+ const moves = screen.promptClickMove(click_pin);
+ for (0..moves.left) |_| p.emitWrite(id, "\x1b[D");
+ for (0..moves.right) |_| p.emitWrite(id, "\x1b[C");
+ }
+
+ pane.body.mode = .tty;
+ followOutput(pane); // entering raw mode is a request for the live shell
+ pane.body.vsel.active = false;
+ pane.body.nsel = 0;
+ // The raw renderer follows the live cursor. A captured mouse selection
+ // keeps its modal endpoint for the next return to editor mode.
+ pane.body.cur_pinned = selected;
+ pane.body.select = false;
+ pane.body.restore_cursor = false;
+ pane.body.sticky_col = -1;
+ pane.body.normal.clear();
+}
+
+// Returned slices remain valid until the next cache rebuild or reset.
+pub const RowsCache = struct {
+ /// whose grid this describes; null = the slot is free
+ pane: ?*const Pane = null,
+ /// the rows joined by '\n' — `flatSurface` hands this back verbatim
+ /// instead of rebuilding the join on every keystroke
+ text: []const u8 = &.{},
+ /// slices INTO `text`, absolute grid rows from 0
+ rows: [][]const u8 = &.{},
+ /// `text` is a prefix of this: blanking a prompt row shortens the join,
+ /// and the slack is not worth a second allocation to reclaim
+ text_alloc: []u8 = &.{},
+ stale: bool = false,
+
+ pub fn reset(c: *RowsCache, gpa: std.mem.Allocator) void {
+ if (c.text_alloc.len > 0) gpa.free(c.text_alloc);
+ if (c.rows.len > 0) gpa.free(c.rows);
+ c.* = .{};
+ }
+
+ /// Free a stale entry. Called at the top of `update`, and nowhere else.
+ pub fn sweep(c: *RowsCache, gpa: std.mem.Allocator) void {
+ if (c.stale) c.reset(gpa);
+ }
+
+ /// `pane`'s grid moved: the entry no longer describes it.
+ pub fn markStale(c: *RowsCache, pane: *const Pane) void {
+ if (c.pane == pane) c.stale = true;
+ }
+
+ pub fn dropPane(c: *RowsCache, pane: *const Pane) void {
+ if (c.pane != pane) return;
+ c.pane = null;
+ c.stale = true;
+ }
+};
+
+const Rows = struct {
+ text_alloc: []u8,
+ text: []const u8,
+ rows: [][]const u8,
+};
+
+const empty_grid = [1][]const u8{""};
+
+/// What LEAVING raw tty mode does to one prompt row, decided from its cells
+/// alone: OSC 133 prompt cells are hidden in normal mode, what was typed at
+/// them stays.
+const PromptCut = union(enum) {
+ /// show the row exactly as ghostty dumped it
+ keep,
+ /// show nothing at all
+ blank,
+ /// drop this many leading COLUMNS — the prompt — and keep the rest, which
+ /// is what was typed at it
+ cut: usize,
+};
+
+fn promptCut(pin: ghostty_vt.Pin) PromptCut {
+ const cells = pin.cells(.all);
+ var cols: usize = 0;
+ while (cols < cells.len and cells[cols].semantic_content == .prompt) cols += 1;
+ // Flagged, but with no prompt cells at the FRONT: a right-side prompt, or
+ // a repaint that has moved on. Nothing here is the prompt, so hide nothing.
+ if (cols == 0) return .keep;
+ // ...and all prompt, nothing typed yet: the row is chrome end to end.
+ if (cols >= cells.len) return .blank;
+ return .{ .cut = cols };
+}
+
+pub fn promptPrefixBytes(pane: *Pane, row: i32, raw: []const u8) usize {
+ if (row < 0) return 0;
+ const state = pane.terminal orelse return 0;
+ const pin = state.vt.screens.active.pages.pin(.{ .screen = .{ .x = 0, .y = @intCast(row) } }) orelse return 0;
+ if (pin.rowAndCell().row.semantic_prompt == .none) return 0;
+ return switch (promptCut(pin)) {
+ .keep => 0,
+ .blank => raw.len,
+ .cut => |cols| @min(raw.len, File.rawAtDisplay(raw, cols)),
+ };
+}
+
+fn promptRow(pin: ghostty_vt.Pin, raw: []const u8) []const u8 {
+ const cols = switch (promptCut(pin)) {
+ .keep => return raw,
+ .blank => return "",
+ .cut => |n| n,
+ };
+ const cells = pin.cells(.all);
+ var at: usize = 0;
+ var col: usize = 0;
+ while (col < cols and at < raw.len) {
+ const cell = &cells[col];
+ at = @min(raw.len, at + dumpedBytes(pin, cell));
+ // the tail cell of a wide glyph spells nothing of its own
+ col += if (cell.wide == .wide) @as(usize, 2) else 1;
+ }
+ return std.mem.trimEnd(u8, raw[at..], " \t");
+}
+
+fn dumpedBytes(pin: ghostty_vt.Pin, cell: *const ghostty_vt.Cell) usize {
+ switch (cell.wide) {
+ .spacer_head, .spacer_tail => return 0,
+ .narrow, .wide => {},
+ }
+ var n: usize = switch (cell.content_tag) {
+ .codepoint, .codepoint_grapheme => std.unicode.utf8CodepointSequenceLength(
+ cell.codepoint(),
+ ) catch 1,
+ // A cell carrying only a colour still spells one blank in the dump.
+ else => 1,
+ };
+ if (cell.content_tag == .codepoint_grapheme) {
+ if (pin.grapheme(cell)) |extra| for (extra) |cp| {
+ n += std.unicode.utf8CodepointSequenceLength(cp) catch 1;
+ };
+ }
+ return n;
+}
+
+pub fn shellRows(p: *Pardes, pane: *Pane) ![]const []const u8 {
+ if (pane.terminal == null) return &empty_grid;
+ pardes.tape.touchTerminal();
+ const c = &p.shell_rows;
+ if (!c.stale and c.pane == pane) {
+ // A step's read whether the rows are kept or made: a client that
+ // came since holds them as holes, and is sent them (Screens.fill).
+ if (!drawing) pane.terminal.?.read = true;
+ return c.rows;
+ }
+ // Another pane's rows, or a dropped pane's still waiting for the step's
+ // sweep (dropPane keeps them, as they may still be borrowed): this
+ // step's rows are scratch, and nothing in the slot is written over.
+ if (c.pane != null or c.text_alloc.len > 0 or c.rows.len > 0) {
+ c.stale = true;
+ return (try buildRows(p.scratch.allocator(), p, pane)).rows;
+ }
+ const built = try buildRows(p.gpa, p, pane);
+ c.* = .{
+ .pane = pane,
+ .text = built.text,
+ .rows = built.rows,
+ .text_alloc = built.text_alloc,
+ };
+ return c.rows;
+}
+
+/// The full modal motion surface: shell history with the live edit overlay
+/// spliced into the rows it covers.
+pub fn cursorLines(p: *Pardes, pane: *Pane) ![]const []const u8 {
+ const rows = try shellRows(p, pane);
+ if (pane.ovl == null) return rows;
+ var last = rows.len;
+ if (pane.ovl) |overlay|
+ last = @max(last, @as(usize, @intCast(@max(0, overlay.row + overlay.rows))));
+ var count = last;
+ if (pane.ovl) |overlay| {
+ if (overlay.row >= 0 and @as(usize, @intCast(overlay.row)) < last)
+ count = count - @min(
+ @as(usize, @intCast(overlay.rows)),
+ last - @as(usize, @intCast(overlay.row)),
+ ) + @max(1, modal.lineCount(overlay.text));
+ }
+ const lines = try p.scratch.allocator().alloc([]const u8, count);
+ var n: usize = 0;
+ var grid_row: usize = 0;
+ while (grid_row < last) : (grid_row += 1) {
+ if (pane.ovl) |overlay| if (overlay.row >= 0 and grid_row == @as(usize, @intCast(overlay.row))) {
+ var overlay_lines = std.mem.splitScalar(u8, overlay.text, '\n');
+ while (overlay_lines.next()) |line| : (n += 1) lines[n] = line;
+ grid_row += @intCast(overlay.rows - 1);
+ continue;
+ };
+ lines[n] = if (grid_row < rows.len) rows[grid_row] else "";
+ n += 1;
+ }
+ return lines[0..n];
+}
+
+/// Flatten `cursorLines` without rebuilding the common cached/no-overlay
+/// case. Scratch-owned when a join is required.
+pub fn flatSurface(p: *Pardes, pane: *Pane, lines: []const []const u8) ![]const u8 {
+ const cache = &p.shell_rows;
+ if (!cache.stale and cache.pane == pane and
+ lines.ptr == cache.rows.ptr and lines.len == cache.rows.len) return cache.text;
+ var total: usize = if (lines.len > 0) lines.len - 1 else 0;
+ for (lines) |line| total += line.len;
+ const text = try p.scratch.allocator().alloc(u8, total);
+ var at: usize = 0;
+ for (lines, 0..) |line, i| {
+ if (i > 0) {
+ text[at] = '\n';
+ at += 1;
+ }
+ @memcpy(text[at..][0..line.len], line);
+ at += line.len;
+ }
+ return text;
+}
+
+/// Materialize or extend the terminal edit overlay with one exact allocation.
+/// Row slices are scratch-owned/borrowed; only the joined text is installed.
+pub fn editText(p: *Pardes, pane: *Pane, lo: i32, hi: i32, col: i32) error{ OutOfMemory, WriteFailed, UnknownPoint }!?EditText {
+ const want_lo = @max(0, @min(lo, hi));
+ const want_hi = @max(want_lo, @max(lo, hi));
+ const fresh = pane.ovl == null;
+ const old: EditBuffer = pane.ovl orelse .{ .row = want_lo, .rows = 1, .text = &.{} };
+ const lines: i32 = if (fresh) 1 else @intCast(modal.lineCount(old.text));
+ const up = old.row - want_lo;
+ const down = want_hi - (old.row + lines - 1);
+ const extending = fresh or up > 0 or down > 0;
+ var row0 = old.row;
+ var covered = old.rows;
+ var text = old.text;
+ var owned = false;
+ if (extending) {
+ const rows = try shellRows(p, pane);
+ row0 = old.row - @max(0, up);
+ covered = old.rows + @max(0, up) + @max(0, down);
+ const up_len: usize = @intCast(@max(0, up));
+ const down_len: usize = @intCast(@max(0, down));
+ const parts = try p.scratch.allocator().alloc([]const u8, up_len + 1 + down_len);
+ for (parts[0..up_len], 0..) |*part, i| {
+ const src = @as(usize, @intCast(row0)) + i;
+ part.* = if (src < rows.len) rows[src] else "";
+ }
+ const middle: usize = @intCast(old.row);
+ parts[up_len] = if (fresh)
+ (if (middle < rows.len) rows[middle] else "")
+ else
+ old.text;
+ for (parts[up_len + 1 ..], 0..) |*part, i| {
+ const src = @as(usize, @intCast(old.row + old.rows)) + i;
+ part.* = if (src < rows.len) rows[src] else "";
+ }
+ text = try std.mem.join(p.gpa, "\n", parts);
+ owned = true;
+ }
+
+ const row: usize = @intCast(@max(0, want_lo - row0));
+ const line_len: i32 = @intCast(modal.lineSlice(text, row).len);
+ if (col > line_len) {
+ const spaces = p.scratch.allocator().alloc(u8, @intCast(col - line_len)) catch {
+ if (owned) p.gpa.free(text);
+ return null;
+ };
+ @memset(spaces, ' ');
+ const padded = modal.insertAt(p.gpa, text, .{ .row = row, .col = @intCast(line_len) }, spaces) catch {
+ if (owned) p.gpa.free(text);
+ return null;
+ };
+ if (owned) p.gpa.free(text);
+ text = padded;
+ owned = true;
+ }
+ if (owned) {
+ if (pane.ovl) |overlay| p.gpa.free(overlay.text);
+ pane.ovl = .{ .row = row0, .rows = covered, .text = text };
+ }
+ // A terminal's text is its program's: edited here it is a copy, to run
+ // with Tab or B2, gone when the program draws again. Said at its first
+ // edit, so it never looks like an edit that was lost.
+ if (fresh) for (p.panes, 0..) |slot, id| if (slot == pane)
+ p.setMessage(id, "a copy of the terminal's text: Tab or B2 runs it; what the program draws next replaces it (Ctrl-b types to the program)");
+ return .{ .text = pane.ovl.?.text, .row0 = pane.ovl.?.row };
+}
+
+/// Consume a rewritten overlay, freeing the terminal edit text it replaces.
+pub fn setEditText(p: *Pardes, pane: *Pane, new: []u8) void {
+ const overlay = if (pane.ovl) |*value| value else return pardes.edit.retireEditText(p, new);
+ for (0..pane.sel.len) |button| {
+ pane.clearPointerSelection(button);
+ pane.sel[button].state = .none;
+ }
+ p.gpa.free(overlay.text);
+ overlay.text = new;
+}
+
+/// Set while a frame is drawn: what it reads is no step's.
+pub var drawing = false;
+
+fn buildRows(alloc: std.mem.Allocator, p: *Pardes, pane: *Pane) !Rows {
+ if (!drawing) pane.terminal.?.read = true;
+ const full = try pane.terminal.?.vt.screens.active.dumpStringAlloc(p.scratch.allocator(), .{ .screen = .{} });
+ var pit = pane.terminal.?.vt.screens.active.pages.rowIterator(.right_down, .{ .screen = .{} }, null);
+ // split yields one more item than delimiters; the extra final slot is the
+ // cursor row retained below.
+ const n_rows = std.mem.count(u8, full, "\n") + 2;
+ const rows = try alloc.alloc([]const u8, n_rows);
+ errdefer alloc.free(rows);
+ // Blanking a prompt row only ever SHORTENS it and the retained cursor row
+ // adds one separator, so the dump's length plus one bounds the join.
+ const text = try alloc.alloc(u8, full.len + 1);
+ errdefer alloc.free(text);
+ var at: usize = 0;
+ var n: usize = 0;
+ var it = std.mem.splitScalar(u8, full, '\n');
+ while (it.next()) |raw| {
+ const shown = if (pit.next()) |pin|
+ if (pin.rowAndCell().row.semantic_prompt != .none) promptRow(pin, raw) else raw
+ else
+ raw;
+ if (n > 0) {
+ text[at] = '\n';
+ at += 1;
+ }
+ @memcpy(text[at..][0..shown.len], shown);
+ rows[n] = text[at..][0..shown.len];
+ at += shown.len;
+ n += 1;
+ }
+ text[at] = '\n';
+ at += 1;
+ rows[n] = text[at..][0..0];
+ n += 1;
+ std.debug.assert(n == n_rows);
+ return .{ .text_alloc = text, .text = text[0..at], .rows = rows };
+}
+
+pub fn bodyText(arena: std.mem.Allocator, pane: *Pane) ![]const u8 {
+ const vp: []const []const u8 = vp: {
+ const state = pane.terminal orelse break :vp &.{};
+ const screen = state.vt.screens.active;
+ var tl = screen.pages.getTopLeft(.viewport);
+ tl.x = 0;
+ const br = screen.pages.getBottomRight(.viewport) orelse return error.UnknownPoint;
+ var rows_out: std.Io.Writer.Allocating = .init(arena);
+ try screen.dumpString(&rows_out.writer, .{ .tl = tl, .br = br, .unwrap = false });
+ const raw = try rows_out.toOwnedSlice();
+ var prompts = screen.pages.rowIterator(.right_down, .{ .viewport = .{} }, null);
+ const vp = try arena.alloc([]const u8, std.mem.count(u8, raw, "\n") + 1);
+ var lines = std.mem.splitScalar(u8, raw, '\n');
+ var n: usize = 0;
+ while (lines.next()) |ln| {
+ vp[n] = if (pane.body.mode != .tty)
+ if (prompts.next()) |pin|
+ if (pin.rowAndCell().row.semantic_prompt != .none) promptRow(pin, ln) else ln
+ else
+ ln
+ else
+ ln;
+ n += 1;
+ }
+ std.debug.assert(n == vp.len);
+ break :vp vp;
+ };
+
+ const len = fillBody(null, pane, vp);
+ const out = try arena.alloc(u8, len);
+ const filled = fillBody(out, pane, vp);
+ std.debug.assert(filled == out.len);
+ return out;
+}
+
+pub const BodyRow = union(enum) {
+ grid: i32,
+ edit: struct { line: []const u8, idx: usize },
+};
+
+const BodyWalk = struct {
+ pane: *Pane,
+ goff: i32,
+ g: i32,
+ /// the buffer can start above the viewport: drop the lines scrolled past
+ skip: usize,
+ n: usize = 0,
+ lines: ?std.mem.SplitIterator(u8, .scalar) = null,
+ covered: i32 = 0,
+ line_idx: usize = 0,
+
+ fn init(pane: *Pane) BodyWalk {
+ const off = pane.scroll();
+ const goff = gridOffset(pane);
+ return .{
+ .pane = pane,
+ .goff = goff,
+ .g = if (pane.body.mode == .tty) goff + pane.pan else pane.gridRow(off),
+ .skip = if (pane.ovl) |o| @intCast(@max(0, off - pane.surfRow(o.row))) else 0,
+ };
+ }
+
+ fn next(w: *BodyWalk) ?BodyRow {
+ while (w.n < w.pane.rows) {
+ if (w.lines) |*it| {
+ if (it.next()) |line| {
+ const idx = w.line_idx;
+ w.line_idx += 1;
+ // Lines scrolled off the top still count: the index names a
+ // line of the BUFFER, not of the visible body.
+ if (w.skip > 0) {
+ w.skip -= 1;
+ continue;
+ }
+ w.n += 1;
+ return .{ .edit = .{ .line = line, .idx = idx } };
+ }
+ // The buffer stands in for `rows` shell rows however many lines
+ // it actually spelled, which is the whole slide.
+ w.g += w.covered;
+ w.skip = 0;
+ w.lines = null;
+ continue;
+ }
+ if (w.pane.body.mode != .tty) if (w.pane.ovl) |o| if (w.g == o.row) {
+ w.lines = std.mem.splitScalar(u8, o.text, '\n');
+ w.covered = o.rows;
+ w.line_idx = 0;
+ continue;
+ };
+ const vi = w.g - w.goff;
+ w.g += 1;
+ w.n += 1;
+ return .{ .grid = vi };
+ }
+ return null;
+ }
+};
+
+/// Run the terminal body row walk. A null destination counts bytes; a slice
+/// fills the exact allocation made from that count.
+fn fillBody(dst: ?[]u8, pane: *Pane, viewport: []const []const u8) usize {
+ var walk: BodyWalk = .init(pane);
+ var written: usize = 0;
+ var first = true;
+ while (walk.next()) |row| {
+ if (!first) {
+ if (dst) |out| out[written] = '\n';
+ written += 1;
+ }
+ first = false;
+ const bytes = switch (row) {
+ .edit => |e| e.line,
+ .grid => |vi| if (vi >= 0 and @as(usize, @intCast(vi)) < viewport.len)
+ viewport[@intCast(vi)]
+ else
+ "",
+ };
+ if (dst) |out| @memcpy(out[written..][0..bytes.len], bytes);
+ written += bytes.len;
+ }
+ return written;
+}
+
+// Match surviving edit-buffer rows to their original terminal styles.
+const EditAnchors = struct {
+ /// the buffer's own text, walked in order: a line the VIEWPORT skipped still
+ /// consumes the row it came from, so the lines below it stay aligned
+ text: []const u8 = &.{},
+ at: usize = 0,
+ shell: []const []const u8 = &.{},
+ /// the covered span, absolute grid rows, as `[first, end)`
+ first: usize = 0,
+ end: usize = 0,
+ lines: usize = 0,
+ /// the line `at` names, and the first row still unclaimed
+ idx: usize = 0,
+ cursor: usize = 0,
+ budget: usize = 0,
+ active: bool = false,
+
+ fn init(p: *Pardes, pane: *Pane, o: EditBuffer) EditAnchors {
+ if (o.rows <= 0 or o.row < 0) return .{};
+ const first: usize = @intCast(o.row);
+ const screen = pane.terminal.?.vt.screens.active;
+ const total = screen.pages.scrollbar().total;
+ if (first >= total) return .{};
+ const covered: usize = @intCast(o.rows);
+ const count = @min(covered, total - first);
+ const tl = screen.pages.pin(.{ .screen = .{ .y = @intCast(first) } }) orelse return .{};
+ const br = screen.pages.pin(.{ .screen = .{
+ .x = screen.pages.cols - 1,
+ .y = @intCast(first + count - 1),
+ } }) orelse return .{};
+ const arena = p.scratch.allocator();
+ var output: std.Io.Writer.Allocating = .init(arena);
+ screen.dumpString(&output.writer, .{ .tl = tl, .br = br, .unwrap = false }) catch return .{};
+ const shell = arena.alloc([]const u8, count) catch return .{};
+ var raw = std.mem.splitScalar(u8, output.written(), '\n');
+ var pins = tl.rowIterator(.right_down, br);
+ for (shell) |*row| {
+ const text = raw.next() orelse "";
+ row.* = if (pins.next()) |pin|
+ if (pin.rowAndCell().row.semantic_prompt != .none) promptRow(pin, text) else text
+ else
+ text;
+ }
+ const lines = std.mem.count(u8, o.text, "\n") + 1;
+ return .{
+ .text = o.text,
+ .shell = shell,
+ .first = first,
+ .end = first + count,
+ .lines = lines,
+ .cursor = first,
+ .budget = covered + 4 * lines,
+ .active = true,
+ };
+ }
+
+ fn shellRow(a: *EditAnchors, idx: usize) ?Anchor {
+ if (!a.active or idx >= a.lines) return null;
+ var found: ?Anchor = null;
+ while (a.idx <= idx) : (a.idx += 1) found = a.claim(a.nextLine() orelse return null);
+ return found;
+ }
+
+ fn nextLine(a: *EditAnchors) ?[]const u8 {
+ if (a.at > a.text.len) return null;
+ const rest = a.text[a.at..];
+ if (std.mem.indexOfScalar(u8, rest, '\n')) |n| {
+ a.at += n + 1;
+ return rest[0..n];
+ }
+ // The last line has no terminator; one past the end ends the walk.
+ a.at = a.text.len + 1;
+ return rest;
+ }
+
+ /// Where this line still stands over the grid, if anywhere.
+ fn claim(a: *EditAnchors, line: []const u8) ?Anchor {
+ const end = if (line.len == 0) @min(a.cursor + 1, a.end) else a.end;
+ var k = a.cursor;
+ while (k < end) : (k += 1) {
+ if (a.budget == 0) return null;
+ a.budget -= 1;
+ if (!std.mem.eql(u8, line, a.shell[k - a.first])) continue;
+ a.cursor = k + 1;
+ return .{ .row = @intCast(k) };
+ }
+ if (a.cursor >= a.end) return null;
+ const shell = a.shell[a.cursor - a.first];
+ var p: usize = 0;
+ while (p < line.len and p < shell.len and line[p] == shell[p]) p += 1;
+ var s: usize = 0;
+ const room = @min(line.len, shell.len) - p;
+ while (s < room and line[line.len - 1 - s] == shell[shell.len - 1 - s]) s += 1;
+ if (p + s == 0) return null;
+ if (line.len != p + s and shell.len - (p + s) > shell.len / 2) return null;
+ const row = a.cursor;
+ if (s > 0 or p >= shell.len) a.cursor += 1;
+ return .{ .row = @intCast(row), .prefix = p, .suffix = s, .shell_len = shell.len };
+ }
+};
+
+const Anchor = struct {
+ /// the row, absolute while it comes from `EditAnchors`, viewport once
+ /// `recolorAnsi` has subtracted the walk's offset
+ row: i32,
+ prefix: usize = std.math.maxInt(usize),
+ suffix: usize = 0,
+ /// the row's own dumped length — what the suffix is measured from on the
+ /// GRID side, where the edit may have changed the byte count
+ shell_len: usize = 0,
+
+ fn whole(an: Anchor) bool {
+ return an.prefix == std.math.maxInt(usize);
+ }
+};
+
+pub fn recolorAnsi(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, body: []const u8) void {
+ // No emulator, no ANSI cells: the whole pass — and the 256-colour theme
+ // projection behind it — is compiled out.
+ if (pane.terminal == null) return;
+ const body_y = p.bodyTop(pane, r);
+ var filtered_storage: FilteredColors = undefined;
+ const filtered: ?*FilteredColors = if (pane.tty_filter) blk: {
+ const tz_filter = tracy.zone(@src(), "filterInit");
+ defer tz_filter.end();
+ filtered_storage = FilteredColors.init(p, &pane.terminal.?.vt);
+ break :blk &filtered_storage;
+ } else null;
+ // DECSCNM, read once: the filtered palette folds it in itself, the raw
+ // path needs it per cell.
+ const scnm = pane.terminal.?.vt.modes.get(.reverse_colors);
+ const pages = &pane.terminal.?.vt.screens.active.pages;
+ const vp_rows: i32 = @intCast(scrollbar(pane).len);
+ // Which buffer lines the user has not actually changed, so a row swallowed
+ // by a growing buffer keeps the colour it still stands over.
+ var anchors: ?EditAnchors = null;
+ var walk: BodyWalk = .init(pane);
+ var lines = std.mem.splitScalar(u8, body, '\n');
+ var vr: u16 = 0;
+ while (walk.next()) |row| : (vr += 1) {
+ if (vr >= body_h) break;
+ // Before any early exit below, or the lines fall out of step with rows.
+ const text = lines.next() orelse "";
+ const anchor: Anchor = switch (row) {
+ .edit => |e| blk: {
+ if (anchors == null) anchors = .init(p, pane, pane.ovl.?);
+ var an = anchors.?.shellRow(e.idx) orelse continue;
+ an.row -= walk.goff;
+ break :blk an;
+ },
+ .grid => |v| .{ .row = v },
+ };
+ const vi = anchor.row;
+ if (vi < 0 or vi >= vp_rows) continue;
+ const row_pin = pages.pin(.{ .viewport = .{ .y = @intCast(vi) } }) orelse continue;
+ const cut: u16 = if (pane.body.mode == .tty) 0 else cut: {
+ if (row_pin.rowAndCell().row.semantic_prompt == .none) break :cut 0;
+ break :cut switch (promptCut(row_pin)) {
+ .keep => 0,
+ // Blanked end to end: the row shows nothing of the grid, so
+ // projecting the prompt's own colours onto it would be a lie.
+ .blank => continue,
+ .cut => |n| std.math.cast(u16, n) orelse continue,
+ };
+ };
+ if (cut > 0 and text.len == 0) continue;
+ var at: usize = 0;
+ var sc: u16 = 0;
+ var gc: u16 = cut;
+ var sb: usize = 0;
+ const mine_from = @min(anchor.prefix, text.len);
+ const mine_to = text.len - @min(anchor.suffix, text.len);
+ var crossed = false;
+ while (at < text.len and sc < tw) {
+ const stop = modal.nextGrapheme(text, at);
+ if (stop <= at) break;
+ const span: u16 = if (sc + 1 < tw and s.at(tx + sc + 1, body_y + vr).len == 0) 2 else 1;
+ if (at >= mine_from and at < mine_to) {
+ sc += span;
+ at = stop;
+ continue;
+ }
+ if (at >= mine_to and !crossed) {
+ crossed = true;
+ const upto = anchor.shell_len - @min(anchor.suffix, anchor.shell_len);
+ while (sb < upto) {
+ const ci = cellAt(pages, row_pin, gc) orelse break;
+ sb += dumpedBytes(row_pin, ci.cell);
+ gc = std.math.add(u16, gc, 1) catch break;
+ }
+ }
+ const want = stop - at;
+ // Consume every cell that contributed to this grapheme. A cluster
+ // ghostty split across several cells is still ONE printed glyph.
+ var covered: usize = 0;
+ var style: ?pardes.CellStyle = null;
+ while (covered < want) {
+ const ci = cellAt(pages, row_pin, gc) orelse break;
+ if (style == null and ci.cell.wide != .spacer_tail and ci.cell.wide != .spacer_head)
+ style = cellStyle(p, ci, filtered, scnm);
+ covered += dumpedBytes(row_pin, ci.cell);
+ gc = std.math.add(u16, gc, 1) catch break;
+ // A spacer contributes no bytes; without this the loop would
+ // spin on a row that ends in one.
+ if (covered == 0 and gc >= pane.cols) break;
+ }
+ while (cellAt(pages, row_pin, gc)) |t| {
+ if (t.cell.wide != .spacer_tail) break;
+ gc = std.math.add(u16, gc, 1) catch break;
+ }
+ if (style) |st| for (0..span) |k| {
+ const cell = s.at(tx + sc + @as(u16, @intCast(k)), body_y + vr);
+ if (cell.default and filtered == null) continue;
+ cell.default = false;
+ cell.style = st;
+ };
+ sb += covered;
+ sc += span;
+ at = stop;
+ }
+ var tail: ?pardes.CellStyle = null;
+ if (anchor.whole() or anchor.suffix > 0) {
+ while (sc < tw) {
+ const ci = cellAt(pages, row_pin, gc) orelse break;
+ gc = std.math.add(u16, gc, 1) catch break;
+ if (ci.cell.wide == .spacer_tail) continue;
+ const cell = s.at(tx + sc, body_y + vr);
+ sc += 1;
+ const style = cellStyle(p, ci, filtered, scnm);
+ tail = style;
+ if (cell.default and filtered == null) continue;
+ cell.default = false;
+ cell.style = style;
+ }
+ if (tail) |style| while (sc < tw) : (sc += 1) {
+ const cell = s.at(tx + sc, body_y + vr);
+ if (cell.default and filtered == null) continue;
+ cell.default = false;
+ cell.style = style;
+ };
+ }
+ }
+}
+
+/// The cell at column `x` of the row `row` pins, as `pages.getCell` reads
+/// it, without walking from the viewport's top down to the row again: that
+/// walk, once a cell, was most of a terminal's paint (once getCell was no
+/// longer inlined, a frame of a 120x40 shell took 75 µs more).
+fn cellAt(pages: *const ghostty_vt.PageList, row: ghostty_vt.Pin, x: u16) ?ghostty_vt.PageList.Cell {
+ if (x >= pages.cols or x >= row.node.cols()) return null;
+ const rac = row.node.page().getRowAndCell(x, row.y);
+ return .{ .node = row.node, .row = rac.row, .cell = rac.cell, .row_idx = row.y, .col_idx = x };
+}
+
+// A cell's underline styles are SGR's, in SGR's order (`off` its `none`): a
+// cast takes one to the other (cellStyle, pager.zig).
+comptime {
+ for (@typeInfo(@FieldType(pardes.CellStyle, "ul")).@"enum".field_names, 0..) |name, i|
+ if (@backingInt(@field(ghostty_vt.sgr.Attribute.Underline, if (std.mem.eql(u8, name, "off")) "none" else name)) != i) @compileError("a cell's underline styles are not SGR's");
+}
+
+fn cellStyle(p: *Pardes, ci: ghostty_vt.PageList.Cell, filtered: ?*FilteredColors, scnm: bool) pardes.CellStyle {
+ const style = ci.style();
+ var cs: pardes.CellStyle = .{
+ .fg = if (filtered) |colors| colors.fg(style) else ghostColor(p, style.fg_color, scnm),
+ .bg = if (filtered) |colors| colors.bg(style, ci.cell) else ghostColor(p, style.bg_color, !scnm),
+ .bold = style.flags.bold,
+ .dim = style.flags.faint,
+ .italic = style.flags.italic,
+ .blink = style.flags.blink,
+ .reverse = style.flags.inverse,
+ .invisible = style.flags.invisible,
+ .strikethrough = style.flags.strikethrough,
+ .ul = @fromBackingInt(@intCast(@backingInt(style.flags.underline))),
+ };
+ if (filtered == null) switch (ci.cell.content_tag) {
+ .bg_color_palette => cs.bg = palColor(p, ci.cell.content.color_palette.data),
+ .bg_color_rgb => {
+ const rgb = ci.cell.content.color_rgb;
+ cs.bg = .{ .rgb = .{ rgb.r, rgb.g, rgb.b } };
+ },
+ else => {},
+ };
+ return cs;
+}
+
+fn asPardesColor(rgb: GColor.RGB) pardes.Color {
+ return .{ .rgb = .{ rgb.r, rgb.g, rgb.b } };
+}
+
+/// A program's colours mapped to the theme (Filter): a terminal's cells, or
+/// a +Pager's spans (`vt` null, the program's palette xterm's own).
+pub const FilteredColors = struct {
+ source: GColor.Palette,
+ target: *const GColor.Palette,
+ theme_bg: GColor.RGB,
+ theme_fg: GColor.RGB,
+ dynamic_bg: ?GColor.RGB,
+ dynamic_fg: ?GColor.RGB,
+ default_bg: GColor.RGB,
+ /// What a foreground too near `default_bg` becomes instead.
+ fallback_fg: GColor.RGB,
+ default_bg_luminance: f64,
+ fg_for_palette: [256]pardes.Color = undefined,
+ bg_for_palette: [256]pardes.Color = undefined,
+ /// The two answers for a cell that names no colour of its own.
+ fg_default: pardes.Color = undefined,
+ bg_default: pardes.Color = undefined,
+ cache_rgb: [256]GColor.RGB = undefined,
+ cache_key: [256]u8 = undefined,
+ cache_valid: [256]bool = @splat(false),
+
+ pub fn init(p: *Pardes, vt: ?*const ghostty_vt.Terminal) FilteredColors {
+ var source = GColor.default;
+ if (vt) |t| {
+ for (&source, 0..) |*rgb, i|
+ rgb.* = t.colorForXterm(.{ .palette = @intCast(i) }) orelse rgb.*;
+ }
+ const theme = p.theme();
+ var theme_bg = asGhostRgb(theme.bg orelse theme.tag_bg);
+ var theme_fg = asGhostRgb(theme.fg orelse theme.tag_fg);
+ var dynamic_bg = if (vt) |t| t.colorForXterm(.{ .dynamic = .background }) else null;
+ var dynamic_fg = if (vt) |t| t.colorForXterm(.{ .dynamic = .foreground }) else null;
+ if (vt != null and vt.?.modes.get(.reverse_colors)) {
+ std.mem.swap(GColor.RGB, &theme_bg, &theme_fg);
+ std.mem.swap(?GColor.RGB, &dynamic_bg, &dynamic_fg);
+ }
+ var self: FilteredColors = .{
+ .source = source,
+ .target = p.tty_filter_palette.get(theme),
+ .theme_bg = theme_bg,
+ .theme_fg = theme_fg,
+ .dynamic_bg = dynamic_bg,
+ .dynamic_fg = dynamic_fg,
+ .default_bg = theme_bg,
+ .fallback_fg = theme_fg,
+ .default_bg_luminance = luminanceOf(theme_bg),
+ };
+ if (dynamic_bg) |rgb| self.default_bg = self.keyedRgb(rgb);
+ self.default_bg_luminance = luminanceOf(self.default_bg);
+ if (self.theme_bg.contrast(self.default_bg) > self.theme_fg.contrast(self.default_bg))
+ self.fallback_fg = self.theme_bg;
+
+ self.fg_default = asPardesColor(self.legible(
+ if (self.dynamic_fg) |rgb| self.keyedRgb(rgb) else self.theme_fg,
+ ));
+ self.bg_default = asPardesColor(self.default_bg);
+ for (&self.source, 0..) |current, i| {
+ const idx: u8 = @intCast(i);
+ const mapped = self.paletteRgb(idx, current);
+ self.fg_for_palette[idx] = asPardesColor(self.legible(mapped));
+ self.bg_for_palette[idx] = asPardesColor(mapped);
+ }
+ return self;
+ }
+
+ fn fg(self: *FilteredColors, style: ghostty_vt.Style) pardes.Color {
+ return switch (style.fg_color) {
+ .none => self.fg_default,
+ .palette => |idx| self.fg_for_palette[idx],
+ .rgb => asPardesColor(self.legible(self.keyedRgb(style.fg(.{
+ .default = self.dynamic_fg orelse self.theme_fg,
+ .palette = &self.source,
+ .bold = null,
+ })))),
+ };
+ }
+
+ fn bg(self: *FilteredColors, style: ghostty_vt.Style, cell: *const ghostty_vt.Cell) pardes.Color {
+ switch (cell.content_tag) {
+ .bg_color_palette => return self.bg_for_palette[cell.content.color_palette.data],
+ .bg_color_rgb => {},
+ else => switch (style.bg_color) {
+ .none => return self.bg_default,
+ .palette => |idx| return self.bg_for_palette[idx],
+ .rgb => {},
+ },
+ }
+ // Truecolour, from either the cell or its style.
+ return asPardesColor(self.keyedRgb(style.bg(cell, &self.source).?));
+ }
+
+ /// A +Pager span's colour (pager.zig), as `fg` and `bg` map a cell's.
+ pub fn spanColor(self: *FilteredColors, color: pardes.Color, is_bg: bool) pardes.Color {
+ return switch (color) {
+ .default => color,
+ .index => |idx| if (is_bg) self.bg_for_palette[idx] else self.fg_for_palette[idx],
+ .rgb => |rgb| blk: {
+ const keyed = self.keyedRgb(asGhostRgb(rgb));
+ break :blk asPardesColor(if (is_bg) keyed else self.legible(keyed));
+ },
+ };
+ }
+
+ fn legible(self: *const FilteredColors, rgb: GColor.RGB) GColor.RGB {
+ if (contrastOf(luminanceOf(rgb), self.default_bg_luminance) >=
+ config.tty_filter_min_contrast) return rgb;
+ return self.fallback_fg;
+ }
+
+ fn paletteRgb(self: *FilteredColors, idx: u8, current: GColor.RGB) GColor.RGB {
+ if (current.eql(GColor.default[idx])) return self.target[idx];
+ return self.keyedRgb(current);
+ }
+
+ fn keyedRgb(self: *FilteredColors, rgb: GColor.RGB) GColor.RGB {
+ return self.target[self.nearestKey(rgb)];
+ }
+
+ fn nearestKey(self: *FilteredColors, rgb: GColor.RGB) u8 {
+ const rgb24 = (@as(u32, rgb.r) << 16) | (@as(u32, rgb.g) << 8) | rgb.b;
+ const slot: u8 = @truncate((rgb24 *% 0x9e3779b1) >> 24);
+ if (self.cache_valid[slot] and self.cache_rgb[slot].eql(rgb))
+ return self.cache_key[slot];
+
+ var best: u8 = 0;
+ var best_distance: u32 = std.math.maxInt(u32);
+ for (GColor.default, 0..) |candidate, i| {
+ const distance = colorDistance(rgb, candidate);
+ // Strict comparison makes duplicate-colour ties stable at the
+ // lowest canonical xterm key.
+ if (distance < best_distance) {
+ best_distance = distance;
+ best = @intCast(i);
+ }
+ }
+ self.cache_rgb[slot] = rgb;
+ self.cache_key[slot] = best;
+ self.cache_valid[slot] = true;
+ return best;
+ }
+};
+
+const channel_luminance: [256]f64 = blk: {
+ @setEvalBranchQuota(20000);
+ var table: [256]f64 = undefined;
+ for (&table, 0..) |*slot, c| {
+ const normalized: f64 = @as(f64, @floatFromInt(c)) / 255;
+ slot.* = if (normalized <= 0.03928)
+ normalized / 12.92
+ else
+ std.math.pow(f64, (normalized + 0.055) / 1.055, 2.4);
+ }
+ break :blk table;
+};
+
+fn luminanceOf(rgb: GColor.RGB) f64 {
+ return 0.2126 * channel_luminance[rgb.r] +
+ 0.7152 * channel_luminance[rgb.g] +
+ 0.0722 * channel_luminance[rgb.b];
+}
+
+/// ghostty's `RGB.contrast` with both luminances already in hand.
+fn contrastOf(a_luminance: f64, b_luminance: f64) f64 {
+ const lighter = @max(a_luminance, b_luminance);
+ const darker = @min(a_luminance, b_luminance);
+ return (lighter + 0.05) / (darker + 0.05);
+}
+
+fn colorDistance(a: GColor.RGB, b: GColor.RGB) u32 {
+ const dr = @as(i32, a.r) - @as(i32, b.r);
+ const dg = @as(i32, a.g) - @as(i32, b.g);
+ const db = @as(i32, a.b) - @as(i32, b.b);
+ return @intCast(dr * dr + dg * dg + db * db);
+}
+
+pub fn palColor(p: *Pardes, idx: u8) pardes.Color {
+ if (p.theme().palette) |pal| if (idx < 16) return .{ .rgb = pal[idx] };
+ return .{ .index = idx };
+}
+
+fn ghostColor(p: *Pardes, color: ghostty_vt.Style.Color, is_bg: bool) pardes.Color {
+ return switch (color) {
+ .none => blk: {
+ const t = if (is_bg) p.theme().bg else p.theme().fg;
+ break :blk if (t) |c| .{ .rgb = c } else .default;
+ },
+ .palette => |idx| palColor(p, idx),
+ .rgb => |rgb| .{ .rgb = .{ rgb.r, rgb.g, rgb.b } },
+ };
+}
+
+/// executing at a prompt with typed text below it: pad the output area
+/// with newlines so the command's output doesn't overwrite the buffer
+pub fn padOutputBelowEdits(p: *Pardes, id: usize) void {
+ // Nothing to pad away from: with no emulator there is no prompt and no
+ // child whose output could land on top of the edit buffer.
+ const pane = p.panes[id] orelse return;
+ const o = pane.ovl orelse return;
+ if (!pane.isTerminal()) return;
+ const state = pane.terminal orelse return;
+ if (!state.vt.cursorIsAtPrompt()) return;
+ // the buffer's LAST surface row: its lines may outnumber the shell
+ // rows it covers, and it is the bottom one output must clear
+ const max_row = o.row + @as(i32, @intCast(modal.lineCount(o.text))) - 1;
+ const goff: i32 = @intCast(state.vt.screens.active.pages.scrollbar().offset);
+ const cursor_abs = pane.surfRow(goff + @as(i32, @intCast(state.vt.screens.active.cursor.y)));
+ const pad = std.math.clamp(max_row - cursor_abs, 0, @as(i32, pane.rows));
+ var i: i32 = 0;
+ while (i < pad) : (i += 1) p.emitWrite(id, "\r");
+}
+
+pub fn pushUndo(p: *Pardes, pane: *Pane) error{OutOfMemory}!void {
+ return pane.body.remember(p.gpa, pane.ovl);
+}
+
+/// Undo (back) or redo one step of the edit overlay.
+pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) error{OutOfMemory}!void {
+ const to = (try pane.body.step(p.gpa, pane.ovl, back)) orelse return;
+ if (pane.ovl) |o| p.gpa.free(o.text);
+ pane.ovl = to.ovl;
+ pane.ensureCursorVisible();
+}
+
+/// The emulator's size in pixels follows the shell's cells: kitty graphics
+/// placements are sized by it, and CSI 14/16 t report it.
+fn syncPixels(p: *const Pardes, pane: *Pane) void {
+ if (comptime !images_enabled) return;
+ const state = pane.terminal orelse return;
+ const vt = &state.vt;
+ vt.width_px = @as(u32, vt.cols) * p.view().cell_pixels.w;
+ vt.height_px = @as(u32, vt.rows) * p.view().cell_pixels.h;
+}
+
+/// When the pane's next kitty animation frame is due (ms on the core's
+/// clock), as its last drawn frame left it; null when nothing plays.
+pub fn animationDueMs(pane: *const Pane) ?u64 {
+ if (comptime !images_enabled) return null;
+ const state = pane.terminal orelse return null;
+ return state.images.animation_due_ms;
+}
+
+/// The Petscii builtin on a terminal: its kitty graphics as glyph art,
+/// or back to pixels where the shell draws pixels.
+pub fn togglePetscii(pane: *Pane) void {
+ if (comptime !images_enabled) return;
+ const state = pane.terminal orelse return;
+ state.images.petscii = !state.images.petscii;
+}
+
+/// Whether the pane draws its kitty graphics as glyph art by choice; null
+/// for a pane with no emulator.
+pub fn petscii(pane: *const Pane) ?bool {
+ if (comptime !images_enabled) return null;
+ const state = pane.terminal orelse return null;
+ return state.images.petscii;
+}
+
+/// Whether the screen showing holds any kitty graphics image.
+pub fn hasImages(pane: *const Pane) bool {
+ if (comptime !images_enabled) return false;
+ const state = pane.terminal orelse return false;
+ return state.vt.screens.active.kitty_images.images.count() > 0;
+}
+
+/// Draw the pane's kitty graphics images over its body rows (after the
+/// rows and their colours: placeholder cells are blanked here).
+pub fn drawImages(p: *Pardes, s: *Surface, pane: *Pane, id: usize, tx: u16, tw: u16, body_y: u16, body_h: u16) void {
+ if (comptime !images_enabled) return;
+ const state = pane.terminal orelse return;
+ const screen = state.vt.screens.active;
+ syncPixels(p, pane);
+ // A body taller than this draws its images on the rows that fit.
+ var rows_of: [1024]?u16 = undefined;
+ const vp_rows: usize = @min(scrollbar(pane).len, rows_of.len);
+ @memset(rows_of[0..vp_rows], null);
+ var any_placeholder = false;
+ var walk: BodyWalk = .init(pane);
+ var vr: u16 = 0;
+ while (walk.next()) |row| : (vr += 1) {
+ if (vr >= body_h) break;
+ const vi = switch (row) {
+ .grid => |v| v,
+ .edit => continue,
+ };
+ if (vi < 0 or vi >= vp_rows) continue;
+ const row_pin = screen.pages.pin(.{ .viewport = .{ .y = @intCast(vi) } }) orelse continue;
+ const flags = row_pin.rowAndCell().row;
+ // A prompt row outside tty mode is cut or hidden: its columns are
+ // not the grid's.
+ if (pane.body.mode != .tty and flags.semantic_prompt != .none) continue;
+ any_placeholder = any_placeholder or flags.kitty_virtual_placeholder;
+ rows_of[@intCast(vi)] = vr;
+ }
+ // Nothing to draw, no placeholder to blank and nothing cached to let
+ // go: the common case costs the rows' flags.
+ if (!any_placeholder and screen.kitty_images.placements.count() == 0 and state.images.converted.count() == 0) return;
+ state.images.draw(p, s, &state.vt, @intCast(id), pane.serial, tx, body_y, @min(tw, pane.cols), rows_of[0..vp_rows]);
+}
+
+/// Every byte the core wrote to each pane's pty since the last call, `\n`
+/// between panes' shares: "0:<bytes>\n1:<bytes>\n" for panes that got any.
+fn ptyWritesByPane(p: *Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ var per: [pardes.MAX_PANES]std.ArrayList(u8) = @splat(.empty);
+ defer for (&per) |*b| b.deinit(p.gpa);
+ while (p.nextEffect()) |effect| {
+ if (effect == .write) try per[effect.write.pane].appendSlice(p.gpa, effect.write.bytes.slice());
+ }
+ for (per, 0..) |b, id| if (b.items.len > 0) try out.print(p.gpa, "{d}:{s}\n", .{ id, b.items });
+ return out.items;
+}
+
+/// `a=T` of a 4x2 RGB image, `i=7`, red on the left half, blue on the
+/// right, with the rest of the control data `extra` (`c=2,r=1` places it
+/// over two cells).
+inline fn kittyTransmit(comptime extra: []const u8) []const u8 {
+ return comptime blk: {
+ const row = [_]u8{ 255, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 255 };
+ const pixels = row ++ row;
+ var buf: [std.base64.standard.Encoder.calcSize(pixels.len)]u8 = undefined;
+ const b64 = std.base64.standard.Encoder.encode(&buf, &pixels)[0..buf.len].*;
+ break :blk "\x1b_Ga=T,f=24,s=4,v=2,i=7," ++ extra ++ ";" ++ b64 ++ "\x1b\\";
+ };
+}
+
+fn imagePlaces(s: *const Surface) []const pardes.Placement {
+ return s.placements.items;
+}
+
+/// `n` line breaks: enough of them push the screen's rows into history.
+fn lineBreaks(comptime n: usize) [2 * n]u8 {
+ var out: [2 * n]u8 = undefined;
+ for (0..n) |i| out[2 * i ..][0..2].* = "\r\n".*;
+ return out;
+}
+
+test "replay ownership is terminal-only and construction rolls back on allocation failure" {
+ const Case = struct {
+ fn run(gpa: std.mem.Allocator, terminal: bool) !void {
+ const pane = if (terminal) try create(gpa, 40, 12) else try createDoc(gpa, 40, 12);
+ defer gpa.destroy(pane);
+ defer deinitEmulator(pane, gpa);
+ try std.testing.expectEqual(terminal, pane.terminal != null);
+ }
+ };
+ try std.testing.expect(@sizeOf(Pane) < 128 * 1024);
+ try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{false});
+ try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{true});
+}
+
+test "a terminal made fresh has no size waiting: one never resized keeps its grid when a unit is cut" {
+ // Fresh memory as a Debug build's allocator hands it out: 0xAA. A field
+ // `create` left unset read a size of 43690x43690 (fixer 2's, 2026-10-30).
+ const Filling = struct {
+ child: std.mem.Allocator,
+ fn alloc(ctx: *anyopaque, len: usize, a: std.mem.Alignment, ra: usize) ?[*]u8 {
+ const self: *@This() = @ptrCast(@alignCast(ctx));
+ const ptr = self.child.rawAlloc(len, a, ra) orelse return null;
+ @memset(ptr[0..len], 0xAA);
+ return ptr;
+ }
+ fn resize(ctx: *anyopaque, buf: []u8, a: std.mem.Alignment, n: usize, ra: usize) bool {
+ const self: *@This() = @ptrCast(@alignCast(ctx));
+ return self.child.rawResize(buf, a, n, ra);
+ }
+ fn remap(ctx: *anyopaque, buf: []u8, a: std.mem.Alignment, n: usize, ra: usize) ?[*]u8 {
+ const self: *@This() = @ptrCast(@alignCast(ctx));
+ return self.child.rawRemap(buf, a, n, ra);
+ }
+ fn free(ctx: *anyopaque, buf: []u8, a: std.mem.Alignment, ra: usize) void {
+ const self: *@This() = @ptrCast(@alignCast(ctx));
+ self.child.rawFree(buf, a, ra);
+ }
+ const vtable: std.mem.Allocator.VTable = .{ .alloc = alloc, .resize = resize, .remap = remap, .free = free };
+ };
+ var filling: Filling = .{ .child = std.testing.allocator };
+ const gpa: std.mem.Allocator = .{ .ptr = &filling, .vtable = &Filling.vtable };
+ const pane = try create(gpa, 40, 12);
+ defer gpa.destroy(pane);
+ defer deinitEmulator(pane, gpa);
+ try std.testing.expect(pane.terminal.?.resize_to == null);
+}
+
+test "document construction allocates only the pane and has inert terminal defaults" {
+ var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{ .fail_index = 1 });
+ const allocator = failing.allocator();
+ const pane = try createDoc(allocator, 40, 12);
+ defer allocator.destroy(pane);
+ defer deinitEmulator(pane, allocator);
+ try std.testing.expect(pane.terminal == null);
+ try std.testing.expectEqual(@as(usize, 1), failing.alloc_index);
+ try std.testing.expectEqual(@as(usize, 0), failing.resize_index);
+ try std.testing.expect(!failing.has_induced_failure);
+ try std.testing.expectEqual(@as(usize, @sizeOf(Pane)), failing.allocated_bytes);
+ try std.testing.expectEqual(GridCursor{}, gridCursor(pane));
+ try std.testing.expectEqual(Scrollbar{}, scrollbar(pane));
+ try std.testing.expect(!bracketedPaste(pane));
+ try std.testing.expect(!reportsMouse(pane));
+ try std.testing.expect(!promptInputReady(pane));
+ scrollGrid(pane, 100);
+ followOutput(pane);
+ resizeGrid(pane, 80, 24);
+ try std.testing.expectEqual(GridCursor{}, gridCursor(pane));
+ try std.testing.expectEqual(Scrollbar{}, scrollbar(pane));
+ try std.testing.expectEqualStrings("", try screenTextAlloc(pane, allocator));
+ try std.testing.expect(!failing.has_induced_failure);
+}
+
+test "terminal state keeps parser fragments and sends emulator replies through its owner" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ const state = pane.terminal.?;
+ try std.testing.expect(state.stream.handler.inner.terminal == &state.vt);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[" } });
+ while (p.nextEffect()) |effect| {
+ if (effect == .write) return error.PrematureTerminalReply;
+ }
+ p.update(.{ .output = .{ .pane = 0, .bytes = "6n" } });
+ var replies: usize = 0;
+ while (p.nextEffect()) |effect| {
+ if (effect != .write) continue;
+ try std.testing.expectEqual(@as(u8, 0), effect.write.pane);
+ try std.testing.expectEqualStrings("\x1b[1;1R", effect.write.bytes.slice());
+ replies += 1;
+ }
+ try std.testing.expectEqual(@as(usize, 1), replies);
+ try std.testing.expectEqual(@as(u16, 0), state.reply_len);
+}
+
+test "a terminal's dump restores the cells it drew, its history and where its view was" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ feedOutput(p, pane, "\x1b[31mred\x1b[0m\r\ncafé\r\n");
+ for (0..30) |i| {
+ var line: [16]u8 = undefined;
+ feedOutput(p, pane, std.fmt.bufPrint(&line, "line {d}\r\n", .{i}) catch unreachable);
+ }
+ scrollGrid(pane, -5);
+ const bytes = try pardes.walk.save(State, gpa, pane.terminal.?);
+ defer gpa.free(bytes);
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const state = try gpa.create(State);
+ defer gpa.destroy(state);
+ state.* = try pardes.walk.load(State, gpa, bytes, null);
+ defer {
+ state.stream.deinit();
+ state.vt.deinit(gpa);
+ }
+ try std.testing.expectEqual(pardes.walk.digest(State, pane.terminal.?), pardes.walk.digest(State, state));
+ try std.testing.expectEqual(pane.terminal.?.vt.screens.active.pages.scrollbar(), state.vt.screens.active.pages.scrollbar());
+}
+
+test "a restored command pane comes back finished, its command not run again" {
+ if (comptime pardes.isolated) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 60, .rows = 16 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const cmd = p.freeSlot().?;
+ _ = try panes.newCommand(p, cmd, "/tmp", "make test");
+ feedOutput(p, p.panes[cmd].?, "ok\r\n");
+ p.update(.{ .exited = .{ .pane = @intCast(cmd), .status = 2 } });
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.initFromDump(gpa, .{ .tty_only = true, .cols = 60, .rows = 16 }, p.dump_out.?);
+ defer restored.deinit();
+ var spawns: usize = 0;
+ while (restored.nextEffect()) |effect| switch (effect) {
+ .spawn => spawns += 1,
+ else => {},
+ };
+ try std.testing.expectEqual(@as(usize, 1), spawns); // the shell, not the command
+ const again = for (restored.panes) |slot| {
+ if (slot) |pane| if (pane.command != null) break pane;
+ } else return error.CommandPaneLost;
+ try std.testing.expectEqualStrings("make test", again.command.?);
+ try std.testing.expect(again.command_done);
+ try std.testing.expectEqual(@as(?u8, 2), again.command_status);
+ const text = try screenTextAlloc(again, gpa);
+ defer gpa.free(text);
+ try std.testing.expect(std.mem.indexOf(u8, text, "ok") != null);
+}
+
+test "a restored terminal keeps its history above a marker and gets a shell where it was" {
+ if (comptime pardes.isolated) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ feedOutput(p, pane, "old output\r\n$ ls\r\n");
+ try pane.setOwnedCwd("/tmp");
+ pane.shell = try gpa.dupe(u8, "bash"); // `Term bash`: it comes back as bash
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.initFromDump(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }, p.dump_out.?);
+ defer restored.deinit();
+ var spawned = false;
+ while (restored.nextEffect()) |effect| switch (effect) {
+ .spawn => |sp| spawned = sp.pane == 0 and std.mem.eql(u8, sp.cwd.slice(), "/tmp"),
+ else => {},
+ };
+ try std.testing.expect(spawned);
+ const again = restored.panes[0].?;
+ try std.testing.expectEqualStrings("bash", again.shell.?);
+ try std.testing.expect(again.command == null);
+ try std.testing.expectEqual(.spawn, again.pending_command.wait);
+ const text = try screenTextAlloc(again, gpa);
+ defer gpa.free(text);
+ const old_at = std.mem.indexOf(u8, text, "old output") orelse return error.HistoryLost;
+ const mark_at = std.mem.indexOf(u8, text, "restored history") orelse return error.NoMarker;
+ try std.testing.expect(old_at < mark_at);
+}
+
+test "a position that cannot follow the output for want of memory is said on the message row, and logged" {
+ var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(failing.allocator(), .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ feedOutput(p, pane, "one\r\ntwo\r\n");
+ // More positions than the emulator's pins have room for: following them
+ // through the output needs memory, and there is none.
+ try std.testing.expect(pane.body.reserveSels());
+ for (pane.body.sels[0..8], 0..) |*range, i| range.* = .{ .row = @intCast(i), .col = 0, .arow = @intCast(i), .acol = 1 };
+ pane.body.nsel = 8;
+ failing.fail_index = failing.alloc_index;
+ feedOutput(p, pane, "three\r\n");
+ failing.fail_index = std.math.maxInt(usize);
+ try std.testing.expect(failing.has_induced_failure);
+ try std.testing.expectEqualStrings(positions_lost, pane.msg[0..pane.msg_len]);
+ const logged = p.messages.at(p.messages.len -| 1) orelse return error.NothingLogged;
+ try std.testing.expectEqualStrings(positions_lost, logged.slice());
+}
+
+test "raw terminal output needs no position tracking allocations" {
+ var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{});
+ const p = try Pardes.init(failing.allocator(), .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ pane.body.mode = .tty;
+ feedOutput(p, pane, "warm");
+ const allocations = failing.alloc_index;
+ failing.fail_index = allocations;
+ const pins = pane.terminal.?.vt.screens.active.pages.countTrackedPins();
+ feedOutput(p, pane, " output");
+ try std.testing.expectEqual(allocations, failing.alloc_index);
+ try std.testing.expect(!failing.has_induced_failure);
+ try std.testing.expectEqual(pins, pane.terminal.?.vt.screens.active.pages.countTrackedPins());
+}
+
+test "rows asked for after a pane's cached rows were dropped, before the sweep, leak nothing" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ try std.testing.expect(pane.terminal != null);
+ _ = try shellRows(p, pane);
+ // A pane's teardown drops its entry; the rows stay until the sweep.
+ p.shell_rows.dropPane(pane);
+ _ = try shellRows(p, pane);
+}
+
+test "the luminance table answers exactly what ghostty computes" {
+ for (0..256) |i| {
+ const c: u8 = @intCast(i);
+ const grey: GColor.RGB = .{ .r = c, .g = c, .b = c };
+ try std.testing.expectEqual(grey.luminance(), luminanceOf(grey));
+ }
+ // Channel weights are asymmetric, so a grey ramp alone would not catch a
+ // transposed coefficient. The palette is what the tables enumerate.
+ for (GColor.default) |candidate| {
+ try std.testing.expectEqual(candidate.luminance(), luminanceOf(candidate));
+ for (GColor.default) |page| {
+ try std.testing.expectEqual(
+ candidate.contrast(page),
+ contrastOf(luminanceOf(candidate), luminanceOf(page)),
+ );
+ }
+ }
+}
+
+test "terminal Filter keys indexed truecolor OSC and background-only cells through the theme" {
+ const testing = std.testing;
+ // Raw index assertions require a theme that inherits the ANSI palette.
+ const p = try Pardes.init(testing.allocator, .{ .startup_config = "Theme helix\n", .tty_only = true, .cols = 18, .rows = 6 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ pane.tag_expanded = false; // a one-row tag keeps this small screen's rows
+ p.sync();
+ try testing.expect(pane.tty_filter);
+ pane.tty_filter = false;
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[31mA" ++
+ "\x1b[38;5;196mB" ++
+ "\x1b[38;2;255;0;0mC" ++
+ "\x1b[0;48;5;25mD" ++
+ "\x1b[0;48;2;0;95;175mE" ++
+ "\x1b[0;1;2;3;4;5;7;8;9mF" ++
+ "\x1b[0;48;5;25m\x1b[K" ++
+ "\r\n\x1b[0;38;5;2m界" } });
+
+ var frame = std.heap.ArenaAllocator.init(testing.allocator);
+ defer frame.deinit();
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const body_y = p.bodyTop(pane, r);
+
+ const raw = try p.render(frame.allocator());
+ try testing.expectEqual(pardes.Color{ .index = 1 }, raw.at(tx, body_y).style.fg);
+ try testing.expectEqual(pardes.Color{ .index = 196 }, raw.at(tx + 1, body_y).style.fg);
+ try testing.expectEqual(pardes.Color{ .rgb = .{ 255, 0, 0 } }, raw.at(tx + 2, body_y).style.fg);
+
+ pane.tty_filter = true;
+ _ = frame.reset(.retain_capacity);
+ const filtered = try p.render(frame.allocator());
+ var expected_cache: FilterPalette = .{};
+ const expected = expected_cache.get(p.theme());
+ try testing.expectEqual(asPardesColor(expected[1]), filtered.at(tx, body_y).style.fg);
+ try testing.expectEqual(asPardesColor(expected[196]), filtered.at(tx + 1, body_y).style.fg);
+ try testing.expectEqual(filtered.at(tx + 1, body_y).style.fg, filtered.at(tx + 2, body_y).style.fg);
+ try testing.expectEqual(asPardesColor(expected[25]), filtered.at(tx + 3, body_y).style.bg);
+ try testing.expectEqual(filtered.at(tx + 3, body_y).style.bg, filtered.at(tx + 4, body_y).style.bg);
+
+ const attrs = filtered.at(tx + 5, body_y).style;
+ try testing.expect(attrs.bold);
+ try testing.expect(attrs.dim);
+ try testing.expect(attrs.italic);
+ try testing.expect(attrs.blink);
+ try testing.expect(attrs.reverse);
+ try testing.expect(attrs.invisible);
+ try testing.expect(attrs.strikethrough);
+ try testing.expectEqual(.single, attrs.ul);
+
+ const erased = pane.terminal.?.vt.screens.active.pages.getCell(.{ .viewport = .{ .x = 6, .y = 0 } }).?;
+ try testing.expectEqual(.bg_color_palette, erased.cell.content_tag);
+ try testing.expectEqual(asPardesColor(expected[25]), filtered.at(tx + 6, body_y).style.bg);
+ try testing.expectEqual(asPardesColor(expected[2]), filtered.at(tx, body_y + 1).style.fg);
+ try testing.expectEqual(filtered.at(tx, body_y + 1).style, filtered.at(tx + 1, body_y + 1).style);
+ // A filtered terminal never delegates either colour to a backend palette,
+ // including cells which were empty/default before the pass.
+ for (0..r.w - config.GUTTER) |col| {
+ const cell = filtered.at(tx + @as(u16, @intCast(col)), body_y);
+ try testing.expect(!cell.default);
+ switch (cell.style.fg) {
+ .rgb => {},
+ else => return error.FilteredForegroundWasNotRgb,
+ }
+ switch (cell.style.bg) {
+ .rgb => {},
+ else => return error.FilteredBackgroundWasNotRgb,
+ }
+ }
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]4;1;#ff0000\x1b\\" } });
+ const osc_red = pane.terminal.?.vt.colorForXterm(.{ .palette = 1 }).?;
+ try testing.expect(osc_red.eql(.{ .r = 255, .g = 0, .b = 0 }));
+ pane.tty_filter = false;
+ pane.tty_filter = true;
+ try testing.expect(osc_red.eql(pane.terminal.?.vt.colorForXterm(.{ .palette = 1 }).?));
+ _ = frame.reset(.retain_capacity);
+ const osc_palette = try p.render(frame.allocator());
+ try testing.expectEqual(asPardesColor(expected[196]), osc_palette.at(tx, body_y).style.fg);
+
+ // Dynamic default foreground/background colours key every default cell,
+ // including the otherwise blank end of the row.
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]10;#ff0000\x1b\\" ++
+ "\x1b]11;#5f5f5f\x1b\\" } });
+ const dyn_fg = pane.terminal.?.vt.colorForXterm(.{ .dynamic = .foreground }).?;
+ const dyn_bg = pane.terminal.?.vt.colorForXterm(.{ .dynamic = .background }).?;
+ try testing.expect(dyn_fg.eql(.{ .r = 255, .g = 0, .b = 0 }));
+ try testing.expect(dyn_bg.eql(.{ .r = 95, .g = 95, .b = 95 }));
+ _ = frame.reset(.retain_capacity);
+ const dynamic = try p.render(frame.allocator());
+ const blank = dynamic.at(tx + r.w - config.GUTTER - 1, body_y + 2).style;
+ try testing.expectEqual(asPardesColor(expected[196]), blank.fg);
+ try testing.expectEqual(asPardesColor(expected[59]), blank.bg);
+
+ const explicit_before_reverse = dynamic.at(tx, body_y).style.fg;
+ try testing.expectEqual(asPardesColor(expected[196]), explicit_before_reverse);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?5h" } });
+ _ = frame.reset(.retain_capacity);
+ const reversed = try p.render(frame.allocator());
+ const reversed_blank = reversed.at(tx + r.w - config.GUTTER - 1, body_y + 2).style;
+ try testing.expectEqual(asPardesColor(expected[59]), reversed_blank.fg);
+ try testing.expectEqual(asPardesColor(expected[196]), reversed_blank.bg);
+ const reversed_explicit = reversed.at(tx, body_y).style;
+ try testing.expectEqual(asPardesColor(expected[196]), reversed_explicit.bg);
+ try testing.expectEqual(pardes.Color{ .rgb = p.theme().bg.? }, reversed_explicit.fg);
+ try testing.expect(!std.meta.eql(reversed_explicit.fg, reversed_explicit.bg));
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?5l" } });
+ _ = frame.reset(.retain_capacity);
+ const unreversed = try p.render(frame.allocator());
+ const unreversed_blank = unreversed.at(tx + r.w - config.GUTTER - 1, body_y + 2).style;
+ try testing.expectEqual(asPardesColor(expected[196]), unreversed_blank.fg);
+ try testing.expectEqual(asPardesColor(expected[59]), unreversed_blank.bg);
+
+ // The cache is keyed by values, not a theme name. Replacing a custom
+ // theme in place immediately recolours already-rendered indexed cells.
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]104;1\x1b\\" } });
+ var custom = p.theme().*;
+ custom.name = try p.gpa.dupe(u8, "same-name");
+ custom.palette = null;
+ custom.kw = .{ 1, 2, 3 };
+ p.custom_theme = custom;
+ _ = frame.reset(.retain_capacity);
+ const custom_first = try p.render(frame.allocator());
+ try testing.expectEqual(pardes.Color{ .rgb = .{ 1, 2, 3 } }, custom_first.at(tx, body_y).style.fg);
+ if (p.custom_theme) |*theme| theme.kw = .{ 4, 5, 6 };
+ _ = frame.reset(.retain_capacity);
+ const custom_second = try p.render(frame.allocator());
+ try testing.expectEqual(pardes.Color{ .rgb = .{ 4, 5, 6 } }, custom_second.at(tx, body_y).style.fg);
+}
+
+test "terminal Filter keeps extended keys dark-to-light on a light theme" {
+ const p = try Pardes.init(std.testing.allocator, .{ .startup_config = "Theme acme\n", .tty_only = true });
+ defer p.deinit();
+ try std.testing.expectEqualStrings("acme", p.theme().name);
+ var cache: FilterPalette = .{};
+ const palette = cache.get(p.theme());
+ try std.testing.expect(palette[16].eql(asGhostRgb(p.theme().fg.?)));
+ try std.testing.expect(palette[231].eql(asGhostRgb(p.theme().bg.?)));
+}
+
+test "terminal Filter preserves exact palette-null light theme default roles" {
+ const testing = std.testing;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 12, .rows = 5 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+
+ var light = p.theme().*;
+ light.name = try p.gpa.dupe(u8, "filter-light-defaults");
+ light.bg = .{ 0xf8, 0xf8, 0xf8 };
+ light.fg = .{ 0x38, 0x38, 0x38 };
+ light.palette = null;
+ p.custom_theme = light;
+
+ const pane = p.panes[0].?;
+ try testing.expectEqual(@as(?GColor.RGB, null), pane.terminal.?.vt.colorForXterm(.{ .dynamic = .foreground }));
+ try testing.expectEqual(@as(?GColor.RGB, null), pane.terminal.?.vt.colorForXterm(.{ .dynamic = .background }));
+ pane.tty_filter = true;
+
+ var frame = std.heap.ArenaAllocator.init(testing.allocator);
+ defer frame.deinit();
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const body_y = p.bodyTop(pane, r);
+ const ordinary = try p.render(frame.allocator());
+ try testing.expectEqual(pardes.Color{ .rgb = light.fg.? }, ordinary.at(tx, body_y).style.fg);
+ try testing.expectEqual(pardes.Color{ .rgb = light.bg.? }, ordinary.at(tx, body_y).style.bg);
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?5h" } });
+ _ = frame.reset(.retain_capacity);
+ const reversed = try p.render(frame.allocator());
+ try testing.expectEqual(pardes.Color{ .rgb = light.bg.? }, reversed.at(tx, body_y).style.fg);
+ try testing.expectEqual(pardes.Color{ .rgb = light.fg.? }, reversed.at(tx, body_y).style.bg);
+}
+
+test "terminal Filter maps the default roles before it maps anything else" {
+ const testing = std.testing;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 18, .rows = 6 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ try testing.expect(pane.tty_filter);
+
+ // Native dark/light palettes plus legacy helix/dark/acme, including
+ // the null-page fallback that only the legacy dark theme exercises.
+ for (0..9) |t| {
+ p.settings.theme = @intCast(t);
+ const stage_one = FilteredColors.init(p, &pane.terminal.?.vt);
+ // `dark` declares no background of its own, which is exactly why the
+ // resolver reads the tag colours as the fallback rather than `.?`.
+ const theme = p.theme();
+ try testing.expect(stage_one.theme_bg.eql(asGhostRgb(theme.bg orelse theme.tag_bg)));
+ try testing.expect(stage_one.theme_fg.eql(asGhostRgb(theme.fg orelse theme.tag_fg)));
+ // With no OSC 11 in play the mapped page IS that anchor, and the
+ // fallback is the other one: a background never contrasts with itself.
+ try testing.expect(stage_one.default_bg.eql(stage_one.theme_bg));
+ try testing.expect(stage_one.fallback_fg.eql(stage_one.theme_fg));
+ }
+
+ p.settings.theme = 0;
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]11;#5f5f5f\x1b\\" } });
+ var moved = FilteredColors.init(p, &pane.terminal.?.vt);
+ try testing.expect(!moved.default_bg.eql(moved.theme_bg));
+ try testing.expect(moved.default_bg.eql(moved.keyedRgb(.{ .r = 0x5f, .g = 0x5f, .b = 0x5f })));
+}
+
+test "terminal Filter refuses a foreground that would collapse onto the page" {
+ const testing = std.testing;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 18, .rows = 6 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ try testing.expect(pane.tty_filter);
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[38;2;255;255;255mW" ++
+ "\x1b[0;30mB" ++
+ "\x1b[0;31mR" } });
+
+ var frame = std.heap.ArenaAllocator.init(testing.allocator);
+ defer frame.deinit();
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const body_y = p.bodyTop(pane, r);
+
+ for (0..9) |t| {
+ p.settings.theme = @intCast(t);
+ var fc = FilteredColors.init(p, &pane.terminal.?.vt);
+ const page = asPardesColor(fc.default_bg);
+ const rescued = asPardesColor(fc.fallback_fg);
+ _ = frame.reset(.retain_capacity);
+ const g = try p.render(frame.allocator());
+
+ // The colour each of the three would have been given with no floor.
+ const raw_white = fc.keyedRgb(.{ .r = 255, .g = 255, .b = 255 });
+ const raw_black = fc.paletteRgb(0, GColor.default[0]);
+ const raw_red = fc.paletteRgb(1, GColor.default[1]);
+
+ for ([_]struct { at: u16, raw: GColor.RGB }{
+ .{ .at = 0, .raw = raw_white },
+ .{ .at = 1, .raw = raw_black },
+ .{ .at = 2, .raw = raw_red },
+ }) |case| {
+ const cell = g.at(tx + case.at, body_y).style;
+ try testing.expectEqual(page, cell.bg);
+ if (case.raw.contrast(fc.default_bg) < config.tty_filter_min_contrast) {
+ // Refused: the projection's answer is not painted, the anchor is.
+ try testing.expectEqual(rescued, cell.fg);
+ try testing.expect(!std.meta.eql(cell.fg, cell.bg));
+ } else {
+ // Cleared the floor, so stage two leaves it exactly alone.
+ try testing.expectEqual(asPardesColor(case.raw), cell.fg);
+ }
+ // Either way a filtered cell delegates neither colour to a backend.
+ switch (cell.fg) {
+ .rgb => |ink| try testing.expect(asGhostRgb(ink).contrast(fc.default_bg) >=
+ config.tty_filter_min_contrast),
+ else => return error.FilteredForegroundWasNotRgb,
+ }
+ }
+
+ // At least one of the three has to have been a real collapse, or this
+ // theme proved nothing: white on the light theme, black on the dark.
+ try testing.expect(raw_white.contrast(fc.default_bg) < config.tty_filter_min_contrast or
+ raw_black.contrast(fc.default_bg) < config.tty_filter_min_contrast);
+ // A saturated red is never the page on any curated theme.
+ try testing.expect(raw_red.contrast(fc.default_bg) >= config.tty_filter_min_contrast);
+ }
+}
+
+test "terminal Filter holds every projected foreground off the page" {
+ const testing = std.testing;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 18, .rows = 6 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+
+ for (0..9) |t| {
+ p.settings.theme = @intCast(t);
+ var fc = FilteredColors.init(p, &pane.terminal.?.vt);
+ var refused: usize = 0;
+ for (fc.target, 0..) |projected, key| {
+ const ink = fc.legible(projected);
+ try testing.expect(ink.contrast(fc.default_bg) >= config.tty_filter_min_contrast);
+ if (!ink.eql(projected)) {
+ refused += 1;
+ try testing.expect(ink.eql(fc.fallback_fg));
+ // Only ever refused for being too near the page.
+ try testing.expect(projected.contrast(fc.default_bg) < config.tty_filter_min_contrast);
+ }
+ // The key a background asks for is handed back untouched, including
+ // the one whose value is the page itself.
+ try testing.expect(fc.keyedRgb(GColor.default[key]).eql(fc.target[fc.nearestKey(GColor.default[key])]));
+ }
+ // Every curated theme owns at least one collapsing key — that is why
+ // the floor exists — and the floor must not be flattening the palette.
+ try testing.expect(refused > 0);
+ try testing.expect(refused < fc.target.len / 8);
+ }
+}
+
+test "tty ansi colors follow the prompt hug into normal mode" {
+ const testing = std.testing;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 18, .rows = 6 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ pane.tty_filter = false;
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;A\x1b\\\x1b[32mPP\x1b]133;B\x1b\\\x1b[31mR\x1b[34mB\x1b[0m out" } });
+
+ var frame = std.heap.ArenaAllocator.init(testing.allocator);
+ defer frame.deinit();
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const body_y = p.bodyTop(pane, r);
+ const red: pardes.Color = .{ .rgb = p.theme().palette.?[1] };
+ const blue: pardes.Color = .{ .rgb = p.theme().palette.?[4] };
+
+ // tty mode projects the emulator's ansi colours cell for cell.
+ pane.body.mode = .tty;
+ p.shell_rows.stale = true;
+ const tty = try p.render(frame.allocator());
+ try testing.expectEqual(red, tty.at(tx + 2, body_y).style.fg);
+ try testing.expectEqual(blue, tty.at(tx + 3, body_y).style.fg);
+
+ pane.body.mode = .normal;
+ p.shell_rows.stale = true;
+ _ = frame.reset(.retain_capacity);
+ const norm = try p.render(frame.allocator());
+ try testing.expectEqualStrings("R", norm.at(tx, body_y).grapheme());
+ try testing.expectEqualStrings("B", norm.at(tx + 1, body_y).grapheme());
+ try testing.expectEqual(red, norm.at(tx, body_y).style.fg);
+ try testing.expectEqual(blue, norm.at(tx + 1, body_y).style.fg);
+}
+
+test "a prompt row hidden end to end paints nothing at all" {
+ const testing = std.testing;
+ const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 12, .rows = 8 });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ pane.tag_expanded = false; // a 12x8 screen: the body, not the tag
+ p.sync();
+ pane.tty_filter = false;
+ pane.body.mode = .normal;
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]133;A\x1b\\\x1b[32maaaaaaaaa\x1b]133;B\x1b\\\x1b[41;36m\u{754C}\x1b[0m\r\n" } });
+
+ var frame = std.heap.ArenaAllocator.init(testing.allocator);
+ defer frame.deinit();
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const body_y = p.bodyTop(pane, r);
+ p.shell_rows.stale = true;
+ const s = try p.render(frame.allocator());
+
+ try testing.expectEqualStrings(" ", s.at(tx, body_y).grapheme());
+ try testing.expect(!std.meta.eql(pardes.Color{ .rgb = p.theme().palette.?[1] }, s.at(tx, body_y).style.bg));
+}
+
+test "a program that asked for focus reports hears CSI I and CSI O as its pane takes and gives up the keyboard, and as the window does" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 90, .rows = 30, .shells = 3 });
+ defer p.deinit();
+ var frame = std.heap.ArenaAllocator.init(gpa);
+ defer frame.deinit();
+ _ = try p.render(frame.allocator());
+ var out: std.ArrayList(u8) = .empty;
+ defer out.deinit(gpa);
+ _ = try ptyWritesByPane(p, &out);
+ p.view().active = 0;
+ // Asking while its pane has the keyboard: told at once that it has.
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1004h" } });
+ try std.testing.expectEqualStrings("0:\x1b[I\n", try ptyWritesByPane(p, &out));
+ p.update(.{ .output = .{ .pane = 1, .bytes = "\x1b[?1004h" } });
+ try std.testing.expectEqualStrings("", try ptyWritesByPane(p, &out));
+ // A click into the other pane moves the keyboard: out of one, into the
+ // other.
+ const r = p.view().rects[1];
+ const at_col = r.x + config.GUTTER + 2;
+ const at_row = p.bodyTop(p.panes[1].?, r) + 1;
+ p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = at_col, .row = at_row } });
+ p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = at_col, .row = at_row } });
+ try std.testing.expectEqual(@as(usize, 1), p.view().active);
+ try std.testing.expectEqualStrings("0:\x1b[O\n1:\x1b[I\n", try ptyWritesByPane(p, &out));
+ // The window: away and back.
+ p.update(.{ .focus = false });
+ try std.testing.expectEqualStrings("1:\x1b[O\n", try ptyWritesByPane(p, &out));
+ p.update(.{ .focus = false });
+ try std.testing.expectEqualStrings("", try ptyWritesByPane(p, &out));
+ p.update(.{ .focus = true });
+ try std.testing.expectEqualStrings("1:\x1b[I\n", try ptyWritesByPane(p, &out));
+ // A program that did not ask hears nothing: pane 2.
+ p.view().active = 2;
+ p.update(.tick);
+ try std.testing.expectEqualStrings("1:\x1b[O\n", try ptyWritesByPane(p, &out));
+}
+
+test "a terminal's kitty graphics image is drawn where its program placed it, and a delete takes it away" {
+ if (comptime !images_enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 });
+ defer p.deinit();
+ p.view().frontend.native_images = true;
+ p.view().active = 0;
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24, .cell_pixels = .{ .w = 10, .h = 20 } } });
+ var frame = std.heap.ArenaAllocator.init(gpa);
+ defer frame.deinit();
+ const pane = p.panes[0].?;
+ pane.body.mode = .tty;
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3;5H" ++ kittyTransmit("c=2,r=1") } });
+ var s = try p.render(frame.allocator());
+ const places = imagePlaces(s);
+ try std.testing.expectEqual(@as(usize, 1), places.len);
+ const place = places[0];
+ const r = p.view().rects[0];
+ const img = pane.terminal.?.vt.screens.active.kitty_images.imageById(7).?;
+ try std.testing.expectEqual(pardes.Placement.keyOf(pane.serial, 7, @truncate(img.generation)), place.key);
+ try std.testing.expectEqual(pardes.RectCell{ .x = r.x + config.GUTTER + 4, .y = p.bodyTop(pane, r) + 2, .w = 2, .h = 1 }, place.dst);
+ try std.testing.expectEqual(@as(u32, 4), place.raster.w);
+ try std.testing.expectEqual(@as(u32, 2), place.raster.h);
+ try std.testing.expectEqualSlices(u8, &.{ 255, 0, 0, 255 }, place.raster.bytes()[0..4]);
+ try std.testing.expectEqual(pardes.RectPx{ .x = 0, .y = 0, .w = 4, .h = 2 }, place.src);
+ try std.testing.expectEqual(pardes.RectPx{ .x = 0, .y = 0, .w = 20, .h = 20 }, place.at.?);
+
+ // Scrolled up by the shell's output, it goes up with the text.
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[24;1H\n\n" } });
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expectEqual(p.bodyTop(pane, r), imagePlaces(s)[0].dst.y);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\n" } });
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len);
+
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[1;1H" ++ kittyTransmit("c=2,r=1") } });
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 1), imagePlaces(s).len);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b_Ga=d,d=A\x1b\\" } });
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len);
+}
+
+test "ED 3 takes away a kitty placement whose row it erased: it never comes back at the top" {
+ if (comptime !images_enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 });
+ defer p.deinit();
+ p.view().frontend.native_images = true;
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24, .cell_pixels = .{ .w = 10, .h = 20 } } });
+ var frame = std.heap.ArenaAllocator.init(gpa);
+ defer frame.deinit();
+ const pane = p.panes[0].?;
+ pane.body.mode = .tty;
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[1;1H" ++ kittyTransmit("c=2,r=1") } });
+ const storage = &pane.terminal.?.vt.screens.active.kitty_images;
+ try std.testing.expectEqual(@as(usize, 1), storage.placements.count());
+ // Scrolled into the history, it is not on screen; `clear` (ED 2 then
+ // ED 3) erases that history and the placement with it.
+ p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(40) } });
+ var s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[H\x1b[2J\x1b[3J" } });
+ try std.testing.expectEqual(@as(usize, 0), storage.placements.count());
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len);
+}
+
+test "a finished command's output erased by a later ED 3 is not called whole, and no rows stand in for it" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 6 });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ const prompt = "\x1b]133;A;cl=line;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07";
+ p.update(.{ .output = .{ .pane = 0, .bytes = prompt ++ "\r\n\x1b]133;C;aid=pardes\x07printed\r\n\x1b]133;D;0;aid=pardes\x07" ++ prompt } });
+ const before = try commandOutput(pane, gpa, 100);
+ defer gpa.free(before.text);
+ try std.testing.expect(before.whole);
+ try std.testing.expect(std.mem.startsWith(u8, before.text, "printed"));
+ // The command's rows go into the history, and ED 3 erases them: its
+ // pins are `garbage` now (ghostty 1.4), not moved to the screen's top,
+ // where another program's text would be read as its output.
+ p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(20) } });
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3J" } });
+ const after = try commandOutput(pane, gpa, 100);
+ defer gpa.free(after.text);
+ try std.testing.expect(!after.whole);
+ try std.testing.expectEqualStrings("", after.text);
+}
+
+test "a selection whose row ED 3 erased goes; one on the screen stays" {
+ const gpa = std.testing.allocator;
+ for ([_]bool{ true, false }) |in_history| {
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 6 });
+ defer p.deinit();
+ const pane = p.panes[0].?;
+ pane.body.mode = .tty;
+ p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(20) } });
+ pane.body.mode = .normal;
+ const pages = &pane.terminal.?.vt.screens.active.pages;
+ const top: i32 = @intCast(pages.total_rows - pane.rows);
+ const row: i32 = if (in_history) top - 3 else top + 2;
+ pane.body.vsel = .{ .active = true, .row = row, .col = 1 };
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3J" } });
+ try std.testing.expectEqual(!in_history, pane.body.vsel.active);
+ if (!in_history) try std.testing.expectEqual(@as(i32, 2), pane.body.vsel.row);
+ }
+}
+
+test "a virtual kitty placement shows through its placeholder cells, which draw no text" {
+ if (comptime !images_enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 });
+ defer p.deinit();
+ p.view().frontend.native_images = true;
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24, .cell_pixels = .{ .w = 10, .h = 20 } } });
+ var frame = std.heap.ArenaAllocator.init(gpa);
+ defer frame.deinit();
+ const pane = p.panes[0].?;
+ pane.body.mode = .tty;
+ // yazi's way: a virtual placement two cells by one, then the two
+ // placeholders, the image's id in their colour, row and column in
+ // their diacritics.
+ p.update(.{ .output = .{ .pane = 0, .bytes = kittyTransmit("U=1,c=2,r=1,q=2") ++
+ "\x1b[2;3H\x1b[38;2;0;0;7m\u{10EEEE}\u{0305}\u{0305}\u{10EEEE}\u{0305}\u{030D}\x1b[39mX" } });
+ const s = try p.render(frame.allocator());
+ const places = imagePlaces(s);
+ try std.testing.expectEqual(@as(usize, 1), places.len);
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const y = p.bodyTop(pane, r) + 1;
+ try std.testing.expectEqual(pardes.RectCell{ .x = tx + 2, .y = y, .w = 2, .h = 1 }, places[0].dst);
+ try std.testing.expectEqualStrings(" ", s.at(tx + 2, y).grapheme());
+ try std.testing.expectEqualStrings(" ", s.at(tx + 3, y).grapheme());
+ try std.testing.expectEqualStrings("X", s.at(tx + 4, y).grapheme());
+}
+
+test "a terminal's image is a placement whatever the frontend draws, and the Petscii builtin asks for it as glyph art" {
+ if (comptime !images_enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 });
+ defer p.deinit();
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24, .cell_pixels = .{ .w = 10, .h = 20 } } });
+ var frame = std.heap.ArenaAllocator.init(gpa);
+ defer frame.deinit();
+ const pane = p.panes[0].?;
+ pane.body.mode = .tty;
+ p.update(.{ .output = .{ .pane = 0, .bytes = kittyTransmit("c=2,r=1") } });
+ const r = p.view().rects[0];
+ const tx = r.x + config.GUTTER;
+ const y = p.bodyTop(pane, r);
+
+ // A frontend that draws no pixels (a tty under no kitty graphics) is
+ // handed the picture all the same, and the cells under it are its.
+ p.view().frontend.native_images = false;
+ var s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 1), imagePlaces(s).len);
+ try std.testing.expect(!imagePlaces(s)[0].art.glyph);
+ try std.testing.expectEqualStrings(" ", s.at(tx, y).grapheme());
+ try std.testing.expectEqualStrings(" ", s.at(tx + 1, y).grapheme());
+ // The tag says what that frontend draws, glyph art, as an image pane's does.
+ try std.testing.expect(std.mem.indexOf(u8, try tagline.tagPrefix(p, pane), " petscii:on") != null);
+
+ // The builtin flips the pane to glyph art and back.
+ p.view().frontend.native_images = true;
+ try std.testing.expect(p.executeBuiltinLine(0, "Petscii"));
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expectEqual(@as(usize, 1), imagePlaces(s).len);
+ try std.testing.expect(imagePlaces(s)[0].art.glyph);
+ try std.testing.expect(std.mem.indexOf(u8, try tagline.tagPrefix(p, pane), " petscii:on") != null);
+ // Dumped and restored, it still asks for glyph art.
+ try pardes.dump.dumpState(p);
+ const restored = try pardes.dump.restore(p, p.dump_out.?, "/tmp/pardes.dump.zon");
+ defer restored.deinit();
+ try std.testing.expectEqual(@as(?bool, true), petscii(restored.panes[0].?));
+ try std.testing.expect(p.executeBuiltinLine(0, "Petscii"));
+ _ = frame.reset(.retain_capacity);
+ s = try p.render(frame.allocator());
+ try std.testing.expect(!imagePlaces(s)[0].art.glyph);
+}
+
+test "a new terminal draws its program's images as pixels, and one without images says nothing of them" {
+ if (comptime !images_enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 });
+ defer p.deinit();
+ try std.testing.expectEqual(false, petscii(p.panes[0].?).?);
+ // A pane without images says nothing of them.
+ try std.testing.expect(std.mem.indexOf(u8, try tagline.tagPrefix(p, p.panes[0].?), "petscii") == null);
+ const id = p.freeSlot().?;
+ const fresh = try p.newShell(id, "");
+ try std.testing.expectEqual(false, petscii(fresh).?);
+}
+
+test "a program asking the cell size in pixels (CSI 16 t) is told the shell's" {
+ if (comptime !images_enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 });
+ defer p.deinit();
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24, .cell_pixels = .{ .w = 10, .h = 20 } } });
+ var out: std.ArrayList(u8) = .empty;
+ defer out.deinit(gpa);
+ _ = try ptyWritesByPane(p, &out);
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[16t" } });
+ try std.testing.expectEqualStrings("0:\x1b[6;20;10t\n", try ptyWritesByPane(p, &out));
+}
+
+test "colors.xterm is the palette the emulator starts from, all 256" {
+ for (pardes.colors.xterm, ghostty_vt.color.default) |ours, its| try std.testing.expectEqual(ours, [3]u8{ its.r, its.g, its.b });
+}