summaryrefslogtreecommitdiff
path: root/src/tui/tui.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/tui/tui.zig')
-rw-r--r--src/tui/tui.zig4017
1 files changed, 4017 insertions, 0 deletions
diff --git a/src/tui/tui.zig b/src/tui/tui.zig
new file mode 100644
index 00000000..e7fde434
--- /dev/null
+++ b/src/tui/tui.zig
@@ -0,0 +1,4017 @@
+const filesystem = @import("../fs.zig");
+const std = @import("std");
+const builtin = @import("builtin");
+const posix = std.posix;
+const libc = std.c;
+const vaxis = @import("vaxis");
+const pardes = @import("../pardes.zig");
+const vaxis_input = @import("../vaxis_input.zig");
+const dump = @import("../dump.zig");
+const tracy = @import("../tracy.zig");
+const look = @import("../look.zig");
+const message = pardes.Messages.Message;
+const file_watch = @import("../file_watch.zig");
+const selection_pipe = @import("../selection_pipe.zig");
+const ninep_io = @import("../9p_io.zig");
+const panel_compositor = @import("panel_compositor.zig");
+const daemon = @import("../daemon.zig");
+const host_io = @import("../host_io.zig");
+const upgrade = @import("../upgrade.zig");
+const replica = @import("../replica.zig");
+const wire = @import("../detached/wire.zig");
+
+extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
+
+const TIOCSWINSZ: c_int = @bitCast(@as(u32, if (@hasDecl(posix.T, "IOCSWINSZ")) posix.T.IOCSWINSZ else 0x80087467));
+
+/// What a terminal's input reader keeps, one a terminal (views.zig): its
+/// graphemes, the frame it waits on the answer to, the shm probe, and the
+/// view its input is.
+const Feed = struct {
+ view: u8 = 0,
+ cache: vaxis.GraphemeCache = .{},
+ ack: FrameAck = .{},
+ /// The terminal answered the shared-memory probe (`kittyShmProbe`): it
+ /// can read a raster from a POSIX shm object, so a page costs a name on
+ /// the wire instead of its whole base64 body. Set by the input reader,
+ /// which sees the reply before vaxis' parser swallows every graphics APC
+ /// alike.
+ shm: std.atomic.Value(bool) = .init(false),
+ /// Only a reply that arrives while the probe is out counts. The id is
+ /// one vaxis' own image numbering (1, 2, ...) never reaches, because a
+ /// terminal answers every transmission `i=<id>;OK` and one of those must
+ /// not pass.
+ shm_probing: std.atomic.Value(bool) = .init(false),
+};
+
+/// A terminal's input onto the loop's queue, as its view's: a `from` goes
+/// ahead of it whenever another terminal posted last. With one terminal
+/// none ever does.
+const Poster = struct {
+ loop: *Loop,
+ view: u8,
+ var lock: std.Io.Mutex = .init;
+ var last: u8 = 0;
+
+ pub fn postEvent(p: Poster, ev: @TypeOf(Command.value)) !void {
+ lock.lockUncancelable(p.loop.io);
+ defer lock.unlock(p.loop.io);
+ if (last != p.view) {
+ try p.loop.postEvent(.{ .from = p.view });
+ last = p.view;
+ }
+ try p.loop.postEvent(ev);
+ }
+};
+const kitty_shm_probe_id = 0x7fff_fff1;
+var kitty_shm_serial: u32 = 0;
+/// Transmissions an unread shm segment outlives before it is removed.
+const kitty_shm_window = 64;
+
+fn kittyShmName(buf: []u8, n: u32) ![:0]const u8 {
+ return std.fmt.bufPrintSentinel(buf, "/pardes-{d}-{d}", .{ libc.getpid(), n }, 0);
+}
+
+/// A terminal unlinks what it reads; whatever it never read (the probe
+/// unanswered, a transmission lost with the terminal) is ours to remove.
+fn unlinkKittyShm() void {
+ var name_buf: [64]u8 = undefined;
+ var n: u32 = 0;
+ while (n <= kitty_shm_serial) : (n += 1) {
+ if (kittyShmName(&name_buf, n)) |name| _ = libc.shm_unlink(name) else |_| {}
+ }
+}
+
+/// Write `bytes` to a fresh shm object; the terminal unlinks it after reading.
+fn kittyShmWrite(name: [:0]const u8, bytes: []const u8) bool {
+ const fd = libc.shm_open(name, @bitCast(libc.O{ .ACCMODE = .RDWR, .CREAT = true, .EXCL = true }), @as(c_uint, 0o600));
+ if (fd < 0) return false;
+ defer _ = libc.close(fd);
+ if (libc.ftruncate(fd, @intCast(bytes.len)) != 0) {
+ _ = libc.shm_unlink(name);
+ return false;
+ }
+ var off: usize = 0;
+ while (off < bytes.len) {
+ const n = libc.write(fd, bytes[off..].ptr, bytes.len - off);
+ if (n <= 0) {
+ _ = libc.shm_unlink(name);
+ return false;
+ }
+ off += @intCast(n);
+ }
+ return true;
+}
+
+/// Ask with a 1x1 RGB image in shm whether the terminal reads that medium. A
+/// remote terminal cannot see our shm and answers an error (or nothing).
+fn kittyShmProbe(w: *std.Io.Writer, feed: *Feed) void {
+ var buf: [64]u8 = undefined;
+ const name = kittyShmName(&buf, 0) catch return;
+ if (!kittyShmWrite(name, &.{ 0, 0, 0 })) return;
+ var b64: [64]u8 = undefined;
+ const enc = std.base64.standard.Encoder.encode(&b64, name);
+ feed.shm_probing.store(true, .release);
+ w.print("\x1b_Gi={d},s=1,v=1,a=q,t=s,f=24;{s}\x1b\\", .{ kitty_shm_probe_id, enc }) catch return;
+ w.flush() catch {};
+}
+
+pub const Command = struct {
+ pub var value: union(enum) {
+ nop,
+ /// The terminal's input ended: its end of file, a hangup. A session
+ /// a daemon keeps carries on detached; any other ends.
+ quit,
+ /// A terminal for this detached session, and its stub's pipe
+ /// (daemon.Note.attach).
+ attach: struct { tty: posix.fd_t, stub: posix.fd_t },
+ /// A shell a dead session left, its pty's master (daemon.Note.adopted).
+ adopted: struct { pid: posix.pid_t, fd: posix.fd_t },
+ /// A timed wait ran out: the core's next wake has come.
+ wake,
+ /// The input after this is the terminal of this view's (Poster).
+ from: u8,
+ /// A SIGWINCH: a terminal changed size (Shell.winched).
+ winched,
+ /// A SIGHUP: the session's own terminal hung up.
+ hangup,
+ key_press: vaxis.Key,
+ pty_read: struct { id: usize, gen: u32, bytes: []u8 },
+ pty_eof: struct { id: usize, gen: u32 },
+ winsize: vaxis.Winsize,
+ mouse: vaxis.Mouse,
+ focus_in,
+ focus_out,
+ paste: []const u8,
+ paste_start,
+ paste_end,
+ lsp_done: struct { id: u32, rows: ?[]u8 },
+ lsp_status: []u8,
+ pipe_done: selection_pipe.Response,
+ /// A streaming search's rows (pardes.Stream).
+ search_rows: pardes.Stream.Batch,
+ files_changed,
+ fs_ready,
+ /// A replica's connection, handed over by the daemon (Peers).
+ replica: daemon.Joining,
+ /// A replica's reader posted: the step boundary takes it in.
+ replica_mail,
+ /// A replica client's: what the session streamed (replica.Link).
+ said: replica.Said,
+ link_gone,
+ } = .nop;
+};
+const Loop = vaxis.Loop(@TypeOf(Command.value));
+
+fn startInput(loop: *Loop, sc: *Screen) !void {
+ if (comptime builtin.os.tag == .windows) return loop.start();
+ if (sc.thread != null) return;
+ sc.thread = try loop.io.concurrent(inputThread, .{ loop, sc });
+}
+
+fn stopInput(io: std.Io, thread: *?std.Io.Future(void)) void {
+ if (thread.*) |*t| {
+ t.cancel(io);
+ thread.* = null;
+ }
+}
+
+fn inputThread(loop: *Loop, sc: *Screen) void {
+ // vaxis's test terminal reads nothing off Linux: it has no read at all.
+ if (comptime !@hasDecl(vaxis.Tty, "read")) return;
+ inputReader(loop, &sc.tty, &sc.vx, &sc.feed);
+}
+
+fn inputReader(loop: *Loop, tty: anytype, vx: *vaxis.Vaxis, feed: *Feed) void {
+ readInput(loop, tty, vx, feed) catch |err| {
+ if (err == error.Canceled) return;
+ std.log.err("terminal input: {s}", .{@errorName(err)});
+ };
+ (Poster{ .loop = loop, .view = feed.view }).postEvent(.quit) catch {};
+}
+
+fn readInput(loop: *Loop, tty: anytype, vx: *vaxis.Vaxis, feed: *Feed) !void {
+ const post: Poster = .{ .loop = loop, .view = feed.view };
+ try post.postEvent(.{ .winsize = try tty.getWinsize() });
+ var parser: vaxis.Parser = .{};
+ var buf: [1024]u8 = undefined;
+ var carried: usize = 0;
+ while (true) { // stopInput cancels the task; the read then fails with Canceled
+ if (carried == buf.len) return error.InputSequenceTooLong;
+ const received = try tty.read(buf[carried..]);
+ if (received == 0) return;
+ // The terminal's answers to frames (FrameAck) come out first,
+ // wherever they sit: never events, and never glued to a key (an
+ // Escape pressed just before one would read as Alt on it).
+ const end = feed.ack.take(buf[0 .. carried + received], loop);
+ if (end == 0) {
+ carried = 0;
+ continue;
+ }
+ if (feed.shm_probing.load(.acquire)) if (std.mem.indexOf(u8, buf[0..end], std.fmt.comptimePrint("\x1b_Gi={d};", .{kitty_shm_probe_id}))) |at| {
+ feed.shm_probing.store(false, .release);
+ feed.shm.store(std.mem.startsWith(u8, buf[at..end], std.fmt.comptimePrint("\x1b_Gi={d};OK", .{kitty_shm_probe_id})), .release);
+ // Answered either way: a terminal that could not read it left it.
+ var name_buf: [64]u8 = undefined;
+ if (kittyShmName(&name_buf, 0)) |name| _ = libc.shm_unlink(name) else |_| {}
+ };
+ var parse_end = end;
+ var lead = end;
+ while (lead > 0 and buf[lead - 1] & 0xc0 == 0x80) lead -= 1;
+ if (lead > 0) {
+ const scalar_len = std.unicode.utf8ByteSequenceLength(buf[lead - 1]) catch 1;
+ if (scalar_len > end - (lead - 1)) parse_end = lead - 1;
+ }
+ var consumed: usize = 0;
+ // A read that is one ESC and nothing else is the Escape key: a
+ // terminal writes each key's sequence whole and ssh carries each of
+ // its writes whole, so no sequence arrives cut right after its ESC.
+ // Waiting on it cost every Escape press 50 ms on a legacy terminal
+ // (tmux, most ssh sessions), and 1 s before kitty's flags were on.
+ // (A terminal's answer to a frame is one write too: FrameAck.)
+ var waited = carried == 0 and end == 1;
+ while (consumed < parse_end) {
+ // A lone ESC that ends a longer read is the Escape key, or the
+ // first byte of a sequence whose rest the read boundary held
+ // back (an ssh packet, a busy link), which parsed now left the
+ // rest to be typed as text. Wait a moment for more. Under the
+ // kitty keyboard protocol Escape is `CSI 27 u`, so there the ESC
+ // can only start a sequence and the wait can be long.
+ const rest = buf[consumed..parse_end];
+ // A frame's answer cut short by the read waits for its rest.
+ if (parse_end == end and rest.len > 1 and rest.len < FrameAck.answer.len and
+ std.mem.startsWith(u8, FrameAck.answer, rest)) break;
+ if (!waited and parse_end == end and rest[0] == 0x1b and (rest.len == 1 or (rest.len == 2 and rest[1] == 0x1b))) {
+ waited = true;
+ if (try inputFollows(tty, loop.io, if (vx.caps.kitty_keyboard) 1000 else 50)) break;
+ }
+ const result = try parser.parse(buf[consumed..parse_end], vx.opts.system_clipboard_allocator);
+ if (result.n == 0) break;
+ consumed += result.n;
+ // A modifier pressed on its own, which the kitty keyboard
+ // protocol reports: pardes binds none, it would break a pending
+ // chord, and a shell pane was typed its private-use code.
+ if (result.event) |event| if (event == .key_press and event.key_press.isModifier()) continue;
+ if (result.event) |event|
+ vaxis.loop.handleEventGeneric(post, vx, &feed.cache, @TypeOf(Command.value), event, vx.opts.system_clipboard_allocator) catch |err| {
+ if (event == .paste) if (vx.opts.system_clipboard_allocator) |gpa| gpa.free(@constCast(event.paste));
+ return err;
+ };
+ // The last answer to the startup queries is no event of its
+ // own: wake the loop so it takes the capabilities up (pollFrame)
+ // now. Left to the first key, that key paid for the full redraw
+ // they cost, and kitty's keys came in the legacy way till then.
+ if (result.event) |event| if (event == .cap_da1) {
+ _ = loop.tryPostEvent(.nop) catch {};
+ };
+ }
+ carried = end - consumed;
+ std.mem.copyForwards(u8, buf[0..carried], buf[consumed..end]);
+ }
+}
+
+/// One frame in flight at most. Each frame the tty draws ends with a device
+/// status request (`CSI 5 n`), and no other frame is drawn until the
+/// terminal's `CSI 0 n` comes back: over ssh the frames a burst of scrolling
+/// or typing would queue behind each other (sshd's window holds megabytes)
+/// are never drawn, and the burst ends one frame and one round trip after
+/// its last input. On a local terminal the answer is back in well under a
+/// millisecond. A terminal that never answers turns this off for good after
+/// `timeout_ns`.
+const FrameAck = struct {
+ const request = "\x1b[5n";
+ const answer = "\x1b[0n";
+ const timeout_ns: u64 = std.time.ns_per_s;
+ waiting: std.atomic.Value(bool) = .init(false),
+ off: std.atomic.Value(bool) = .init(false),
+ /// When the request went out (the loop's thread only).
+ sent_ns: u64 = 0,
+
+ /// Take every answer out of `bytes`, closing up the rest; the new
+ /// length. The loop is woken for the frame that waited on one.
+ fn take(a: *FrameAck, bytes: []u8, loop: *Loop) usize {
+ var len = bytes.len;
+ var found = false;
+ while (std.mem.indexOf(u8, bytes[0..len], answer)) |at| {
+ std.mem.copyForwards(u8, bytes[at..], bytes[at + answer.len .. len]);
+ len -= answer.len;
+ found = true;
+ }
+ if (found and a.waiting.swap(false, .acq_rel)) loop.postEvent(.nop) catch {};
+ return len;
+ }
+
+ /// Whether a new frame must wait (and the loop has a wake at the
+ /// timeout); past the timeout the terminal is taken to never answer.
+ fn holds(a: *FrameAck, now_ns: u64, io: std.Io) bool {
+ if (a.off.load(.acquire) or !a.waiting.load(.acquire)) return false;
+ const waited_ns = now_ns -| a.sent_ns;
+ if (waited_ns >= timeout_ns) {
+ a.off.store(true, .release);
+ a.waiting.store(false, .release);
+ return false;
+ }
+ requestWake(io, @intCast((timeout_ns - waited_ns + std.time.ns_per_ms - 1) / std.time.ns_per_ms));
+ return true;
+ }
+
+ /// After a frame that wrote something: ask for the answer.
+ fn ask(a: *FrameAck, w: *std.Io.Writer, now_ns: u64) void {
+ if (a.off.load(.acquire)) return;
+ // Waiting before the request goes: a local terminal can answer
+ // before the write returns, and an answer nobody waited for is lost.
+ a.sent_ns = now_ns;
+ a.waiting.store(true, .release);
+ w.writeAll(request) catch return a.waiting.store(false, .release);
+ w.flush() catch return a.waiting.store(false, .release);
+ }
+};
+
+/// Whether more input is readable within `ms`, polled in short slices so
+/// that a cancel of the input thread is still seen. A test reader answers
+/// for itself.
+fn inputFollows(tty: anytype, io: std.Io, ms: u32) !bool {
+ if (@hasDecl(@TypeOf(tty.*), "inputFollows")) return tty.inputFollows(ms);
+ const handle = if (@TypeOf(tty.fd) == std.Io.File) tty.fd.handle else tty.fd;
+ var fds = [_]posix.pollfd{.{ .fd = handle, .events = posix.POLL.IN, .revents = 0 }};
+ var left = ms;
+ while (left > 0) : (left -|= 10) {
+ try io.checkCancel();
+ if (try posix.poll(&fds, @intCast(@min(left, 10))) > 0) return true;
+ }
+ return false;
+}
+
+test "terminal input preserves fragmented keys queries paste and text after EOF" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa });
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ vx.queries_done.store(false, .unordered);
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ const Reader = struct {
+ parts: []const []const u8,
+ next: usize = 0,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(self: *@This(), _: u32) bool {
+ return self.next < self.parts.len;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ if (self.next == self.parts.len) return 0;
+ const part = self.parts[self.next];
+ self.next += 1;
+ @memcpy(buf[0..part.len], part);
+ return part.len;
+ }
+ };
+ var reader: Reader = .{ .parts = &.{
+ "plain \x1b[?62;", "4c\x1b[", "A\x1b[200", "~caf\xc3", "\xa9 \xe7", "\x95",
+ "\x8c \xf0\x9f", "\x98\x80", "\x1b[201", "~\x1b]52;c;Y2", "xpcA==\x07tail", "\x1b",
+ } };
+ try readInput(&loop, &reader, &vx, &feed);
+ try std.testing.expect(vx.queries_done.load(.unordered));
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ var resized = false;
+ var up = false;
+ var in_paste = false;
+ var pasted = false;
+ var clipboard = false;
+ var escape = false;
+ while (try loop.tryEvent()) |event| switch (event) {
+ .winsize => |size| {
+ try std.testing.expect(!resized);
+ resized = true;
+ try std.testing.expectEqual(@as(u16, 80), size.cols);
+ },
+ .key_press => |key| {
+ try std.testing.expect(resized);
+ if (key.codepoint == vaxis.Key.up) {
+ up = true;
+ } else if (key.codepoint == vaxis.Key.escape) {
+ escape = true;
+ } else if (key.text) |bytes| {
+ if (in_paste) try std.testing.expect(up);
+ try text.appendSlice(gpa, bytes);
+ } else return error.UnexpectedInputKey;
+ },
+ .paste_start => {
+ try std.testing.expect(up and !in_paste);
+ in_paste = true;
+ },
+ .paste_end => {
+ try std.testing.expect(in_paste);
+ in_paste = false;
+ pasted = true;
+ },
+ .paste => |bytes| {
+ defer gpa.free(@constCast(bytes));
+ try std.testing.expect(pasted and !in_paste);
+ try std.testing.expectEqualStrings("clip", bytes);
+ clipboard = true;
+ },
+ // The device attributes' wake (a capability answer).
+ .nop => try std.testing.expect(vx.queries_done.load(.unordered)),
+ else => return error.UnexpectedInputEvent,
+ };
+ try std.testing.expectEqualStrings("plain café 界 😀tail", text.items);
+ try std.testing.expect(resized and up and pasted and clipboard and escape);
+}
+
+test "terminal replies and malformed sequences never become typed text" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa });
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ vx.queries_done.store(false, .unordered);
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ const Reader = struct {
+ parts: []const []const u8,
+ next: usize = 0,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(self: *@This(), _: u32) bool {
+ return self.next < self.parts.len;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ if (self.next == self.parts.len) return 0;
+ const part = self.parts[self.next];
+ self.next += 1;
+ @memcpy(buf[0..part.len], part);
+ return part.len;
+ }
+ };
+ var reader: Reader = .{
+ .parts = &.{
+ // The startup width queries' answers where the terminal has no
+ // explicit width: both used to arrive as a bare F3, typed as text.
+ "a\x1b[1;1R\x1b[1;1R",
+ // A late report somewhere else on the screen, and DECXCPR.
+ "\x1b[12;40R\x1b[?3;7;1R",
+ // rxvt's Alt+Up: ESC before the sequence, not Alt+Esc then `[A`.
+ "b\x1b\x1b[A",
+ // A kitty graphics reply cut inside its ST sliced past its input.
+ "\x1b_Gi=1;OK\x1b",
+ "\\",
+ // An X10 mouse report cut after `CSI M` left three bytes as text.
+ "\x1b[M",
+ " !!",
+ // Malformed color and clipboard replies failed the parse, which
+ // ended input altogether; and a reply ended by BEL ran on to the
+ // next sequence's ESC, leaving what lay between as text.
+ "\x1b]11;rgb:zz/zz/zz\x1b\\\x1b]52;c;!!!!\x07\x1b]52\x07",
+ // Device reports whose fields end early.
+ "\x1b[?1;y\x1b[?997;n\x1b[c",
+ "\x1b[?62;c",
+ "c",
+ },
+ };
+ try readInput(&loop, &reader, &vx, &feed);
+ try std.testing.expect(vx.queries_done.load(.unordered));
+ try std.testing.expect(vx.caps.kitty_graphics);
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ var alt_up = false;
+ var clicked = false;
+ while (try loop.tryEvent()) |event| switch (event) {
+ .winsize => {},
+ .key_press => |key| {
+ if (key.codepoint == vaxis.Key.up and key.mods.alt) {
+ alt_up = true;
+ } else if (key.text) |bytes| {
+ try text.appendSlice(gpa, bytes);
+ } else return error.UnexpectedInputKey;
+ },
+ .mouse => |mouse| {
+ try std.testing.expectEqual(@as(i16, 0), mouse.col);
+ clicked = true;
+ },
+ .nop => {}, // the device attributes' wake
+ else => return error.UnexpectedInputEvent,
+ };
+ try std.testing.expectEqualStrings("abc", text.items);
+ try std.testing.expect(alt_up and clicked);
+}
+
+test "terminal input split at every byte with a gap reads as it does whole" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa });
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ // Two reads with `gap_ms` between them, as an ssh link delivers a
+ // sequence cut across two packets.
+ const Reader = struct {
+ parts: [2][]const u8,
+ gap_ms: u32,
+ next: usize = 0,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(self: *@This(), ms: u32) bool {
+ return self.next < self.parts.len and self.gap_ms <= ms;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ while (self.next < self.parts.len) {
+ const part = self.parts[self.next];
+ self.next += 1;
+ if (part.len == 0) continue;
+ @memcpy(buf[0..part.len], part);
+ return part.len;
+ }
+ return 0;
+ }
+ /// What the loop was handed, one line per event.
+ fn events(l: *Loop, out: *std.ArrayList(u8)) !void {
+ out.clearRetainingCapacity();
+ while (try l.tryEvent()) |event| switch (event) {
+ .winsize => {},
+ .key_press => |k| try out.print(std.testing.allocator, "key {d} {d} {?s}\n", .{ k.codepoint, @as(u8, @bitCast(k.mods)), k.text }),
+ .mouse => |m| try out.print(std.testing.allocator, "mouse {d} {d} {t} {t}\n", .{ m.col, m.row, m.button, m.type }),
+ .paste => |bytes| {
+ try out.print(std.testing.allocator, "paste {s}\n", .{bytes});
+ std.testing.allocator.free(@constCast(bytes));
+ },
+ else => |other| try out.print(std.testing.allocator, "{t}\n", .{other}),
+ };
+ }
+ };
+ const Case = struct { bytes: []const u8, kitty: bool = false };
+ const cases = [_]Case{
+ .{ .bytes = "\x1b[118;5u", .kitty = true }, // Ctrl-V
+ .{ .bytes = "\x1b[97;;97u", .kitty = true }, // a, with its text
+ .{ .bytes = "\x1b[57442;5u", .kitty = true }, // Ctrl on its own
+ .{ .bytes = "\x1b[27u", .kitty = true }, // Escape
+ .{ .bytes = "\x1b[A" },
+ .{ .bytes = "\x1bOA" },
+ .{ .bytes = "\x1b[3;5~" },
+ .{ .bytes = "\x1b\x1b[A" },
+ // Four wheel notches: cut at a `;` with 60 ms between the halves,
+ // ssh's framing lost all four.
+ .{ .bytes = "\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M" },
+ .{ .bytes = "\x1b[200~pasted\x1b[201~" },
+ .{ .bytes = "\x1b]52;c;Y2xpcA==\x1b\\" },
+ .{ .bytes = "\x1b_Gi=1;OK\x1b\\" },
+ .{ .bytes = "\x1bP>|kitty(0.40)\x1b\\" },
+ };
+ var whole: std.ArrayList(u8) = .empty;
+ defer whole.deinit(gpa);
+ var split: std.ArrayList(u8) = .empty;
+ defer split.deinit(gpa);
+ for (cases) |case| {
+ vx.caps.kitty_keyboard = case.kitty;
+ const all = try std.mem.concat(gpa, u8, &.{ "x", case.bytes, "y" });
+ defer gpa.free(all);
+ var one: Reader = .{ .parts = .{ all, "" }, .gap_ms = 0 };
+ try readInput(&loop, &one, &vx, &feed);
+ try Reader.events(&loop, &whole);
+ for (1..all.len) |cut| {
+ // A cut just after an ESC is the one that has to wait, and a
+ // legacy terminal's Escape waits only 50 ms: 40 ms there. A cut
+ // anywhere else is carried however long the gap.
+ const after_esc = all[cut - 1] == 0x1b;
+ var two: Reader = .{ .parts = .{ all[0..cut], all[cut..] }, .gap_ms = if (after_esc and !case.kitty) 40 else 60 };
+ try readInput(&loop, &two, &vx, &feed);
+ try Reader.events(&loop, &split);
+ std.testing.expectEqualStrings(whole.items, split.items) catch |err| {
+ std.debug.print("case {f} cut at {d}\n", .{ std.ascii.hexEscape(case.bytes, .lower), cut });
+ return err;
+ };
+ }
+ }
+ vx.caps.kitty_keyboard = false;
+}
+
+test "an ESC read by itself is the Escape key at once" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{});
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ // More always follows at once: a reader that waited on the ESC would
+ // take `j` for the rest of its sequence (Alt-j).
+ const Reader = struct {
+ parts: []const []const u8,
+ next: usize = 0,
+ asked: bool = false,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(self: *@This(), _: u32) bool {
+ self.asked = true;
+ return self.next < self.parts.len;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ if (self.next == self.parts.len) return 0;
+ const part = self.parts[self.next];
+ self.next += 1;
+ @memcpy(buf[0..part.len], part);
+ return part.len;
+ }
+ };
+ for ([_]bool{ false, true }) |kitty| {
+ vx.caps.kitty_keyboard = kitty;
+ var reader: Reader = .{ .parts = &.{ "\x1b", "j" } };
+ try readInput(&loop, &reader, &vx, &feed);
+ try std.testing.expect(!reader.asked);
+ try std.testing.expectEqual(.winsize, std.meta.activeTag((try loop.tryEvent()).?));
+ const escape = (try loop.tryEvent()).?.key_press;
+ try std.testing.expectEqual(vaxis.Key.escape, escape.codepoint);
+ try std.testing.expect(!escape.mods.alt);
+ const j = (try loop.tryEvent()).?.key_press;
+ try std.testing.expectEqual(@as(u21, 'j'), j.codepoint);
+ try std.testing.expect(!j.mods.alt);
+ try std.testing.expect(try loop.tryEvent() == null);
+ }
+ vx.caps.kitty_keyboard = false;
+}
+
+test "a frame's answer is taken wherever the reads cut it, and never typed" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{});
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ const Reader = struct {
+ parts: [2][]const u8,
+ next: usize = 0,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(self: *@This(), _: u32) bool {
+ return self.next < self.parts.len;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ while (self.next < self.parts.len) {
+ const part = self.parts[self.next];
+ self.next += 1;
+ if (part.len == 0) continue;
+ @memcpy(buf[0..part.len], part);
+ return part.len;
+ }
+ return 0;
+ }
+ };
+ const all = "x" ++ FrameAck.answer ++ "y";
+ defer feed.ack.waiting.store(false, .release);
+ for (0..all.len) |cut| {
+ feed.ack.waiting.store(true, .release);
+ var reader: Reader = .{ .parts = .{ all[0..cut], all[cut..] } };
+ try readInput(&loop, &reader, &vx, &feed);
+ try std.testing.expect(!feed.ack.waiting.load(.acquire));
+ var typed: std.ArrayList(u8) = .empty;
+ defer typed.deinit(gpa);
+ var woke = false;
+ while (try loop.tryEvent()) |event| switch (event) {
+ .winsize => {},
+ .nop => woke = true,
+ .key_press => |key| try typed.appendSlice(gpa, key.text orelse return error.UnexpectedInputKey),
+ else => return error.UnexpectedInputEvent,
+ };
+ std.testing.expectEqualStrings("xy", typed.items) catch |err| {
+ std.debug.print("cut at {d}\n", .{cut});
+ return err;
+ };
+ try std.testing.expect(woke);
+ }
+ // An Escape pressed just before an answer, in the same read, is the
+ // Escape key, not Alt on the answer.
+ feed.ack.waiting.store(true, .release);
+ var glued: Reader = .{ .parts = .{ "\x1b" ++ FrameAck.answer, "j" } };
+ try readInput(&loop, &glued, &vx, &feed);
+ try std.testing.expectEqual(.winsize, std.meta.activeTag((try loop.tryEvent()).?));
+ try std.testing.expectEqual(.nop, std.meta.activeTag((try loop.tryEvent()).?));
+ const escape = (try loop.tryEvent()).?.key_press;
+ try std.testing.expectEqual(vaxis.Key.escape, escape.codepoint);
+ try std.testing.expect(!escape.mods.alt);
+ try std.testing.expectEqual(@as(u21, 'j'), (try loop.tryEvent()).?.key_press.codepoint);
+ try std.testing.expect(try loop.tryEvent() == null);
+}
+
+test "a terminal that never answers a frame stops being asked after one timeout" {
+ const io = std.testing.io;
+ var ack: FrameAck = .{};
+ var out: std.Io.Writer.Allocating = .init(std.testing.allocator);
+ defer out.deinit();
+ const t0: u64 = 5 * std.time.ns_per_s;
+ ack.ask(&out.writer, t0);
+ try std.testing.expectEqualStrings(FrameAck.request, out.written());
+ // Unanswered: the next frame waits, until the timeout.
+ try std.testing.expect(ack.holds(t0 + 10 * std.time.ns_per_ms, io));
+ try std.testing.expect(ack.holds(t0 + 999 * std.time.ns_per_ms, io));
+ try std.testing.expect(!ack.holds(t0 + FrameAck.timeout_ns, io));
+ // Then never again: no request, no wait.
+ out.clearRetainingCapacity();
+ ack.ask(&out.writer, t0 + 2 * std.time.ns_per_s);
+ try std.testing.expectEqual(@as(usize, 0), out.written().len);
+ try std.testing.expect(!ack.holds(t0 + 2 * std.time.ns_per_s, io));
+}
+
+test "terminal input cancellation joins blocked reads and queued EOF" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{});
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ const Reader = struct {
+ file: std.Io.File,
+ eof: bool,
+ entered: std.Io.Event = .unset,
+ release: std.Io.Event = .unset,
+ returned: std.Io.Event = .unset,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(_: *@This(), _: u32) bool {
+ return false;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ self.entered.set(std.testing.io);
+ if (self.eof) {
+ try self.release.wait(std.testing.io);
+ self.returned.set(std.testing.io);
+ return 0;
+ }
+ return self.file.readStreaming(std.testing.io, &.{buf});
+ }
+ fn run(loop: *Loop, reader: *@This(), vx_: *vaxis.Vaxis, feed: *Feed) void {
+ inputReader(loop, reader, vx_, feed);
+ }
+ };
+ const Case = enum { blocked_read, cancel_eof, deliver_eof };
+ for (std.enums.values(Case)) |case| {
+ const eof = case != .blocked_read;
+ var fds: [2]c_int = undefined;
+ if (libc.pipe(&fds) != 0) return error.PipeFailed;
+ defer _ = libc.close(fds[0]);
+ defer _ = libc.close(fds[1]);
+ var reader: Reader = .{ .file = .{ .handle = fds[0], .flags = .{ .nonblocking = false } }, .eof = eof };
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ var thread: ?std.Io.Future(void) = try io.concurrent(Reader.run, .{ &loop, &reader, &vx, &feed });
+ defer stopInput(io, &thread);
+ try std.testing.expectEqual(.winsize, std.meta.activeTag(try loop.nextEvent()));
+ try reader.entered.wait(io);
+ if (eof) {
+ for (0..512) |_| try loop.postEvent(.nop);
+ reader.release.set(io);
+ try reader.returned.wait(io);
+ }
+ if (case == .deliver_eof) {
+ try std.testing.expectEqual(.nop, std.meta.activeTag(try loop.nextEvent()));
+ thread.?.await(io);
+ }
+ stopInput(io, &thread);
+ try std.testing.expect(thread == null);
+ var count: usize = 0;
+ while (try loop.tryEvent()) |event| {
+ const expected: std.meta.Tag(@TypeOf(Command.value)) = if (case == .deliver_eof and count == 511) .quit else .nop;
+ try std.testing.expectEqual(expected, std.meta.activeTag(event));
+ count += 1;
+ }
+ try std.testing.expectEqual(@as(usize, if (eof) 512 else 0), count);
+ }
+}
+
+const PipeTasks = selection_pipe.Tasks;
+
+const Pty = struct {
+ file: std.Io.File,
+ pid: posix.pid_t,
+ reader: std.Io.Future(anyerror!void),
+ /// A command pane's child, watched to its exit (host_io.watchExit);
+ /// the pty stays open until both its end of file and its exit.
+ cmd: host_io.CommandWatch = .{},
+};
+
+/// A watched child exited: wake the loop, which takes it (`takeExits`).
+fn wakeForExit(ctx: ?*anyopaque) void {
+ const loop: *Loop = @ptrCast(@alignCast(ctx.?));
+ _ = loop.tryPostEvent(.nop) catch {};
+}
+
+const KittyPlacement = struct {
+ cell_x: u16,
+ cell_y: u16,
+ cell_cols: u16,
+ cell_rows: u16,
+ options: vaxis.Image.DrawOptions,
+};
+
+fn terminalCellPixels(total_pixels: u16, cells: u16, fallback: u32) u32 {
+ if (total_pixels == 0 or cells == 0) return fallback;
+ return @max(1, @as(u32, total_pixels) / cells);
+}
+
+fn updateCoreTerminalSize(core: *pardes.Pardes, cols: u16, rows: u16, pixel_w: u16, pixel_h: u16) void {
+ core.update(.{ .resize = terminalSize(cols, rows, pixel_w, pixel_h) });
+}
+
+fn terminalSize(cols: u16, rows: u16, pixel_w: u16, pixel_h: u16) @FieldType(pardes.Event, "resize") {
+ return .{
+ .cols = cols,
+ .rows = rows,
+ .cell_pixels = .{
+ .w = @intCast(terminalCellPixels(pixel_w, cols, 8)),
+ .h = @intCast(terminalCellPixels(pixel_h, rows, 16)),
+ },
+ };
+}
+
+/// A terminal pane's image fragment (`native.exact`): its `src` into its
+/// `dst`, inside one cell row. Kitty scales a source rectangle to whole
+/// cells, so the source is trimmed to the cells' scale rather than the
+/// picture stretched: a fragment loses under a cell at its right edge.
+/// A full row is declared one row high; a part of one (an image's top or
+/// bottom edge) only its columns, its height then following the source.
+fn exactKittyPlacement(
+ place: pardes.ImagePlace,
+ screen_cols: u16,
+ screen_rows: u16,
+ screen_pixel_w: u16,
+ screen_pixel_h: u16,
+) ?KittyPlacement {
+ if (comptime !pardes.pdf_enabled) return null;
+ const g = place.native.geometry orelse return null;
+ const cell_w = terminalCellPixels(screen_pixel_w, screen_cols, 8);
+ const cell_h = terminalCellPixels(screen_pixel_h, screen_rows, 16);
+ if (g.dst.w == 0 or g.dst.h == 0 or g.src.w == 0 or g.src.h == 0) return null;
+ const cell_x = g.dst.x / cell_w;
+ const pixel_x = g.dst.x % cell_w;
+ const pixel_y = @min(g.dst.y, cell_h - 1);
+ const cols: u32 = @max(1, (g.dst.w + cell_w / 2) / cell_w);
+ if (cell_x >= place.w) return null;
+ const declared_w = cols * cell_w;
+ // At the cells' scale, the source that fills `cols` cells.
+ var src_w = g.src.w;
+ if (declared_w < g.dst.w) src_w = @max(1, @as(u32, @intCast(@as(u64, g.src.w) * declared_w / g.dst.w)));
+ var src_h = g.src.h;
+ const full = g.dst.y == 0 and g.dst.h >= cell_h;
+ if (!full) {
+ // As tall as it is at that scale, and no taller than the row.
+ const room = cell_h - pixel_y;
+ const fits: u32 = @intCast(@as(u64, room) * src_w / declared_w);
+ if (fits == 0) return null;
+ src_h = @min(src_h, fits);
+ }
+ return .{
+ .cell_x = std.math.cast(u16, cell_x) orelse return null,
+ .cell_y = 0,
+ .cell_cols = std.math.cast(u16, @min(@as(u32, place.w) - cell_x, (pixel_x + declared_w + cell_w - 1) / cell_w)) orelse return null,
+ .cell_rows = 1,
+ .options = .{
+ .clip_region = .{
+ .x = std.math.cast(u16, g.src.x) orelse return null,
+ .y = std.math.cast(u16, g.src.y) orelse return null,
+ .width = std.math.cast(u16, src_w) orelse return null,
+ .height = std.math.cast(u16, src_h) orelse return null,
+ },
+ .pixel_offset = if (pixel_x != 0 or pixel_y != 0) .{ .x = @intCast(pixel_x), .y = @intCast(pixel_y) } else null,
+ // The outer terminal stacks them, under the text below 0.
+ .z_index = if (place.z != 0) place.z else null,
+ .size = if (full)
+ .{ .cols = std.math.cast(u16, cols) orelse return null, .rows = 1 }
+ else
+ .{ .cols = std.math.cast(u16, cols) orelse return null },
+ },
+ };
+}
+
+fn kittyPlacement(
+ place: pardes.ImagePlace,
+ screen_cols: u16,
+ screen_rows: u16,
+ screen_pixel_w: u16,
+ screen_pixel_h: u16,
+) ?KittyPlacement {
+ if (comptime pardes.pdf_enabled) {
+ if (place.native.fit == .contain) return null;
+ const cell_w = terminalCellPixels(screen_pixel_w, screen_cols, 8);
+ const cell_h = terminalCellPixels(screen_pixel_h, screen_rows, 16);
+ const body_w = std.math.mul(u32, place.w, cell_w) catch return null;
+ const body_h = std.math.mul(u32, place.h, cell_h) catch return null;
+ const geometry = place.native.geometry orelse pardes.image.nativeGeometry(
+ place.iw,
+ place.ih,
+ body_w,
+ body_h,
+ place.native.fit,
+ place.native.pan_x,
+ place.native.pan_y,
+ ) orelse return null;
+
+ const safe_rows_u32 = geometry.dst.h / cell_h;
+ if (safe_rows_u32 == 0) return null;
+ const safe_pixel_h = safe_rows_u32 * cell_h;
+ var safe_src_h: u32 = geometry.src.h;
+ var declared_cols: u32 = 0;
+ var declared_rows: u32 = 0;
+ switch (place.native.fit) {
+ .width => {
+ declared_cols = @intCast(@max(
+ @as(u64, 1),
+ (@as(u64, geometry.dst.w) + cell_w - 1) / cell_w,
+ ));
+ const declared_pixel_w = @as(u64, declared_cols) * cell_w;
+ const max_src_h: u32 = @intCast(
+ @as(u64, safe_pixel_h) * geometry.src.w / declared_pixel_w,
+ );
+ if (max_src_h == 0) return null;
+ safe_src_h = @min(safe_src_h, max_src_h);
+ const aspect_pixel_h: u32 = @intCast(
+ (@as(u64, safe_src_h) * declared_pixel_w + geometry.src.w - 1) /
+ geometry.src.w,
+ );
+ declared_rows = @intCast(
+ (@as(u64, aspect_pixel_h) + cell_h - 1) / cell_h,
+ );
+ },
+ .height => {
+ declared_rows = safe_rows_u32;
+ safe_src_h = @max(@as(u32, 1), @as(u32, @intCast(
+ @as(u64, safe_pixel_h) * geometry.src.h / geometry.dst.h,
+ )));
+ safe_src_h = @min(safe_src_h, geometry.src.h);
+ const aspect_pixel_w: u32 = @intCast(
+ (@as(u64, geometry.src.w) * safe_pixel_h + safe_src_h - 1) /
+ safe_src_h,
+ );
+ declared_cols = @intCast(
+ (@as(u64, aspect_pixel_w) + cell_w - 1) / cell_w,
+ );
+ },
+ .contain => unreachable,
+ }
+ if (declared_rows == 0 or declared_rows > safe_rows_u32) return null;
+
+ const src_x = std.math.cast(u16, geometry.src.x) orelse return null;
+ const src_y = std.math.cast(u16, geometry.src.y) orelse return null;
+ const src_w = std.math.cast(u16, geometry.src.w) orelse return null;
+ const src_h = std.math.cast(u16, safe_src_h) orelse return null;
+ const cell_x = std.math.cast(u16, geometry.dst.x / cell_w) orelse return null;
+ const cell_y = std.math.cast(u16, geometry.dst.y / cell_h) orelse return null;
+ if (cell_x >= place.w or cell_y >= place.h) return null;
+ const pixel_x = std.math.cast(u16, geometry.dst.x % cell_w) orelse return null;
+ const pixel_y = std.math.cast(u16, geometry.dst.y % cell_h) orelse return null;
+ const cell_cols = std.math.cast(u16, @min(
+ @as(u32, place.w - cell_x),
+ (@as(u64, pixel_x) + @as(u64, declared_cols) * cell_w + cell_w - 1) / cell_w,
+ )) orelse return null;
+ const cell_rows = std.math.cast(u16, @min(
+ @as(u32, place.h - cell_y),
+ (@as(u64, pixel_y) + declared_rows * cell_h + cell_h - 1) / cell_h,
+ )) orelse return null;
+ if (cell_cols == 0 or cell_rows == 0) return null;
+
+ return .{
+ .cell_x = cell_x,
+ .cell_y = cell_y,
+ .cell_cols = cell_cols,
+ .cell_rows = cell_rows,
+ .options = .{
+ .clip_region = .{ .x = src_x, .y = src_y, .width = src_w, .height = src_h },
+ .pixel_offset = if (pixel_x != 0 or pixel_y != 0) .{ .x = pixel_x, .y = pixel_y } else null,
+ .size = switch (place.native.fit) {
+ .width => .{ .cols = std.math.cast(u16, declared_cols) orelse return null },
+ .height => .{ .rows = std.math.cast(u16, declared_rows) orelse return null },
+ .contain => unreachable,
+ },
+ },
+ };
+ } else {
+ return null;
+ }
+}
+
+test "a terminal's image fragment goes to kitty cropped to its cells' scale, a full row one row high" {
+ if (comptime !pardes.pdf_enabled) return;
+ var place = pardes.ImagePlace{
+ .pane = 0,
+ .serial = 3,
+ .native = .{ .page = 7, .exact = true, .geometry = .{
+ .src = .{ .x = 0, .y = 40, .w = 240, .h = 20 },
+ .dst = .{ .x = 0, .y = 0, .w = 240, .h = 20 },
+ } },
+ .x = 99,
+ .y = 4,
+ .w = 24,
+ .h = 1,
+ .rgba = &.{},
+ .iw = 240,
+ .ih = 160,
+ };
+ // 10x20 pixel cells: a whole row, one to one.
+ const full = exactKittyPlacement(place, 100, 30, 1000, 600).?;
+ try std.testing.expectEqual(@as(u16, 0), full.cell_x);
+ try std.testing.expectEqual(@as(?u16, 24), full.options.size.?.cols);
+ try std.testing.expectEqual(@as(?u16, 1), full.options.size.?.rows);
+ try std.testing.expectEqual(@as(?u16, 40), full.options.clip_region.?.y);
+ try std.testing.expectEqual(@as(?u16, 240), full.options.clip_region.?.width);
+ try std.testing.expect(full.options.pixel_offset == null);
+
+ // The top of a letterboxed picture: 7 pixels down into the row, 13
+ // tall, 35 pixels in, 205 wide, which rounds to 21 cells. Its columns
+ // only, its source no taller than the 13 pixels left in the row at
+ // that scale.
+ place.native.geometry = .{
+ .src = .{ .x = 0, .y = 0, .w = 205, .h = 13 },
+ .dst = .{ .x = 35, .y = 7, .w = 205, .h = 13 },
+ };
+ const top = exactKittyPlacement(place, 100, 30, 1000, 600).?;
+ try std.testing.expectEqual(@as(u16, 3), top.cell_x);
+ try std.testing.expectEqual(@as(u16, 5), top.options.pixel_offset.?.x);
+ try std.testing.expectEqual(@as(u16, 7), top.options.pixel_offset.?.y);
+ try std.testing.expectEqual(@as(?u16, 21), top.options.size.?.cols);
+ try std.testing.expectEqual(@as(?u16, null), top.options.size.?.rows);
+ const w = top.options.clip_region.?.width.?;
+ const h = top.options.clip_region.?.height.?;
+ try std.testing.expectEqual(@as(u16, 205), w);
+ try std.testing.expect(h > 0 and @as(u32, h) * 210 / w <= 13);
+
+ // Narrower than its cells round to: the source is cut to their scale.
+ place.native.geometry = .{
+ .src = .{ .x = 0, .y = 0, .w = 400, .h = 40 },
+ .dst = .{ .x = 0, .y = 0, .w = 204, .h = 20 },
+ };
+ const cut = exactKittyPlacement(place, 100, 30, 1000, 600).?;
+ try std.testing.expectEqual(@as(?u16, 20), cut.options.size.?.cols);
+ try std.testing.expectEqual(@as(?u16, 392), cut.options.clip_region.?.width);
+}
+
+test "Kitty PDF fragments never declare pixels beyond their clipped bottom" {
+ if (comptime !pardes.pdf_enabled) return;
+
+ const base = pardes.ImagePlace{
+ .pane = 0,
+ .serial = 1,
+ .native = .{
+ .revision = 1,
+ .page = 0,
+ .fit = .width,
+ .geometry = .{
+ .src = .{ .w = 96, .h = 10 },
+ .dst = .{ .y = 195, .w = 304, .h = 29 },
+ },
+ },
+ .x = 0,
+ .y = 0,
+ .w = 38,
+ .h = 14,
+ .rgba = &.{},
+ .iw = 96,
+ .ih = 64,
+ };
+ const width = kittyPlacement(base, 80, 16, 640, 256) orelse
+ return error.MissingSafeKittyWidthFragment;
+ const width_clip = width.options.clip_region.?;
+ const width_size = width.options.size.?;
+ try std.testing.expectEqual(@as(u16, 5), width_clip.height.?);
+ try std.testing.expectEqual(@as(u16, 38), width_size.cols.?);
+ try std.testing.expectEqual(@as(u16, 3), width.options.pixel_offset.?.y);
+ const aspect_pixels = (@as(u32, width_size.cols.?) * 8 * width_clip.height.? +
+ width_clip.width.? - 1) / width_clip.width.?;
+ const inferred_rows = (aspect_pixels + 15) / 16;
+ try std.testing.expect(inferred_rows * 16 <= base.native.geometry.?.dst.h);
+
+ var height = base;
+ height.native.fit = .height;
+ height.native.geometry.?.src.h = 9;
+ const height_fragment = kittyPlacement(height, 80, 16, 640, 256) orelse
+ return error.MissingSafeKittyHeightFragment;
+ try std.testing.expectEqual(@as(u16, 1), height_fragment.options.size.?.rows.?);
+ try std.testing.expect(@as(u32, height_fragment.options.size.?.rows.?) * 16 <=
+ height.native.geometry.?.dst.h);
+
+ height.native.geometry.?.dst.h = 13;
+ try std.testing.expect(kittyPlacement(height, 80, 16, 640, 256) == null);
+}
+
+test "host watch closes initial race and reloads rename-over PDF while idle" {
+ if (comptime !file_watch.supported or !pardes.pdf_enabled) return;
+ const io = std.testing.io;
+ const gpa = std.testing.allocator;
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ const original = try pardes.pdf.makeOutlineTestPdf(gpa);
+ defer gpa.free(original);
+ const replacement = try pardes.pdf.makeNoOutlineTestPdf(gpa);
+ defer gpa.free(replacement);
+ try tmp.dir.writeFile(io, .{ .sub_path = "live.pdf", .data = original });
+ try tmp.dir.writeFile(io, .{ .sub_path = "initial.pdf", .data = replacement });
+ try tmp.dir.writeFile(io, .{ .sub_path = "live-replacement.pdf", .data = original });
+ var path_buf: [256]u8 = undefined;
+ const path = try std.fmt.bufPrint(&path_buf, ".zig-cache/tmp/{s}/live.pdf", .{tmp.sub_path});
+
+ const fd = file_watch.init(true);
+ if (fd < 0) return error.WatchInitFailed;
+ defer _ = libc.close(fd);
+ var watches: file_watch.Table = @splat(null);
+ defer for (0..pardes.MAX_PANES) |id| file_watch.watchPane(
+ fd,
+ &watches,
+ @intCast(id),
+ null,
+ 0,
+ .{ .text = 0 },
+ );
+
+ const core = try pardes.Pardes.init(gpa, .{ .file = path, .cols = 80, .rows = 28 });
+ defer core.deinit();
+ try std.testing.expectEqual(@as(usize, 3), core.panes[0].?.pdf.?.page_count);
+
+ try tmp.dir.rename("initial.pdf", tmp.dir, "live.pdf", io);
+ var armed = false;
+ while (core.nextEffect()) |effect| switch (effect) {
+ .watch => |watch| if (watch.pane == 0 and watch.on) {
+ armed = true;
+ try std.testing.expect(!file_watch.applyEffect(core, io, fd, &watches, 0, true, watch.mode));
+ },
+ else => {},
+ };
+ try std.testing.expect(armed and watches[0] != null);
+ try std.testing.expectEqual(@as(usize, 1), core.panes[0].?.pdf.?.page_count);
+
+ try tmp.dir.rename("live-replacement.pdf", tmp.dir, "live.pdf", io);
+ try std.testing.expect(file_watch.drain(fd));
+
+ try std.testing.expect(!file_watch.reloadChanged(core, io, gpa, &watches));
+ const pane = core.panes[0].?;
+ try std.testing.expectEqual(@as(usize, 3), pane.pdf.?.page_count);
+ const disk_identity = try file_watch.identify(io, path);
+ switch (watches[0].?.generation) {
+ .pdf => |accepted| try std.testing.expect(accepted != null and accepted.?.eql(disk_identity)),
+ .text => return error.PdfWatchStoredTextGeneration,
+ }
+ try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "reloaded") != null);
+
+ core.native_images = true;
+ var frame = std.heap.ArenaAllocator.init(gpa);
+ defer frame.deinit();
+ const surface = try core.render(frame.allocator());
+ try std.testing.expect(surface.nimages > 0);
+ try std.testing.expectEqual(@as(u32, 0), surface.images[0].?.native.page);
+}
+
+fn kittyImageRepresentable(place: pardes.ImagePlace) bool {
+ return place.iw > 0 and place.ih > 0 and
+ place.iw <= std.math.maxInt(u16) and place.ih <= std.math.maxInt(u16);
+}
+
+fn surfaceHasKittyKey(surface: *const pardes.Surface, key: pardes.ImageCacheKey) bool {
+ for (surface.images[0..surface.nimages]) |maybe| {
+ const place = maybe orelse continue;
+ if (comptime pardes.pdf_enabled) if (!kittyImageRepresentable(place)) continue;
+ if (place.cacheKey().eql(key)) return true;
+ }
+ return false;
+}
+
+const PdfWheelTarget = struct { pane: usize, page: usize };
+
+fn nativePdfWheelTarget(core: *const pardes.Pardes, mouse: vaxis.Mouse) ?PdfWheelTarget {
+ if (comptime !pardes.pdf_enabled) return null;
+ if (!core.native_images or mouse.type != .press or
+ (mouse.button != .wheel_up and mouse.button != .wheel_down) or
+ mouse.col < 0 or mouse.row < 0) return null;
+ const col: u16 = @intCast(mouse.col);
+ const row: u16 = @intCast(mouse.row);
+ for (core.panes, 0..) |slot, id| {
+ const pane = slot orelse continue;
+ const rect = core.rects[id];
+ if (col < rect.x or col >= rect.x + rect.w or
+ row < rect.y or row >= rect.y + rect.h) continue;
+ const page = pane.pdfPage() orelse return null;
+ return .{ .pane = id, .page = page };
+ }
+ return null;
+}
+
+/// Where a session's terminal comes from: /dev/tty, as a plain `pardes`
+/// opens it; one open already (a session forked off its stub,
+/// daemon.forkSession); or none, until one is attached (`--detach`).
+/// The terminal a session starts on: /dev/tty, one its stub opened (an
+/// upgraded session's is raw already, `termios` the cooked one), or none.
+pub const Term = union(enum) { open, fd: struct { fd: posix.fd_t, termios: ?posix.termios = null }, none };
+
+pub fn run(init: std.process.Init, opts: pardes.Options, term: Term) !void {
+ const io = init.io;
+ const gpa = init.gpa;
+
+ var winch_set = posix.sigemptyset();
+ posix.sigaddset(&winch_set, posix.SIG.WINCH);
+ // Kept by a daemon, a hangup is the terminal's end, not the session's:
+ // winchWatch takes it, and the session carries on detached.
+ if (daemon.link >= 0) posix.sigaddset(&winch_set, posix.SIG.HUP);
+ // FreeBSD drops a signal whose action is to be ignored (WINCH's
+ // default) as it is sent, sigwait or not: a handler keeps it.
+ if (comptime builtin.os.tag == .freebsd)
+ posix.sigaction(.WINCH, &.{ .handler = .{ .handler = keepSignal }, .mask = posix.sigemptyset(), .flags = 0 }, null);
+ posix.sigprocmask(posix.SIG.BLOCK, &winch_set, null);
+
+ var tty_buf: [0x10000]u8 = undefined;
+ var screen: Screen = .{ .io = io, .gpa = gpa, .env = init.environ_map, .buf = &tty_buf, .kitty = .init(gpa), .primary = true };
+ defer screen.kitty.deinit();
+ switch (term) {
+ .open => try screen.enter(try vaxis.Tty.init(io, &tty_buf)),
+ .fd => |t| try screen.enter(try Screen.ttyOn(io, &tty_buf, t.fd, t.termios)),
+ .none => {},
+ }
+ defer screen.leave();
+
+ var paste_buf: std.Io.Writer.Allocating = .init(gpa);
+ defer paste_buf.deinit();
+ var loop: Loop = .init(io, &screen.tty, &screen.vx);
+
+ try localSession(init, opts, &screen, &loop, &paste_buf);
+}
+
+/// A replica client's link to its session (`remote`), drawn here.
+const Remote = struct {
+ link: replica.Link,
+
+ /// The client's own view drawn on its terminal, outside any step: the
+ /// replica's digest stays the session's (views.drawOne). What the host
+ /// writes in the core as it presents (a frame skipped, one owed) is put
+ /// back, as the frame statistics are this process's.
+ fn draw(c: *Remote, s: *Shell) void {
+ const r = c.link.r;
+ const core = r.core();
+ const skipped = core.present_skipped;
+ const needs = core.needs_frame;
+ core.frames.mark_start = pardes.FrameStats.nowNs();
+ core.frames.mark_update = core.frames.mark_start;
+ r.draw(.{ .ctx = s, .f = Shell.present });
+ core.frames.mark_render = core.frames.mark_update;
+ const drew = core.frames.bytes > 0;
+ c.link.owed = core.present_skipped;
+ core.frames.record(pardes.FrameStats.nowNs(), false, c.link.owed);
+ core.present_skipped = skipped;
+ core.needs_frame = needs;
+ c.link.drawn(drew);
+ }
+};
+
+/// The session's stream, onto the loop: its units, and its end.
+fn linkReader(gpa: std.mem.Allocator, fd: posix.fd_t, rest: *replica.Framer, loop: *Loop, done: *std.atomic.Value(bool)) void {
+ defer done.store(true, .release);
+ const Post = struct {
+ fn post(l: *Loop, said: replica.Said) bool {
+ l.postEvent(.{ .said = said }) catch return false;
+ return true;
+ }
+ };
+ replica.readLink(gpa, fd, rest, loop, Post.post);
+ loop.postEvent(.link_gone) catch {};
+}
+
+/// `pardes --attach=<socket>:<session>` (and `<host>:<session>`, through
+/// ssh, main.zig): this terminal a replica client of a session elsewhere
+/// (docs/next-daemon.md, "Phase 5 part B notes"). Its own core, loaded
+/// from the session's dump, applies its keys at once (src/replica.zig);
+/// the session's units are the truth it rolls back to. Its own view of the
+/// session is drawn here, as the session draws its terminals'.
+pub fn remote(init: std.process.Init, opts: pardes.Options, path: []const u8, session: []const u8, far_link: bool) !void {
+ const io = init.io;
+ const gpa = init.gpa;
+ const Said = struct {
+ fn no(o: std.Io, comptime fmt: []const u8, args: anytype) noreturn {
+ var said: [800]u8 = undefined;
+ std.Io.File.stderr().writeStreamingAll(o, std.fmt.bufPrint(&said, "pardes: --attach: " ++ fmt ++ "\n", args) catch "pardes: --attach failed\n") catch {};
+ std.process.exit(1);
+ }
+ };
+ var why: [600]u8 = @splat(0);
+ // Far (through ssh, or PARDES_REPLICA_FAR=1): its join's blobs by hash,
+ // those it holds kept from the link, and its stream in zstd. A client
+ // on this machine's own socket is sent the dump whole, as before: a
+ // hash and a compression there cost more than the bytes.
+ const far = if (init.environ_map.get("PARDES_REPLICA_FAR")) |v| std.mem.eql(u8, v, "1") else far_link;
+ var have_store: replica.Have = if (far) .init(io) else .{ .io = io };
+ defer have_store.deinit();
+ const have: ?*replica.Have = if (far) &have_store else null;
+ var dial_t0 = std.Io.Clock.awake.now(io).nanoseconds;
+ var joined = replica.dial(gpa, path, session, &why, have, null) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ if (joined.semantics != wire.semantics) Said.no(io, "{s}", .{replica.Link.upgrade_words});
+
+ const allocs = pardes.memory.init(gpa);
+ defer pardes.memory.deinit();
+ pardes.image.start(io, allocs.image);
+ if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ pardes.syntax.start(allocs.tree_sitter);
+ defer {
+ pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.pdf.stop();
+ pardes.syntax.stop();
+ }
+ var o = opts;
+ o.image_allocator = allocs.image;
+ o.pdf_allocator = allocs.pdf;
+ var r = replica.Link.load(gpa, &joined, o, &why, have) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ // Its join's time, the dial and the load (PARDES_REPLICA_STATS).
+ var dial_ms: u64 = @intCast(@divTrunc(std.Io.Clock.awake.now(io).nanoseconds - dial_t0, std.time.ns_per_ms));
+
+ var winch_set = posix.sigemptyset();
+ posix.sigaddset(&winch_set, posix.SIG.WINCH);
+ // A hangup ends it the normal way (`quit`), what it made kept on disk
+ // (`Have.keep`) and its ssh forward's socket unlinked (main.zig).
+ posix.sigaddset(&winch_set, posix.SIG.HUP);
+ hangup_quits = true;
+ if (comptime builtin.os.tag == .freebsd)
+ posix.sigaction(.WINCH, &.{ .handler = .{ .handler = keepSignal }, .mask = posix.sigemptyset(), .flags = 0 }, null);
+ posix.sigprocmask(posix.SIG.BLOCK, &winch_set, null);
+ var tty_buf: [0x10000]u8 = undefined;
+ var screen: Screen = .{ .io = io, .gpa = gpa, .env = init.environ_map, .buf = &tty_buf, .kitty = .init(gpa), .primary = true };
+ defer screen.kitty.deinit();
+ try screen.enter(try vaxis.Tty.init(io, &tty_buf));
+ defer screen.leave();
+ defer screen.glide.deinit(gpa);
+ var paste_buf: std.Io.Writer.Allocating = .init(gpa);
+ defer paste_buf.deinit();
+ var loop: Loop = .init(io, &screen.tty, &screen.vx);
+ var frame_arena: std.heap.ArenaAllocator = .init(allocs.frame);
+ defer frame_arena.deinit();
+ var remote_link: Remote = .{ .link = .{ .r = r, .fd = joined.fd } };
+ const link = &remote_link.link;
+ try link.fromEnv(gpa, init.environ_map);
+ defer link.deinit(gpa);
+ var sh: Shell = .{
+ .io = io,
+ .gpa = gpa,
+ .lsp_gpa = allocs.lsp,
+ .core = r.core(),
+ .prompt_rcs = undefined,
+ .loop = &loop,
+ .frame = &frame_arena,
+ .paste_buf = &paste_buf,
+ .inotify_fd = -1,
+ .from = joined.view,
+ .remote = &remote_link,
+ };
+
+ try startInput(&loop, &screen);
+ defer stopInput(io, &screen.thread);
+ (try std.Thread.spawn(.{}, winchWatch, .{&loop})).detach();
+ (try std.Thread.spawn(.{}, wakeWatch, .{ io, &loop })).detach();
+ try screen.vx.queryTerminalSend(screen.tty.writer());
+ // A join a pass: the first, and one after the replica diverged or the
+ // session let it go to upgrade. The terminal stays as it is.
+ while (true) {
+ r.gmtoff = joined.gmtoff;
+ sh.core = r.core();
+ sh.from = joined.view;
+ sh.terms = @splat(null);
+ sh.terms[joined.view] = &screen;
+ screen.feed.view = joined.view;
+ link.reset(r, joined.fd);
+ link.joinedAs(&joined, dial_ms);
+ var reader_done: std.atomic.Value(bool) = .init(false);
+ const reader = try std.Thread.spawn(.{}, linkReader, .{ gpa, joined.fd, &joined.rest, &loop, &reader_done });
+ // What it is, then its size, are its view's first inputs.
+ link.input(.{ .frontend = .{ .windowed = false } });
+ screen.size = null;
+ sh.winched();
+ screen.vx.queueRefresh();
+ while (!link.quit) {
+ // Its predicted echo judged and caught up, once a frame.
+ if (r.echoFrame()) link.dirty = true;
+ if (link.dirty) remote_link.draw(&sh);
+ const first = (loop.tryEvent() catch null) orelse idle: {
+ // Idle, its frame drawn: the next key needs no copy taken.
+ r.ready();
+ break :idle loop.nextEvent() catch break;
+ };
+ var ev = first;
+ var batch: usize = 1;
+ while (true) {
+ _ = sh.apply(ev);
+ if (link.quit or (!sh.in_paste and batch >= 64)) break;
+ ev = (loop.tryEvent() catch null) orelse break;
+ batch += 1;
+ }
+ r.settle();
+ if (screen.caps_pending and screen.vx.queries_done.load(.unordered)) {
+ screen.caps_pending = false;
+ screen.vx.enableDetectedFeatures(screen.tty.writer()) catch {};
+ screen.vx.queueRefresh();
+ link.dirty = true;
+ }
+ if (link.owed or r.echo.changed) link.dirty = true;
+ // Predictions out: judged a frame at a time while they are.
+ if (r.echo.n > 0 or r.echo.cursor != null or r.echo.nd > 0) requestWake(io, @intCast(pardes.animation.frame_ns / std.time.ns_per_ms));
+ if (link.quietCheck()) |ms| requestWake(io, ms);
+ if (r.diverged != null) link.quit = true;
+ }
+ if (init.environ_map.get("PARDES_REPLICA_STATS")) |file| link.writeStats(file);
+ if (!link.gone) replica.bye(joined.fd, r.diverged != null);
+ // The link's reader ends with the link, posting as it goes: what it
+ // and the terminal posted is let go until it has. Its end is read
+ // before the drain, not after: its last post (`link_gone`) comes
+ // just before it, and left queued it ended the next link at once.
+ _ = libc.shutdown(joined.fd, 2);
+ while (true) {
+ const ended = reader_done.load(.acquire);
+ while (loop.tryEvent() catch null) |ev| switch (ev) {
+ .said => |said| switch (said) {
+ .unit, .screen, .refused => |b| std.heap.c_allocator.free(b),
+ .checked => {},
+ },
+ .paste => |b| gpa.free(@constCast(b)),
+ else => {},
+ };
+ if (ended) break;
+ std.Thread.yield() catch {};
+ }
+ reader.join();
+ _ = libc.close(joined.fd);
+ joined.rest.deinit(gpa);
+ // Why it joins again, in a line over its frame until a key.
+ if (!link.rejoins()) {
+ // What it made since it joined, kept for its next start.
+ if (have) |h| h.keep(r.core());
+ r.deinit();
+ if (link.gone) {
+ screen.leave();
+ Said.no(io, "'{s}' let this client go (a Detach in it, or the session's end)", .{session});
+ }
+ return;
+ }
+ // The session again, the core it leaves held meanwhile: its blobs
+ // are not sent again.
+ if (have) |h| h.leaving(r.core());
+ dial_t0 = std.Io.Clock.awake.now(io).nanoseconds;
+ joined = replica.Link.redial(gpa, path, session, &why, have, r.diverged == null, joined.view) orelse {
+ screen.leave();
+ Said.no(io, "could not join again: {s}", .{std.mem.sliceTo(&why, 0)});
+ };
+ if (have) |h| h.left();
+ r.deinit();
+ r = replica.Link.load(gpa, &joined, o, &why, have) orelse {
+ screen.leave();
+ Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ };
+ dial_ms = @intCast(@divTrunc(std.Io.Clock.awake.now(io).nanoseconds - dial_t0, std.time.ns_per_ms));
+ }
+}
+
+
+/// A terminal a session draws on, while it has one: entered (raw, the
+/// alternate screen, mouse and paste reports) and left (all of it put back,
+/// the terminal closed) at the session's start and end, and at a detach and
+/// a reattach in between (daemon.zig). One a view (views.zig): the session's
+/// own (`primary`, its stub `daemon.stub`), and one more for each terminal
+/// `pardes --attach`ed while it is attached, which keeps its own.
+const Screen = struct {
+ io: std.Io,
+ gpa: std.mem.Allocator,
+ env: *std.process.Environ.Map,
+ buf: []u8,
+ tty: vaxis.Tty = undefined,
+ vx: vaxis.Vaxis = undefined,
+ on: bool = false,
+ primary: bool = false,
+ /// The pipe to its stub, an attached one's (the primary's is daemon.stub).
+ stub: posix.fd_t = -1,
+ /// Its slot in Killed.
+ killed: ?usize = null,
+ feed: Feed = .{},
+ thread: ?std.Io.Future(void) = null,
+ kitty: std.AutoHashMap(pardes.ImageCacheKey, vaxis.Image),
+ caps_pending: bool = true,
+ /// Its size as last taken (`Shell.resized`).
+ size: ?vaxis.Winsize = null,
+ tracks: []const pardes.animation.Track = &.{},
+ /// T2: the cursor's jump trail (JumpTrail).
+ trail: JumpTrail = .{},
+ /// The view's glide, the GUI's motion drawn at whole rows (anim 12).
+ glide: pardes.glide.Glide = .{},
+ /// T7: when each pane's view last moved (ThumbFlash).
+ flash: ThumbFlash = .{},
+
+ /// `fd` made raw, as vaxis.Tty.init makes /dev/tty: the terminal of a
+ /// forked session is no controlling terminal of its, which /dev/tty is.
+ /// An upgraded session's is raw already, `cooked` what it goes back to.
+ fn ttyOn(io: std.Io, buf: []u8, fd: posix.fd_t, cooked: ?posix.termios) !vaxis.Tty {
+ if (comptime builtin.is_test) unreachable; // vaxis.Tty is its TestTty
+ const termios = cooked orelse try vaxis.Tty.makeRaw(fd);
+ const file: std.Io.File = .{ .handle = fd, .flags = .{ .nonblocking = false } };
+ return .{ .io = io, .fd = file, .termios = termios, .tty_writer = file.writerStreaming(io, buf) };
+ }
+
+ fn enter(sc: *Screen, tty: vaxis.Tty) !void {
+ sc.tty = tty;
+ errdefer sc.tty.deinit();
+ sc.vx = try vaxis.init(sc.io, sc.gpa, sc.env, .{ .system_clipboard_allocator = sc.gpa });
+ errdefer sc.vx.deinit(sc.gpa, sc.tty.writer());
+ try sc.vx.enterAltScreen(sc.tty.writer());
+ try sc.vx.setMouseMode(sc.tty.writer(), true);
+ try sc.vx.setBracketedPaste(sc.tty.writer(), true);
+ if (comptime !builtin.is_test) {
+ sc.killed = Killed.arm(sc.tty.fd.handle, sc.tty.termios);
+ // What a panic puts back (vaxis.recover).
+ if (sc.primary) vaxis.tty.global_tty = sc.tty;
+ }
+ const view = sc.feed.view;
+ sc.feed = .{ .view = view };
+ sc.caps_pending = true;
+ sc.size = null;
+ sc.on = true;
+ }
+
+ fn leave(sc: *Screen) void {
+ if (!sc.on) return;
+ sc.on = false;
+ if (sc.killed) |slot| Killed.disarm(slot);
+ sc.killed = null;
+ clearNativeImages(&sc.kitty, &sc.vx, &sc.tty);
+ sc.vx.exitAltScreen(sc.tty.writer()) catch {};
+ sc.vx.deinit(sc.gpa, sc.tty.writer());
+ if (comptime !builtin.is_test) if (sc.primary) {
+ vaxis.tty.global_tty = null;
+ };
+ sc.tty.deinit(); // restore cooked termios LAST, after vx flushed its resets
+ }
+
+ /// Its stub told the terminal is detached (it ends, and its shell has
+ /// the terminal back).
+ fn sayDetached(sc: *Screen) void {
+ if (sc.primary) return daemon.tellStubDetached();
+ daemon.tellDetached(sc.stub);
+ sc.stub = -1;
+ }
+
+ /// Its terminal hung up, or the stub that waits on it is gone.
+ fn hungUp(sc: *const Screen) bool {
+ const stub = if (sc.primary) daemon.stub else sc.stub;
+ const handle = if (@TypeOf(sc.tty.fd) == std.Io.File) sc.tty.fd.handle else sc.tty.fd;
+ var fds = [_]posix.pollfd{
+ .{ .fd = handle, .events = 0, .revents = 0 },
+ .{ .fd = stub, .events = 0, .revents = 0 },
+ };
+ _ = posix.poll(fds[0..if (stub >= 0) 2 else 1], 0) catch return false;
+ const gone = posix.POLL.HUP | posix.POLL.ERR;
+ return fds[0].revents & gone != 0 or (stub >= 0 and fds[1].revents & gone != 0);
+ }
+
+ fn setStub(sc: *Screen, fd: posix.fd_t) void {
+ if (sc.primary) daemon.stub = fd else sc.stub = fd;
+ }
+};
+
+/// SIGTERM or SIGHUP: each terminal put back as a clean exit leaves it --
+/// the main screen, no mouse, paste or keyboard modes, the cursor shown,
+/// cooked termios -- and then the signal's own death. A nested editor
+/// killed in a pane must not leave that pane's terminal wedged.
+/// Async-signal-safe: write, tcsetattr, sigaction, raise.
+const Killed = struct {
+ var fds: [pardes.views.max]posix.fd_t = @splat(-1);
+ var cooked: [pardes.views.max]posix.termios = undefined;
+ const reset = "\x1b[<u\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1004l\x1b[?2004l\x1b[0m\x1b[?25h\x1b[?1049l";
+ fn arm(tty_fd: posix.fd_t, termios: posix.termios) ?usize {
+ const slot = std.mem.findScalar(posix.fd_t, &fds, -1) orelse return null;
+ cooked[slot] = termios;
+ fds[slot] = tty_fd;
+ const on: posix.Sigaction = .{ .handler = .{ .handler = handle }, .mask = posix.sigemptyset(), .flags = posix.SA.RESETHAND };
+ posix.sigaction(.TERM, &on, null);
+ // A hangup a daemon keeps the session through is winchWatch's.
+ if (daemon.link < 0) posix.sigaction(.HUP, &on, null);
+ return slot;
+ }
+
+ /// The terminal gone (put back, or detached): a TERM still takes the
+ /// socket, the prompt files and the shells with it, and leaves the
+ /// terminal alone.
+ fn disarm(slot: usize) void {
+ fds[slot] = -1;
+ }
+
+ fn handle(sig: posix.SIG) callconv(.c) void {
+ for (fds, &cooked) |fd, *termios| if (fd >= 0) {
+ _ = std.c.write(fd, reset, reset.len);
+ _ = std.c.tcsetattr(fd, .FLUSH, termios);
+ };
+ // The 9P socket and private prompt files go too: a killed editor
+ // leaves none behind. Its shells too, the daemon's dups let go.
+ ninep_io.unlinkOwnSocket();
+ host_io.Shell.unlinkOwnedRcs();
+ daemon.hangUp();
+ // SA_RESETHAND put the default back: the same signal, now fatal.
+ _ = std.c.raise(sig);
+ }
+};
+
+fn localSession(
+ init: std.process.Init,
+ opts: pardes.Options,
+ screen: *Screen,
+ loop: *Loop,
+ paste_buf: *std.Io.Writer.Allocating,
+) !void {
+ const io = init.io;
+ const gpa = init.gpa;
+
+ const allocs = pardes.memory.init(gpa);
+ defer pardes.memory.deinit();
+ var options = opts;
+ options.image_allocator = allocs.image;
+ options.pdf_allocator = allocs.pdf;
+ options.tree_sitter_allocator = allocs.tree_sitter;
+ options.frame_allocator = allocs.frame;
+
+ pardes.image.start(io, allocs.image);
+ if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ // Pages render on lanes off the loop (pdf_view.workers).
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.workers = io;
+ pardes.syntax.start(allocs.tree_sitter);
+ defer {
+ pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.dropKept();
+ if (comptime pardes.pdf_enabled) pardes.pdf.stop();
+ pardes.syntax.stop();
+ }
+
+ var core = if (upgrade.resumed) |*rec|
+ try upgrade.load(gpa, allocs.pardes, options, rec)
+ else if (options.load_path) |lp| blk: {
+ const bytes = try filesystem.readFile(gpa, lp);
+ defer gpa.free(bytes);
+ break :blk try pardes.dump.initFromDump(allocs.pardes, options, bytes);
+ } else try pardes.Pardes.init(allocs.pardes, options);
+ defer core.deinit();
+
+ var prompt_rcs = host_io.Shell.prepare();
+ defer prompt_rcs.deinit();
+
+ var frame_arena: std.heap.ArenaAllocator = .init(allocs.frame);
+ defer frame_arena.deinit();
+
+ var fs = ninep_io.start(io, gpa, core);
+ defer if (fs) |f| f.deinit(gpa);
+
+ var sh: Shell = .{
+ .io = io,
+ .gpa = gpa,
+ .lsp_gpa = allocs.lsp,
+ .core = core,
+ .prompt_rcs = &prompt_rcs,
+ .loop = loop,
+ .frame = &frame_arena,
+ .paste_buf = paste_buf,
+ .inotify_fd = file_watch.init(false),
+ .fs = fs,
+ .test_clock = host_io.testClock(),
+ };
+ sh.terms[0] = screen;
+ sh.peers = .{ .gpa = gpa, .io = io, .name = daemon.name(), .wake_ctx = loop, .wake = wakeForReplica };
+ defer sh.peers.deinit();
+ // Before the core goes: each client sees its link end.
+ defer sh.peers.dropAll(sh.core);
+ pardes.lsp.setStatusSink(&sh, lspStatusSink);
+ host_io.setExitWake(loop, wakeForExit);
+ defer screen.glide.deinit(gpa);
+ // The terminals of the other views end with the session: each put back,
+ // its stub told.
+ defer for (&sh.terms) |*slot| if (slot.*) |sc| if (!sc.primary) {
+ stopInput(io, &sc.thread);
+ sh.dropScreen(sc, .exit);
+ slot.* = null;
+ };
+ defer {
+ host_io.setExitWake(null, null);
+ pardes.lsp.setStatusSink(null, null);
+ for (&sh.ptys) |*slot| if (slot.*) |*pt| {
+ pt.reader.cancel(io) catch {};
+ _ = libc.close(pt.file.handle);
+ slot.* = null;
+ };
+ for (sh.adoptions[0..sh.adoptions_len]) |a| _ = libc.close(a.fd);
+ if (sh.lsp_task) |*t| {
+ t.future.cancel(io);
+ sh.lsp_task = null;
+ }
+ sh.pipe_tasks.cancelAll(io);
+ // Its worker may be waiting on the loop's queue for room.
+ core.stream.cancelTask();
+ file_watch.stop(sh.inotify_fd);
+ if (sh.watch_task) |*t| {
+ t.cancel(io) catch {};
+ sh.watch_task = null;
+ }
+ if (sh.inotify_fd >= 0) {
+ _ = libc.close(sh.inotify_fd);
+ sh.inotify_fd = -1;
+ }
+ while (loop.tryEvent() catch null) |ev| switch (ev) {
+ .pty_read => |pr| {
+ tookRead(io, pr.id);
+ gpa.free(pr.bytes);
+ },
+ .paste => |b| gpa.free(@constCast(b)),
+ .lsp_done => |d| if (d.rows) |rows| allocs.lsp.free(rows),
+ .lsp_status => |text| allocs.lsp.free(text),
+ .pipe_done => |response_value| {
+ var response = response_value;
+ response.deinit(gpa);
+ },
+ .search_rows => |b| b.deinit(gpa),
+ .attach => |a| {
+ _ = libc.close(a.tty);
+ if (a.stub >= 0) _ = libc.close(a.stub);
+ },
+ .adopted => |a| _ = libc.close(a.fd),
+ else => {},
+ };
+ }
+ const host = sh.host();
+
+ core.host = host;
+ // An upgraded session's terminals, its own again.
+ if (comptime !builtin.is_test) if (upgrade.resumed) |*rec| sh.resumeTerminals(rec, screen);
+ // Nobody to see it, and nobody to size it: `size` sets it (ctl.zig).
+ sh.setAttended(sh.attached());
+ while (core.nextEffect()) |effect| core.perform(effect);
+ // ...and its shells, once a fresh session's own has a directory to
+ // adopt them in.
+ if (upgrade.resumed) |*rec| {
+ sh.resumePtys(rec);
+ while (core.nextEffect()) |effect| core.perform(effect);
+ }
+
+ if (screen.on) try startInput(loop, screen);
+ defer stopInput(io, &screen.thread);
+ (try std.Thread.spawn(.{}, winchWatch, .{loop})).detach();
+ (try std.Thread.spawn(.{}, wakeWatch, .{ io, loop })).detach();
+ if (fs) |f| try f.watch(loop, wakeFs);
+ if (screen.on) try screen.vx.queryTerminalSend(screen.tty.writer());
+ // Detached from the start, nothing else may wake the first wait.
+ if (!screen.on) daemon.watch(loop, deliverNote);
+ // PARDES_TEST_VIEWS: the terminals at these paths are views of the
+ // session too, from its start, as `pardes --attach`ed ones are (the
+ // snapshot harness's `start ... views=N`).
+ if (upgrade.resumed == null) if (init.environ_map.get("PARDES_TEST_VIEWS")) |paths| {
+ var it = std.mem.tokenizeScalar(u8, paths, ' ');
+ while (it.next()) |path| {
+ var path_buf: [256]u8 = undefined;
+ const z = std.fmt.bufPrintSentinel(&path_buf, "{s}", .{path}, 0) catch continue;
+ const fd = libc.open(z, .{ .ACCMODE = .RDWR, .NOCTTY = true, .CLOEXEC = true }, @as(libc.mode_t, 0));
+ if (fd >= 0) sh.attachTerminal(fd, -1, null);
+ }
+ };
+
+ sh.threads_ok = true;
+ for (&sh.ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = try io.concurrent(readPty, .{ io, gpa, pt.file, id, sh.gens[id], loop });
+ };
+ if (sh.inotify_fd >= 0) sh.watch_task = io.concurrent(watchFiles, .{ io, sh.inotify_fd, loop }) catch null;
+
+ defer unlinkKittyShm();
+ while (!core.quit) {
+ pardes.turn.bump(&pardes.turn.restores);
+ try core.pump(host);
+ // Its unit to each replica client, and theirs taken in.
+ sh.peers.boundary(core);
+ upgrade.locate();
+ // Asked in the step (the word), done between steps: the session whole.
+ if (sh.upgrade_asked) |pane| sh.upgradeNow(pane);
+ // A terminal (`pardes --attach`) or an adopted shell, handed on by
+ // the daemon's thread to this loop; started after the first frame,
+ // off a startup's way.
+ daemon.watch(loop, deliverNote);
+ if (core.takeRestore()) |rp| blk: {
+ // ponytail: a Restore replaces the core its clients replicate;
+ // they are let go, and attach again.
+ sh.peers.dropAll(core);
+ const bytes = filesystem.readRestore(gpa, rp, core.settings.dump_dir.get()) catch |err| {
+ core.reportError(core.active, "Restore", err);
+ break :blk;
+ };
+ defer gpa.free(bytes);
+ const nc = dump.restore(core, bytes, rp) catch |err| {
+ core.reportError(core.active, "Restore", err);
+ break :blk;
+ };
+ if (sh.lsp_task) |*task| {
+ task.future.cancel(io);
+ sh.lsp_task = null;
+ }
+ sh.pipe_tasks.cancelAll(io);
+ for (&sh.gens) |*generation| generation.* +%= 1;
+ for (&sh.ptys) |*slot| if (slot.*) |*pt| {
+ pt.reader.cancel(io) catch {};
+ _ = libc.close(pt.file.handle);
+ daemon.closed(pt.pid);
+ host_io.retireShell(pt.pid);
+ slot.* = null;
+ };
+ for (0..pardes.MAX_PANES) |wid| file_watch.watchPane(
+ sh.inotify_fd,
+ &sh.watches,
+ @intCast(wid),
+ null,
+ 0,
+ .{ .text = 0 },
+ );
+ _ = file_watch.applyThemeEffect(core, gpa, sh.inotify_fd, &sh.watches, 0, false, false);
+ // ponytail: a restored session is one view, the live one's
+ // terminal: the others are let go, as a detach of each.
+ const live = sh.term().?;
+ for (&sh.terms) |*slot| if (slot.*) |sc| if (sc != live) {
+ stopInput(io, &sc.thread);
+ sh.dropScreen(sc, .detach);
+ slot.* = null;
+ };
+ sh.terms = @splat(null);
+ sh.terms[0] = live;
+ stopInput(io, &live.thread);
+ live.feed.view = 0;
+ sh.from = 0;
+ if (live.on) startInput(loop, live) catch {};
+ if (live.on) clearNativeImages(&live.kitty, &live.vx, &live.tty);
+ nc.native_images = live.on and live.vx.caps.kitty_graphics;
+ nc.unattended = !live.on;
+ sh.peers.alone_unattended = !live.on;
+ if (fs) |f| f.reset(nc);
+ core.deinit();
+ core = nc;
+ sh.core = nc;
+ if (comptime pardes.pdf_enabled) if (live.on) {
+ updateCoreTerminalSize(core, live.vx.screen.width, live.vx.screen.height, live.vx.screen.width_pix, live.vx.screen.height_pix);
+ };
+ }
+ }
+ if (fs) |f| {
+ f.deinit(gpa);
+ fs = null;
+ sh.fs = null;
+ }
+}
+
+fn clearNativeImages(
+ kitty_handles: *std.AutoHashMap(pardes.ImageCacheKey, vaxis.Image),
+ vx: *vaxis.Vaxis,
+ tty: *vaxis.Tty,
+) void {
+ var iterator = kitty_handles.valueIterator();
+ while (iterator.next()) |handle| vx.freeImage(tty.writer(), handle.id);
+ kitty_handles.clearRetainingCapacity();
+}
+
+const Adoption = struct { pid: posix.pid_t, fd: posix.fd_t, pane: ?u8 };
+
+/// The daemon's thread: what it says, onto the loop's queue.
+fn deliverNote(ctx: *anyopaque, note: daemon.Note) void {
+ const loop: *Loop = @ptrCast(@alignCast(ctx));
+ switch (note) {
+ .attach => |a| if (a.tty < 0) {
+ if (a.stub >= 0) daemon.refuseStub(a.stub, "a terminal session takes a terminal");
+ } else loop.postEvent(.{ .attach = .{ .tty = a.tty, .stub = a.stub } }) catch {
+ _ = libc.close(a.tty);
+ _ = libc.close(a.stub);
+ },
+ .adopted => |a| {
+ for (a.pids[0..a.n], a.fds[0..a.n]) |pid, fd| loop.postEvent(.{ .adopted = .{ .pid = pid, .fd = fd } }) catch {
+ _ = libc.close(fd);
+ };
+ loop.postEvent(.{ .adopted = .{ .pid = 0, .fd = -1 } }) catch {};
+ },
+ .replica => |j| loop.postEvent(.{ .replica = j }) catch {
+ _ = libc.close(j.fd);
+ },
+ }
+}
+
+/// A replica reader's post: the session's wait ends, and its step
+/// boundary takes the post in.
+fn wakeForReplica(ctx: ?*anyopaque) void {
+ const loop: *Loop = @ptrCast(@alignCast(ctx.?));
+ // Never waits: a full queue wakes the loop anyway, and a reader the
+ // loop is joining (a client let go) must not wait on it.
+ _ = loop.tryPostEvent(.replica_mail) catch {};
+}
+
+const Shell = struct {
+ io: std.Io,
+ gpa: std.mem.Allocator,
+ lsp_gpa: std.mem.Allocator,
+ core: *pardes.Pardes,
+ prompt_rcs: *const host_io.Shell.PromptFiles,
+ loop: *Loop,
+ /// Each view's terminal, by view (views.zig): the session's own first;
+ /// none in tests.
+ terms: [pardes.views.max]?*Screen = @splat(null),
+ /// The view the input taken now is from (`Command.value.from`).
+ from: u8 = 0,
+ frame: *std.heap.ArenaAllocator,
+ paste_buf: *std.Io.Writer.Allocating,
+ inotify_fd: c_int,
+ /// Shells a dead session left (Adopt), each waiting for the spawn of
+ /// the terminal pane made for it.
+ adoptions: [pardes.MAX_PANES]Adoption = undefined,
+ adoptions_len: usize = 0,
+ adopted: usize = 0,
+ fs: ?*ninep_io.Listener = null,
+ ptys: [pardes.MAX_PANES]?Pty = @splat(null),
+ gens: [pardes.MAX_PANES]u32 = @splat(0),
+ watches: file_watch.Table = @splat(null),
+ watch_task: ?std.Io.Future(anyerror!void) = null,
+ lsp_task: ?host_io.Lsp.Task = null,
+ pipe_tasks: PipeTasks = .{},
+ threads_ok: bool = false,
+ check_files: bool = false,
+ // ponytail: one bracketed paste at a time for every terminal: keys
+ // another terminal sends while one pastes join its paste.
+ in_paste: bool = false,
+ /// PARDES_TEST_CLOCK's virtual time (host_io.testClock), and where the
+ /// running-out wait moves it: the core's next wake.
+ test_clock: ?u64 = null,
+ /// The tick the last paced frame was due at (waitInput), and whether
+ /// this wait read an input (its frame is drawn at once).
+ pace_ns: u64 = 0,
+ input_seen: bool = false,
+ wake_to: u64 = 0,
+ /// waitInput's pacing of output: whether this wait read a pane's output,
+ /// and when the last frame was written, the last input was read and the
+ /// focused pane's output last was.
+ output_seen: bool = false,
+ drawn_ns: u64 = 0,
+ input_ns: u64 = 0,
+ focused_ns: u64 = 0,
+ /// Upgrade was asked from this pane, to be done between steps (`upgradeNow`).
+ upgrade_asked: ?u8 = null,
+ /// Its pty readers stopped for it: their end of file is not a shell's.
+ upgrading: bool = false,
+ /// The session's replica clients (src/replica.zig), on sockets.
+ peers: replica.Peers = .{},
+ /// This wait took only a replica's post (its input, its join): the
+ /// pump after it reads no new time, so it moves nothing the replicas'
+ /// speculations stand on (a replica takes such a unit as is).
+ mail_only: bool = false,
+ waited: bool = false,
+ /// This wait's steps so far, and the input held for the next (`split`).
+ took_input: bool = false,
+ took_output: bool = false,
+ held: ?@TypeOf(Command.value) = null,
+ /// This process a replica client of a session elsewhere (`remote`):
+ /// its inputs go to the replica, never straight to the core.
+ remote: ?*Remote = null,
+
+ const Leaving = enum { detach, exit };
+
+ /// A terminal's input, to the core, or to a replica client's engine
+ /// (applied at once there, and sent to the session).
+ fn feed(s: *Shell, ev: pardes.Event) void {
+ const c = s.remote orelse return s.core.update(ev);
+ c.link.input(ev);
+ }
+
+ /// Whether a terminal of this process's shows the session, or
+ /// nothing (a test) can.
+ fn local(s: *const Shell) bool {
+ for (s.terms) |slot| if (slot != null) return true;
+ return false;
+ }
+
+ /// Whether anyone looks at the session: a terminal here, or a replica
+ /// client (Peers keeps it attended while one is there).
+ fn setAttended(s: *Shell, on: bool) void {
+ s.peers.alone_unattended = !on;
+ s.core.unattended = !on and s.peers.count() == 0;
+ }
+
+ fn of(ctx: ?*anyopaque) *Shell {
+ return @ptrCast(@alignCast(ctx.?));
+ }
+
+ fn host(s: *Shell) host_io.Host {
+ return .{ .ctx = s, .vtable = if (comptime pardes.isolated) &isolated_vtable else &vtable };
+ }
+
+ const isolated_vtable: host_io.Host.VTable = .{
+ .wait_input = waitInput,
+ .now = clockNow,
+ .present = present,
+ .post_present = postPresent,
+ .poll_frame = stepGlide,
+ };
+
+ const vtable: host_io.Host.VTable = .{
+ .wait_input = waitInput,
+ .now = clockNow,
+ .present = present,
+ .post_present = postPresent,
+ .poll_frame = pollFrame,
+ .watched = watched,
+ .detach = detach,
+ .adopt = adopt,
+ .upgrade = upgradeAsked,
+ .newer_build = newerBuild,
+ .spawn = spawn,
+ .pty_write = ptyWrite,
+ .pty_resize = ptyResize,
+ .pty_signal = ptySignal,
+ .close_pty = closePty,
+ .tty_taken = ttyTaken,
+ .fg_name = fgName,
+ .kill_job = killJob,
+ .write_file = writeFile,
+ .write_dump = writeDump,
+ .watch_file = watchFile,
+ .watch_theme = watchTheme,
+ .dump_themes = dumpThemes,
+ .set_clipboard = setClipboard,
+ .read_clipboard = readClipboard,
+ .open_link = openLink,
+ .lsp = lsp,
+ .pipe = pipe,
+ .search = search,
+ };
+
+ fn clockNow(ctx: ?*anyopaque) u64 {
+ const s = of(ctx);
+ if (s.waited) {
+ s.waited = false;
+ if (s.mail_only and s.peers.count() > 0 and s.core.clock_started) return s.core.now_ns;
+ }
+ return s.test_clock orelse @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ }
+
+ /// The live view's terminal (null in tests).
+ fn term(s: *const Shell) ?*Screen {
+ return s.terms[s.core.view];
+ }
+
+ fn attached(s: *const Shell) bool {
+ const screen = s.term() orelse return true;
+ return screen.on;
+ }
+
+ /// Drawn only while a terminal shows it: a replica client's view live
+ /// (its input the last), whichever terminal here shows another.
+ fn watched(ctx: ?*anyopaque) bool {
+ const s = of(ctx);
+ if (s.term() == null and s.local()) {
+ for (s.terms) |slot| if (slot) |sc| if (sc.on) return true;
+ return false;
+ }
+ return s.attached();
+ }
+
+ /// Detach: the terminal put back and let go, the stub told (it ends,
+ /// and the shell has its terminal again), the session left running.
+ fn detach(ctx: ?*anyopaque) void {
+ const s = of(ctx);
+ // A replica client's: its link ends.
+ if (s.peers.detach(s.core.view)) return;
+ if (!s.attached()) return s.core.reportFailure(s.core.active, "Detach: no terminal is attached");
+ // One of several: its view goes, and the session stays on the rest.
+ if (pardes.views.count(s.core) > 1) return s.dropView(s.core.view, .detach);
+ if (!daemon.kept()) return s.core.reportFailure(s.core.active, "Detach: no pardes daemon keeps this session (it is its terminal's job)");
+ s.leaveTerminal();
+ }
+
+ /// View `k`'s terminal let go (detached, or gone) while others stay: the
+ /// view goes with it.
+ fn dropView(s: *Shell, k: u8, how: Leaving) void {
+ const sc = s.terms[k] orelse return;
+ stopInput(s.io, &sc.thread);
+ s.terms[k] = null;
+ s.core.closeView(k);
+ s.dropScreen(sc, how);
+ }
+
+ /// A terminal put back and its stub told; an attached one's Screen freed
+ /// (the session's own stays, a view of none).
+ fn dropScreen(s: *Shell, sc: *Screen, how: Leaving) void {
+ if (sc.primary) {
+ sc.leave();
+ return sc.sayDetached();
+ }
+ sc.leave();
+ switch (how) {
+ .detach => sc.sayDetached(),
+ .exit => {
+ daemon.tellExit(sc.stub, 0);
+ sc.stub = -1;
+ },
+ }
+ sc.glide.deinit(s.gpa);
+ sc.kitty.deinit();
+ s.gpa.free(sc.buf);
+ s.gpa.destroy(sc);
+ }
+
+ fn leaveTerminal(s: *Shell) void {
+ const screen = s.term() orelse return;
+ stopInput(s.io, &screen.thread);
+ screen.leave();
+ s.core.native_images = false;
+ s.setAttended(false);
+ // The stub's stdin, stdout and stderr were its terminal too.
+ const null_fd = libc.open("/dev/null", .{ .ACCMODE = .RDWR, .CLOEXEC = true }, @as(libc.mode_t, 0));
+ if (null_fd >= 0) {
+ for (0..3) |i| _ = libc.dup2(null_fd, @intCast(i));
+ if (null_fd > 2) _ = libc.close(null_fd);
+ }
+ screen.sayDetached();
+ daemon.setState(true);
+ }
+
+ /// `pardes --attach`'s terminal: for a detached session its own again,
+ /// entered as the first one was; for one attached already, a view of
+ /// its own (views.zig). Sized, asked what it can do, and drawn whole.
+ fn attachTerminal(s: *Shell, fd: posix.fd_t, stub: posix.fd_t, cooked: ?posix.termios) void {
+ // A replica client's view live (its input the last) has no terminal
+ // here: the session's own is the one a terminal takes, or joins.
+ const live = s.term() orelse for (s.terms) |slot| {
+ if (slot) |sc| if (sc.primary) break sc;
+ } else {
+ _ = libc.close(fd);
+ return refuse(stub, "that session has no terminal of its own to attach to");
+ };
+ const screen = if (!live.on) live else extra: {
+ const sc = s.gpa.create(Screen) catch break :extra null;
+ const buf = s.gpa.alloc(u8, 0x10000) catch {
+ s.gpa.destroy(sc);
+ break :extra null;
+ };
+ sc.* = .{ .io = s.io, .gpa = s.gpa, .env = live.env, .buf = buf, .kitty = .init(s.gpa) };
+ break :extra sc;
+ } orelse {
+ _ = libc.close(fd);
+ return refuse(stub, "that session has no room for another terminal");
+ };
+ const extra = screen != live;
+ const tty = Screen.ttyOn(s.io, screen.buf, fd, cooked) catch {
+ _ = libc.close(fd);
+ if (extra) s.freeScreen(screen) else daemon.setState(true);
+ return refuse(stub, "that terminal would not go raw");
+ };
+ screen.enter(tty) catch {
+ if (extra) s.freeScreen(screen) else daemon.setState(true);
+ return refuse(stub, "that terminal would not take the screen");
+ };
+ if (extra) {
+ const k = s.core.openView() orelse {
+ screen.leave();
+ s.freeScreen(screen);
+ return refuse(stub, "that session has as many terminals as it takes");
+ };
+ screen.feed.view = k;
+ s.terms[k] = screen;
+ }
+ screen.setStub(stub);
+ s.setAttended(true);
+ startInput(s.loop, screen) catch {};
+ screen.vx.queryTerminalSend(screen.tty.writer()) catch {};
+ s.core.needs_frame = true;
+ daemon.setState(false);
+ }
+
+ fn freeScreen(s: *Shell, sc: *Screen) void {
+ sc.kitty.deinit();
+ s.gpa.free(sc.buf);
+ s.gpa.destroy(sc);
+ }
+
+ /// A terminal refused: its stub told why (a test's has none).
+ fn refuse(stub: posix.fd_t, why: []const u8) void {
+ if (stub >= 0) daemon.refuseStub(stub, why);
+ }
+
+ /// Adopt: the daemon is asked for the shells of sessions that died
+ /// holding them; each comes back (`adopted`) as a terminal pane here.
+ fn adopt(ctx: ?*anyopaque, pane: u8) void {
+ const s = of(ctx);
+ if (!daemon.kept()) return s.core.reportFailure(pane, "Adopt: no pardes daemon is keeping shells for this session");
+ s.adopted = 0;
+ daemon.adopt();
+ }
+
+ /// A client's own build is not the session's to say (its core's host
+ /// is the session's, through the tape).
+ fn newerBuild(ctx: ?*anyopaque) bool {
+ return of(ctx).remote == null and upgrade.newer();
+ }
+
+ fn upgradeAsked(ctx: ?*anyopaque, pane: u8) void {
+ const s = of(ctx);
+ if (comptime !upgrade.supported) return s.core.reportFailure(pane, "Upgrade: this system cannot move a session to another build in place");
+ s.upgrade_asked = pane;
+ }
+
+ /// Upgrade, between steps: this process exec'd as the pardes now at the
+ /// path it was started from, the session in its dump, and its ptys,
+ /// terminals, stubs and daemon link kept open across (upgrade.zig).
+ /// Returns only when it could not be, the session going on as it was.
+ fn upgradeNow(s: *Shell, pane: u8) void {
+ if (comptime builtin.is_test) unreachable; // vaxis.Tty is its TestTty
+ s.upgrade_asked = null;
+ const core = s.core;
+ var why: [800]u8 = undefined;
+ const path = upgrade.exe() orelse return core.reportFailure(pane, "Upgrade: this process does not know the path it was started from");
+ // 9P is served while the new binary is asked (its clients' clunks
+ // and reads after the word are answered), and not after.
+ pardes.turn.rest();
+ const checked = upgrade.check(path, &why);
+ pardes.turn.wake();
+ switch (checked) {
+ .no => |w| return core.reportFailure(pane, w),
+ .ok => {},
+ }
+ // Nothing more read from a pty or a terminal, and what was read
+ // goes in; a reader's cancel posts an end of file, passed over.
+ s.upgrading = true;
+ defer s.upgrading = false;
+ for (&s.ptys) |*slot| if (slot.*) |*pt| pt.reader.cancel(s.io) catch {};
+ for (s.terms) |slot| if (slot) |sc| stopInput(s.io, &sc.thread);
+ while (s.loop.tryEvent() catch null) |ev| _ = s.apply(ev);
+ core.settle();
+ // Its replica clients told, their views gone before the dump: each
+ // dials the session again once it is back.
+ s.peers.refuseAll(core, "the session is upgrading to another build of pardes");
+ var rec: upgrade.Record = .{ .link = daemon.link, .stub = daemon.stub, .exe = path };
+ for (s.ptys, 0..) |slot, id| if (slot) |pt| rec.addPty(id, pt.pid, pt.file.handle);
+ for (s.terms, 0..) |slot, k| if (slot) |sc| if (sc.on) rec.addTty(.{
+ .view = @intCast(k),
+ .fd = sc.tty.fd.handle,
+ .stub = if (sc.primary) daemon.stub else sc.stub,
+ .primary = sc.primary,
+ .termios = sc.tty.termios,
+ });
+ var popped = false;
+ var at_buf: [1024:0]u8 = undefined;
+ const failed: []const u8 = failed: {
+ const at = pardes.dump.upgradePath(&at_buf, core.settings.dump_dir.get()) orelse break :failed "Upgrade: no directory for the session's dump; this session stays as it is";
+ const bytes = pardes.dump.dumpBytes(core) catch |err| {
+ var words: [128]u8 = undefined;
+ break :failed std.fmt.bufPrint(&why, "Upgrade: the session would not dump: {s}; it stays as it is", .{pardes.Messages.errorWords(err, &words)}) catch "Upgrade: the session would not dump";
+ };
+ defer s.gpa.free(bytes);
+ if (!upgrade.writeDump(at, bytes)) break :failed std.fmt.bufPrint(&why, "Upgrade: the session's dump could not be written to {s}; it stays as it is", .{at[0..@min(at.len, 600)]}) catch "Upgrade: its dump could not be written";
+ rec.dump = at;
+ rec.old = upgrade.openSelf();
+ // What this process put in its terminals that the next puts in
+ // again: its images, and its keyboard mode, a stack.
+ for (s.terms) |slot| if (slot) |sc| if (sc.on) {
+ clearNativeImages(&sc.kitty, &sc.vx, &sc.tty);
+ if (sc.vx.state.kitty_keyboard) sc.tty.writer().writeAll("\x1b[<u") catch {};
+ sc.vx.state.kitty_keyboard = false;
+ sc.tty.writer().flush() catch {};
+ };
+ popped = true;
+ unlinkKittyShm();
+ daemon.upgraded();
+ if (s.fs) |f| f.flushOut();
+ const err_words = upgrade.exec(s.gpa, path, -1, &rec);
+ // Still here: the exec failed.
+ _ = libc.unlink(at);
+ if (rec.old >= 0) _ = libc.close(rec.old);
+ break :failed std.fmt.bufPrint(&why, "Upgrade: {s} would not start: {s}; this session stays as it is", .{ path[0..@min(path.len, 600)], err_words }) catch "Upgrade: the new pardes would not start";
+ };
+ // As it was: its ptys read on, its terminals' keys as they were.
+ for (&s.ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = s.io.concurrent(readPty, .{ s.io, s.gpa, pt.file, id, s.gens[id], s.loop }) catch pt.reader;
+ };
+ for (s.terms) |slot| if (slot) |sc| if (sc.on) {
+ if (popped) sc.vx.enableDetectedFeatures(sc.tty.writer()) catch {};
+ startInput(s.loop, sc) catch {};
+ };
+ core.reportFailure(pane, failed);
+ }
+
+ /// An upgraded session's shells, running on: each its pane's pty again,
+ /// or, when its dump would not load (`fresh`), adopted as new panes.
+ fn resumePtys(s: *Shell, rec: *const upgrade.Record) void {
+ for (rec.ptys[0..rec.nptys]) |k| {
+ const pane = if (rec.fresh) null else s.core.panes[k.pane];
+ if (pane == null or !pane.?.isTerminal()) {
+ s.adoptShell(k.pid, k.fd);
+ continue;
+ }
+ const file: std.Io.File = .{ .handle = k.fd, .flags = .{ .nonblocking = false } };
+ s.ptys[k.pane] = .{ .file = file, .pid = k.pid, .reader = .{ .any_future = null, .result = {} }, .cmd = .{ .watched = pane.?.command != null and host_io.watchExit(k.pid), .fd = k.fd } };
+ }
+ }
+
+ /// An upgraded session's terminals, each its view's again (`primary`,
+ /// run's, entered already); in a fresh session each but the primary a
+ /// view of its own, as `--attach` makes one. A view left with none
+ /// closes, but a replica client's, kept for its rejoin (views.away).
+ fn resumeTerminals(s: *Shell, rec: *const upgrade.Record, primary: *Screen) void {
+ if (comptime builtin.is_test) unreachable;
+ const core = s.core;
+ if (rec.fresh) {
+ for (rec.ttys[0..rec.nttys]) |t| if (!t.primary) s.attachTerminal(t.fd, t.stub, t.termios);
+ return;
+ }
+ s.terms = @splat(null);
+ if (rec.nttys == 0) {
+ // The live view alone (never one kept for a rejoin) is the
+ // session's own.
+ for (0..pardes.views.max) |k| if (k != core.view and pardes.views.isOpen(core, @intCast(k)) and !pardes.views.isAway(core, @intCast(k))) core.closeView(@intCast(k));
+ s.terms[core.view] = primary;
+ primary.feed.view = core.view;
+ return;
+ }
+ for (rec.ttys[0..rec.nttys]) |t| {
+ if (!pardes.views.isOpen(core, t.view) or s.terms[t.view] != null) {
+ if (t.primary) continue;
+ _ = libc.close(t.fd);
+ if (t.stub >= 0) daemon.tellDetached(t.stub);
+ continue;
+ }
+ const sc = if (t.primary) primary else extra: {
+ const sc = s.gpa.create(Screen) catch break :extra null;
+ const buf = s.gpa.alloc(u8, 0x10000) catch {
+ s.gpa.destroy(sc);
+ break :extra null;
+ };
+ sc.* = .{ .io = s.io, .gpa = s.gpa, .env = primary.env, .buf = buf, .kitty = .init(s.gpa) };
+ const tty = Screen.ttyOn(s.io, sc.buf, t.fd, t.termios) catch {
+ s.freeScreen(sc);
+ break :extra null;
+ };
+ sc.enter(tty) catch {
+ s.freeScreen(sc);
+ break :extra null;
+ };
+ sc.setStub(t.stub);
+ startInput(s.loop, sc) catch {};
+ sc.vx.queryTerminalSend(sc.tty.writer()) catch {};
+ break :extra sc;
+ } orelse {
+ _ = libc.close(t.fd);
+ if (t.stub >= 0) daemon.tellDetached(t.stub);
+ continue;
+ };
+ sc.feed.view = t.view;
+ s.terms[t.view] = sc;
+ }
+ for (0..pardes.views.max) |k| if (pardes.views.isOpen(core, @intCast(k)) and s.terms[k] == null and !pardes.views.isAway(core, @intCast(k))) core.closeView(@intCast(k));
+ if (s.terms[core.view] == null) s.terms[core.view] = primary;
+ }
+
+ /// One shell of a dead session (`pid` 0: the last of them was told).
+ fn adoptShell(s: *Shell, pid: posix.pid_t, fd: posix.fd_t) void {
+ const core = s.core;
+ if (pid == 0) {
+ var buf: [96]u8 = undefined;
+ return core.setMessage(core.active, if (s.adopted == 0) "Adopt: no shell of a session that died is waiting" else std.fmt.bufPrint(&buf, "Adopt: {d} shell{s} taken in; what they showed is gone", .{ s.adopted, if (s.adopted == 1) "" else "s" }) catch "Adopt: shells taken in");
+ }
+ if (s.adoptions_len < s.adoptions.len) {
+ // A terminal pane, as the Term word makes one; its spawn takes
+ // this pty instead of forking a shell (`spawn`).
+ s.adoptions[s.adoptions_len] = .{ .pid = pid, .fd = fd, .pane = null };
+ s.adoptions_len += 1;
+ if (core.adoptShell()) |id| {
+ s.adoptions[s.adoptions_len - 1].pane = id;
+ s.adopted += 1;
+ return;
+ }
+ s.adoptions_len -= 1;
+ }
+ // No room for it: its master goes, and the shell with this session.
+ _ = libc.close(fd);
+ var buf: [96]u8 = undefined;
+ core.setMessage(core.active, std.fmt.bufPrint(&buf, "Adopt: no room for shell {d}; it ends with this session", .{pid}) catch "Adopt: no room for a shell");
+ }
+
+ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
+ const s = of(ctx);
+ // The wait is the 9P connections' turn with the core. A timeout (the
+ // core's next wake) arrives through the same queue (`wakeWatch`).
+ // While anything moves, a frame a tick (animation.frame_ns) on a grid
+ // of them, as the GUI paces to its display: the loop ran as fast as
+ // the terminal answered, a frame every 2 ms, each a write. An input
+ // ends the wait at once and its frame is drawn then; the ticks after
+ // it run from it.
+ var wait = timeout_ms;
+ // Detached, nobody's key dismisses a message: they go on the clock
+ // (the pump's, after this wait), which wakes it.
+ if (!s.attached()) {
+ for (s.core.panes) |slot| if (slot) |pane| if (pane.msg_len > 0) {
+ wait = if (wait == 0) 100 else @min(wait, 100);
+ break;
+ };
+ }
+ const paced = s.test_clock == null and s.core.continuous();
+ var tick: u64 = 0;
+ if (paced) {
+ const period = pardes.animation.frame_ns;
+ const now: u64 = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ tick = if (s.pace_ns != 0 and now -| s.pace_ns < 2 * period) s.pace_ns + period else now;
+ if (tick < now) tick += (now - tick) / period * period;
+ s.pace_ns = tick;
+ wait = @intCast(@max(1, (tick -| now) / std.time.ns_per_ms));
+ }
+ s.input_seen = false;
+ s.output_seen = false;
+ s.took_input = false;
+ s.took_output = false;
+ s.mail_only = true;
+ defer s.waited = true;
+ // Paced, what is not an input (a frame's ack, a pty's output) is
+ // taken in and the wait goes on to the tick: the acks alone ran the
+ // loop at the terminal's round trip.
+ while (true) {
+ s.waitOnce(wait);
+ if (!paced or s.input_seen or s.core.quit) break;
+ const now: u64 = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ if (now + std.time.ns_per_ms > tick) break;
+ wait = @intCast((tick - now) / std.time.ns_per_ms);
+ }
+ if (paced and s.input_seen) s.pace_ns = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ // Output alone is drawn a frame a tick at most, what came in till
+ // then in one: a flood (`yes`, 4 KB a read) was drawn a read at a
+ // time, nearly all of its frames written over before they were
+ // seen. Never while what someone waits on is undrawn: an input
+ // (its frame held for the terminal's answer, FrameAck), or the
+ // focused pane's output soon after one, its echo (a remote shell's
+ // an RTT later).
+ while (!paced and s.output_seen and !s.input_seen and !s.core.quit and s.test_clock == null) {
+ if (s.input_ns > s.drawn_ns) break;
+ if (s.focused_ns > s.drawn_ns and s.focused_ns -| s.input_ns < std.time.ns_per_s) break;
+ const due = s.drawn_ns + pardes.animation.frame_ns;
+ const now: u64 = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ if (now + std.time.ns_per_ms > due) break;
+ s.waitOnce(@intCast((due - now) / std.time.ns_per_ms));
+ }
+ }
+
+ fn waitOnce(s: *Shell, wait: u32) void {
+ var batch: usize = 0;
+ const first = if (s.held) |held| held: {
+ s.held = null;
+ break :held held;
+ } else next: {
+ if (wait != 0) {
+ // A virtual clock moves a frame a wake while anything moves
+ // continuously (the glide), as the real one would.
+ s.wake_to = s.core.nextWake() orelse if (s.core.continuous()) s.core.now_ns + pardes.animation.frame_ns else 0;
+ requestWake(s.io, wait);
+ }
+ pardes.turn.rest();
+ const got = s.loop.nextEvent() catch {
+ pardes.turn.wake();
+ s.core.quit = true;
+ return s.reloadWatched();
+ };
+ pardes.turn.wake();
+ break :next got;
+ };
+ batch = 1;
+ // A run of queued motions is one move to its last cell: each would
+ // otherwise redo hover and selection work the next one undoes.
+ var motion: ?@TypeOf(Command.value) = null;
+ var ev = first;
+ while (true) {
+ if (s.split(ev)) break;
+ if (ev == .mouse and (ev.mouse.type == .motion or ev.mouse.type == .drag)) {
+ if (motion) |m| if (m.mouse.button != ev.mouse.button or m.mouse.type != ev.mouse.type or
+ @as(u3, @bitCast(m.mouse.mods)) != @as(u3, @bitCast(ev.mouse.mods)))
+ {
+ _ = s.apply(m);
+ };
+ motion = ev;
+ } else {
+ if (motion) |m| _ = s.apply(m);
+ motion = null;
+ if (s.apply(ev)) break;
+ }
+ if (!s.in_paste and batch >= 64) break;
+ ev = (s.loop.tryEvent() catch null) orelse break;
+ batch += 1;
+ }
+ if (motion) |m| _ = s.apply(m);
+ // An exit's wake (a .nop) or output an exit waited behind: told
+ // here, inside the step, so the frame after it shows it.
+ s.takeExits();
+ s.reloadWatched();
+ }
+
+ /// With replica clients, a wait (one pump, one unit) takes one step of
+ /// a person's input, and none after a pty's output: a step reads the
+ /// terminals as the clients' deltas bring them, sent after each unit
+ /// (docs/next-daemon.md, part B terminal notes). One that must wait is
+ /// held for the next. Whether `ev` is.
+ fn split(s: *Shell, ev: @TypeOf(Command.value)) bool {
+ if (!s.peers.recording) return false;
+ switch (ev) {
+ .pty_read => {
+ s.took_output = true;
+ return false;
+ },
+ .key_press => if (s.in_paste) return false,
+ .mouse, .paste, .paste_end, .winsize, .focus_in, .focus_out => {},
+ else => return false,
+ }
+ if (s.took_output or s.took_input) {
+ s.held = ev;
+ s.input_seen = true;
+ return true;
+ }
+ s.took_input = true;
+ return false;
+ }
+
+ fn apply(s: *Shell, event: @TypeOf(Command.value)) bool {
+ const core = s.core;
+ const tz_event = tracy.zone(@src(), "event");
+ defer tz_event.end();
+ // A key's or a click's time, for its latency to the frame that
+ // answers it (FrameStats): when the loop takes it in.
+ switch (event) {
+ .key_press => {
+ core.frames.input(pardes.FrameStats.nowNs());
+ s.input_seen = true;
+ },
+ .mouse => |m| if (m.type == .press) {
+ core.frames.input(pardes.FrameStats.nowNs());
+ s.input_seen = true;
+ },
+ .paste, .paste_start, .winsize => s.input_seen = true,
+ else => {},
+ }
+ if (s.input_seen) s.input_ns = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ if (event != .replica_mail) s.mail_only = false;
+ // A terminal's input goes into its view; a closed one's last is
+ // dropped.
+ switch (event) {
+ .key_press, .mouse, .paste, .paste_start, .paste_end, .winsize, .focus_in, .focus_out, .quit => {
+ if (s.terms[s.from] == null and s.local()) {
+ if (event == .paste) s.gpa.free(@constCast(event.paste));
+ return false;
+ }
+ if (s.local() and s.remote == null) core.toView(s.from);
+ },
+ else => {},
+ }
+ switch (event) {
+ .nop => {},
+ .from => |k| s.from = k,
+ .winched => s.winched(),
+ // A terminal hung up (its stub passes the hangup on) or its stub
+ // died (a forked session's death signal): that one's input has
+ // ended. A HUP says not whose: each is asked.
+ .hangup => for (s.terms, 0..) |slot, k| if (slot) |sc| if (sc.on and sc.hungUp()) {
+ s.from = @intCast(k);
+ if (s.apply(.quit)) return true;
+ },
+ .wake => if (s.test_clock) |*virtual| {
+ virtual.* = @max(virtual.*, s.wake_to);
+ },
+ .quit => {
+ if (s.remote) |c| {
+ c.link.quit = true;
+ return true;
+ }
+ // One of several: its view goes with it.
+ if (pardes.views.count(core) > 1) {
+ s.dropView(core.view, .detach);
+ return true;
+ }
+ // The terminal went: a session the daemon keeps carries on
+ // without it, to be attached again. Gone before the first
+ // frame, the reader that takes the daemon's `ok` (kept
+ // waits on it) is not started yet: started here.
+ daemon.watch(s.loop, deliverNote);
+ if (daemon.kept()) {
+ if (s.attached()) s.leaveTerminal();
+ return true;
+ }
+ core.quit = true;
+ return true;
+ },
+ .attach => |a| s.attachTerminal(a.tty, a.stub, null),
+ .adopted => |a| s.adoptShell(a.pid, a.fd),
+ .replica => |j| {
+ s.peers.handed(j.fd, j.view);
+ s.input_seen = true;
+ },
+ .replica_mail => s.input_seen = true,
+ .said => |said| if (s.remote) |c| {
+ c.link.take(said);
+ if (said == .refused) return true;
+ } else switch (said) {
+ .unit, .screen, .refused => |b| std.heap.c_allocator.free(b),
+ .checked => {},
+ },
+ .link_gone => if (s.remote) |c| {
+ c.link.quit = true;
+ c.link.gone = true;
+ return true;
+ },
+ .focus_in => s.feed(.{ .focus = true }),
+ .focus_out => {
+ s.feed(.pointer_leave);
+ s.feed(.{ .focus = false });
+ },
+ .winsize => |ws| if (s.attached()) s.resized(s.terms[s.from], ws),
+ .pty_read => |pr| {
+ tookRead(s.io, pr.id);
+ s.output_seen = true;
+ if (pr.id == core.active) s.focused_ns = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ if (s.gens[pr.id] == pr.gen)
+ core.update(.{ .output = .{ .pane = @intCast(pr.id), .bytes = pr.bytes } });
+ s.gpa.free(pr.bytes);
+ // An exit waiting behind this output may be told now.
+ s.takeExits();
+ return true;
+ },
+ .pty_eof => |e| if (s.gens[e.id] == e.gen and !s.upgrading) {
+ if (s.ptys[e.id]) |*pt| {
+ pt.reader.await(s.io) catch {}; // reader just finished; join it or its future leaks
+ // A command's pty stays open until its child has exited:
+ // closing it would hang up one that runs on without it.
+ // Its exit, if it came first, is told now its output is in.
+ if (pt.cmd.watched) {
+ host_io.commandEof(core, &s.ptys, e.id, s, closeWatched);
+ return true;
+ }
+ _ = libc.close(pt.file.handle);
+ // Unwatched, a command's exit is read here, as its end,
+ // and a shell's, for a run waiting on it and the log.
+ const command = if (core.panes[e.id]) |pn| pn.command != null else false;
+ const status = host_io.exitStatus(pt.pid, 100);
+ if (status == null) host_io.retireShell(pt.pid);
+ s.ptys[e.id] = null;
+ if (command or status != null) core.update(.{ .exited = .{ .pane = @intCast(e.id), .status = status } });
+ }
+ core.update(.{ .eof = .{ .pane = @intCast(e.id) } });
+ },
+ .key_press => |key| if (s.in_paste) {
+ const bytes = pasteBytes(key);
+ const room = max_paste_bytes -| s.paste_buf.written().len;
+ s.paste_buf.writer.writeAll(bytes[0..@min(bytes.len, room)]) catch {};
+ } else s.feed(vaxis_input.keyEvent(key)),
+ .mouse => |m| {
+ const pdf_before = nativePdfWheelTarget(core, m);
+ if (mouseEvent(m)) |ev| s.feed(ev);
+ if (pdf_before) |before| {
+ if (core.panes[before.pane]) |pane| {
+ if (pane.pdfPage()) |page| {
+ if (page != before.page) return true;
+ }
+ }
+ }
+ },
+ .paste => |bytes| {
+ s.feed(.{ .paste = bytes });
+ s.gpa.free(@constCast(bytes));
+ },
+ .paste_start => {
+ s.in_paste = true;
+ s.paste_buf.clearRetainingCapacity();
+ },
+ .paste_end => {
+ s.in_paste = false;
+ const pasted = s.paste_buf.written();
+ if (pasted.len > 0) s.feed(.{ .paste = pasted });
+ s.paste_buf.clearRetainingCapacity();
+ },
+ .files_changed => s.check_files = true,
+ .fs_ready => {},
+ .lsp_done => |d| {
+ core.update(.{ .lsp_resp = .{ .id = d.id, .rows = d.rows } });
+ if (d.rows) |rows| s.lsp_gpa.free(rows);
+ if (s.lsp_task) |*t| if (t.id == d.id) {
+ t.future.await(s.io);
+ s.lsp_task = null;
+ };
+ },
+ .lsp_status => |text| {
+ var mbuf: [256]u8 = undefined;
+ core.setStatus(core.active, message.stamp(&mbuf, "lsp", text));
+ s.lsp_gpa.free(text);
+ },
+ .pipe_done => |response_value| {
+ var response = response_value;
+ core.update(.{ .pipe_resp = .{
+ .id = response.id,
+ .success = response.success,
+ .outputs = response.outputs,
+ .failure = response.failure,
+ } });
+ response.deinit(s.gpa);
+ s.pipe_tasks.finish(s.io, response_value.id);
+ },
+ .search_rows => |b| {
+ core.update(.{ .search = b });
+ b.deinit(s.gpa);
+ },
+ }
+ return false;
+ }
+
+ /// Terminal `screen` (the live view's) is `ws` big.
+ fn resized(s: *Shell, screen: ?*Screen, ws: vaxis.Winsize) void {
+ if (screen) |sc| {
+ sc.size = ws;
+ sc.vx.resize(s.gpa, sc.tty.writer(), ws) catch {};
+ }
+ s.feed(.{ .resize = if (comptime pardes.pdf_enabled) terminalSize(ws.cols, ws.rows, ws.x_pixel, ws.y_pixel) else .{ .cols = ws.cols, .rows = ws.rows } });
+ }
+
+ /// A SIGWINCH: each terminal whose size it changed is resized, in its
+ /// view (a terminal reporting in band says so as input).
+ fn winched(s: *Shell) void {
+ for (s.terms, 0..) |slot, k| {
+ const sc = slot orelse continue;
+ if (!sc.on or sc.vx.state.in_band_resize) continue;
+ const ws = sc.tty.getWinsize() catch continue;
+ if (sc.size) |was| if (std.meta.eql(was, ws)) continue;
+ if (s.remote == null) s.core.toView(@intCast(k));
+ s.resized(sc, ws);
+ }
+ }
+
+ fn reloadWatched(s: *Shell) void {
+ if (!s.check_files) return;
+ s.check_files = false;
+ if (file_watch.reloadChanged(s.core, s.io, s.gpa, &s.watches))
+ s.loop.postEvent(.files_changed) catch {};
+ }
+
+ /// ponytail: a terminal's scrollback under the wheel lands here (the
+ /// wheel reaches the core as a mouse event, not counted as the GUI's
+ /// notches are); `wheeled` from the mouse event if it should glide.
+ fn stepGlide(ctx: ?*anyopaque) void {
+ const s = of(ctx);
+ if (s.term()) |sc| sc.glide.step(s.core, s.gpa, null, null);
+ }
+
+ fn pollFrame(ctx: ?*anyopaque) void {
+ const s = of(ctx);
+ stepGlide(ctx);
+ if (s.fs) |f| if (f.tick().pending) {
+ _ = s.loop.tryPostEvent(.fs_ready) catch {};
+ };
+ for (&s.ptys, 0..) |*slot, id| if (slot.*) |pt| {
+ var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ if (host_io.ttyCwd(pt.pid, pt.file.handle, s.core.settings.shell.effective.get(), &lbuf)) |cwd| s.core.setCwd(id, cwd);
+ };
+
+ const sc = s.term() orelse return;
+ s.core.native_image_patches = sc.feed.shm.load(.acquire);
+ if (sc.caps_pending and sc.on and sc.vx.queries_done.load(.unordered)) {
+ sc.caps_pending = false;
+ sc.vx.enableDetectedFeatures(sc.tty.writer()) catch {};
+ s.core.native_images = sc.vx.caps.kitty_graphics;
+ if (sc.vx.caps.kitty_graphics) kittyShmProbe(sc.tty.writer(), &sc.feed);
+ sc.vx.queueRefresh();
+ s.core.needs_frame = true;
+ }
+ }
+
+ fn present(ctx: ?*anyopaque, canonical: *const pardes.Surface) void {
+ const s = of(ctx);
+ const sc = s.term() orelse return;
+ const vx = &sc.vx;
+ sc.tracks = canonical.panelTracks();
+ // The last frame is not answered yet: this one stays owed, and the
+ // answer's wake draws the state as it is then.
+ if (sc.feed.ack.holds(@intCast(std.Io.Clock.awake.now(s.io).nanoseconds), s.io)) {
+ s.core.present_skipped = true;
+ return;
+ }
+ _ = s.frame.reset(.retain_capacity);
+ const surface = panel_compositor.compose(
+ s.frame.allocator(),
+ @constCast(canonical),
+ sc.tracks,
+ s.core.theme().bg,
+ ) catch return;
+ const tz_cells = tracy.zone(@src(), "surface->vaxis");
+ const win = vx.window();
+ const truecolor = vx.caps.rgb or colortermTruecolor();
+ // Each of the shell's own motions below asks for frames while it runs.
+ if (sc.glide.pending) sc.glide.measure(s.gpa, canonical);
+ if (sc.glide.moving()) sc.glide.advance(s.core.now_ns, sc.glide.motion);
+ s.core.shell_continuous = sc.glide.moving();
+ s.core.frames.scroll = @round(sc.glide.follow.offset);
+ const glided = pardes.glide.shifted(&sc.glide, s.frame.allocator(), surface) catch surface;
+ const shadowed = chipShadows(s.frame.allocator(), glided, s.core, truecolor) catch glided;
+ const flashed = sc.flash.apply(s.frame.allocator(), shadowed, s.core, truecolor) catch shadowed;
+ const trailed = sc.trail.apply(s.frame.allocator(), flashed, s.core, truecolor) catch flashed;
+ paintCells(win, trailed.cells, trailed.cols, trailed.rows);
+ if (s.remote) |c| if (c.link.notice_len > 0) noticeLine(win, c.link.notice(), trailed.cols, trailed.rows);
+ tz_cells.end();
+ for (surface.images[0..surface.nimages]) |maybe| {
+ const place = maybe orelse continue;
+ if (panel_compositor.hidesAttachment(surface.panelTracks(), place.serial)) continue;
+ if (comptime pardes.pdf_enabled) {
+ if (!kittyImageRepresentable(place)) continue;
+ }
+ const key = place.cacheKey();
+ if (!sc.kitty.contains(key) and vx.caps.kitty_graphics and sc.feed.shm.load(.acquire)) shm: {
+ var buf: [64]u8 = undefined;
+ kitty_shm_serial +%= 1;
+ // Bounded: a segment this many transmissions old was never
+ // read (a terminal reads one as its command arrives), and a
+ // tmpfs holds it in memory until it goes.
+ if (kitty_shm_serial > kitty_shm_window) {
+ var old_buf: [64]u8 = undefined;
+ if (kittyShmName(&old_buf, kitty_shm_serial - kitty_shm_window)) |old| _ = libc.shm_unlink(old) else |_| {}
+ }
+ const name = kittyShmName(&buf, kitty_shm_serial) catch break :shm;
+ if (!kittyShmWrite(name, place.rgba)) break :shm;
+ if (vx.transmitLocalImagePath(s.gpa, sc.tty.writer(), name, @intCast(place.iw), @intCast(place.ih), .shared_mem, .rgba) catch null) |handle|
+ sc.kitty.put(key, handle) catch vx.freeImage(sc.tty.writer(), handle.id)
+ else
+ _ = libc.shm_unlink(name);
+ }
+ if (!sc.kitty.contains(key) and vx.caps.kitty_graphics) {
+ const enc = std.base64.standard.Encoder;
+ if (s.gpa.alloc(u8, enc.calcSize(place.rgba.len))) |b64| {
+ defer s.gpa.free(b64);
+ _ = enc.encode(b64, place.rgba);
+ if (vx.transmitPreEncodedImage(sc.tty.writer(), b64, @intCast(place.iw), @intCast(place.ih), .rgba) catch null) |handle|
+ sc.kitty.put(key, handle) catch vx.freeImage(sc.tty.writer(), handle.id);
+ } else |_| {}
+ }
+ if (sc.kitty.get(key)) |cached| {
+ if (comptime !pardes.pdf_enabled) {
+ const child = win.child(.{ .x_off = place.x, .y_off = place.y, .width = place.w, .height = place.h });
+ cached.draw(child, .{ .scale = .contain }) catch {};
+ } else {
+ if (place.native.exact) {
+ if (exactKittyPlacement(place, vx.screen.width, vx.screen.height, vx.screen.width_pix, vx.screen.height_pix)) |placement| {
+ // The cell keeps its own glyph and colours
+ // (Image.draw would reset them): a fragment
+ // short of the cell shows the pane under it.
+ const x = place.x + placement.cell_x;
+ if (win.readCell(x, place.y)) |under| {
+ var cell = under;
+ cell.image = .{ .img_id = cached.id, .options = placement.options };
+ win.writeCell(x, place.y, cell);
+ }
+ }
+ } else if (place.native.fit == .contain) {
+ const child = win.child(.{ .x_off = place.x, .y_off = place.y, .width = place.w, .height = place.h });
+ cached.draw(child, .{ .scale = .contain }) catch {};
+ } else if (kittyPlacement(
+ place,
+ vx.screen.width,
+ vx.screen.height,
+ vx.screen.width_pix,
+ vx.screen.height_pix,
+ )) |placement| {
+ const child = win.child(.{
+ .x_off = @as(i17, place.x) + placement.cell_x,
+ .y_off = @as(i17, place.y) + placement.cell_y,
+ .width = placement.cell_cols,
+ .height = placement.cell_rows,
+ });
+ cached.draw(child, placement.options) catch {};
+ }
+ }
+ }
+ }
+ while (true) {
+ var stale: [pardes.MAX_PANES]pardes.ImageCacheKey = undefined;
+ var stale_len: usize = 0;
+ var image_iterator = sc.kitty.iterator();
+ while (image_iterator.next()) |entry| {
+ if (surfaceHasKittyKey(surface, entry.key_ptr.*)) continue;
+ stale[stale_len] = entry.key_ptr.*;
+ stale_len += 1;
+ if (stale_len == stale.len) break;
+ }
+ for (stale[0..stale_len]) |key| if (sc.kitty.fetchRemove(key)) |removed|
+ vx.freeImage(sc.tty.writer(), removed.value.id);
+ if (stale_len < stale.len) break;
+ }
+ if (glided.cursor) |cur| paintCursor(win, cur.x, cur.y, cur.bar);
+ const tz_render = tracy.zone(@src(), "vx.render");
+ const before = sc.tty.tty_writer.pos + sc.tty.writer().end;
+ vx.render(sc.tty.writer()) catch {};
+ // The frame's cost to the terminal (FrameStats.Frame.bytes): what
+ // vaxis's diff of the cells wrote.
+ s.core.frames.bytes +|= @intCast(@min(std.math.maxInt(u32), sc.tty.tty_writer.pos + sc.tty.writer().end -| before));
+ if (sc.tty.tty_writer.pos + sc.tty.writer().end != before) sc.feed.ack.ask(sc.tty.writer(), @intCast(std.Io.Clock.awake.now(s.io).nanoseconds));
+ s.drawn_ns = @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
+ tz_render.end();
+ }
+
+ fn postPresent(ctx: ?*anyopaque) void {
+ const s = of(ctx);
+ if (s.term()) |sc| s.core.acknowledgePanelPresentation(sc.tracks);
+ tracy.frameMark();
+ }
+
+ fn spawn(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
+ const s = of(ctx);
+ for (s.adoptions[0..s.adoptions_len], 0..) |a, i| if (a.pane == pane) {
+ std.mem.copyForwards(Adoption, s.adoptions[i .. s.adoptions_len - 1], s.adoptions[i + 1 .. s.adoptions_len]);
+ s.adoptions_len -= 1;
+ return s.takeShell(pane, a);
+ };
+ // The new shell starts before a running one goes: one that cannot
+ // start leaves the running one be (pty/ctl's exec).
+ const running = s.ptys[pane] != null;
+ const child = host_io.forkShell(s.core, pane, s.prompt_rcs, s.core.shellBin(), cwd, s.core.screen_h, s.core.screen_w, s.fs) catch |err| {
+ if (running) return s.core.restartFailed(pane, err);
+ return s.core.shellFailed(pane, err);
+ };
+ closePty(ctx, pane); // a shell still in the slot goes, reaped
+ s.gens[pane] +%= 1;
+ const command = if (s.core.panes[pane]) |pn| pn.command != null else false;
+ s.ptys[pane] = .{ .file = child.file, .pid = child.pid, .reader = .{ .any_future = null, .result = {} }, .cmd = .{ .watched = command and host_io.watchExit(child.pid), .fd = child.file.handle } };
+ var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ // Only a shell given no directory is asked where it is: one given a
+ // directory is named by it already (newShell), and asked now, before
+ // its chdir, it would answer this process's, a rename to undo.
+ if (cwd.len == 0) if (host_io.shellCwd(child.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
+ if (s.threads_ok) {
+ if (s.ptys[pane]) |*pt| {
+ pt.reader = s.io.concurrent(readPty, .{ s.io, s.gpa, pt.file, @as(usize, pane), s.gens[pane], s.loop }) catch pt.reader;
+ }
+ }
+ }
+
+ /// An adopted shell, running already, as pane `pane`'s: told the size
+ /// twice (a size it never had, then the pane's), which makes it redraw.
+ fn takeShell(s: *Shell, pane: u8, a: Adoption) void {
+ closePty(s, pane);
+ s.gens[pane] +%= 1;
+ const file: std.Io.File = .{ .handle = a.fd, .flags = .{ .nonblocking = false } };
+ s.ptys[pane] = .{ .file = file, .pid = a.pid, .reader = .{ .any_future = null, .result = {} }, .cmd = .{} };
+ var exe_buf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ s.core.acknowledgeShell(pane, host_io.processExe(a.pid, &exe_buf) orelse "sh", host_io.marksPrompts(a.pid));
+ var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ if (host_io.shellCwd(a.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
+ const tiny: posix.winsize = .{ .row = 1, .col = 1, .xpixel = 0, .ypixel = 0 };
+ _ = posix.system.ioctl(a.fd, TIOCSWINSZ, @intFromPtr(&tiny));
+ if (s.core.panes[pane]) |pn| ptyResize(s, pane, @max(pn.cols, 1), @max(pn.rows, 1));
+ if (s.threads_ok) if (s.ptys[pane]) |*pt| {
+ pt.reader = s.io.concurrent(readPty, .{ s.io, s.gpa, pt.file, @as(usize, pane), s.gens[pane], s.loop }) catch pt.reader;
+ };
+ }
+
+ fn ptyWrite(ctx: ?*anyopaque, pane: u8, bytes: []const u8) void {
+ const s = of(ctx);
+ if (s.ptys[pane]) |pt| _ = host_io.writeFd(pt.file.handle, bytes);
+ }
+
+ fn ptyResize(ctx: ?*anyopaque, pane: u8, cols: u16, rows: u16) void {
+ const s = of(ctx);
+ if (s.ptys[pane]) |pt| {
+ const ws = host_io.ptyWinsize(s.core, cols, rows);
+ _ = posix.system.ioctl(pt.file.handle, TIOCSWINSZ, @intFromPtr(&ws));
+ }
+ }
+
+ fn ptySignal(ctx: ?*anyopaque, pane: u8, sig: pardes.PtySignal) void {
+ const s = of(ctx);
+ // A command whose exit is recorded is reaped: its group may be
+ // another's by now.
+ if (s.ptys[pane]) |pt| if (!pt.cmd.exited) host_io.signalTty(pt.pid, pt.file.handle, sig, pt.cmd.watched);
+ }
+
+ /// The pane is gone: hang its pty up, which the kernel passes on to the
+ /// shell as SIGHUP, and retire the shell. Output still in flight
+ /// carries the old generation and is dropped.
+ fn closePty(ctx: ?*anyopaque, pane: u8) void {
+ const s = of(ctx);
+ var pt = s.ptys[pane] orelse return;
+ s.ptys[pane] = null;
+ s.gens[pane] +%= 1;
+ pt.reader.cancel(s.io) catch {};
+ _ = libc.close(pt.file.handle);
+ daemon.closed(pt.pid);
+ host_io.retireShell(pt.pid);
+ }
+
+ fn ttyTaken(ctx: ?*anyopaque, pane: u8) bool {
+ const s = of(ctx);
+ const pt = s.ptys[pane] orelse return false;
+ return host_io.ttyTaken(pt.pid, pt.file.handle);
+ }
+
+ fn fgName(ctx: ?*anyopaque, pane: u8, buf: []u8) ?[]const u8 {
+ const s = of(ctx);
+ const pt = s.ptys[pane] orelse return null;
+ return host_io.foregroundName(pt.pid, pt.file.handle, buf);
+ }
+
+ /// The command panes' exits, told once their output is in (host_io).
+ fn takeExits(s: *@This()) void {
+ host_io.takeExits(s.core, &s.ptys, s, closeWatched);
+ }
+
+ fn closeWatched(s: *@This(), id: usize) void {
+ const pt = &(s.ptys[id] orelse return);
+ _ = libc.close(pt.file.handle);
+ s.ptys[id] = null;
+ }
+
+ fn killJob(ctx: ?*anyopaque, pane: u8) bool {
+ const s = of(ctx);
+ const pt = s.ptys[pane] orelse return false;
+ return host_io.killJob(pt.pid, pt.file.handle);
+ }
+
+ fn writeFile(ctx: ?*anyopaque, pane: u8, path: []const u8, bytes: []const u8) void {
+ const s = of(ctx);
+ host_io.writeFile(s.core, &s.watches, pane, path, bytes);
+ }
+
+ fn writeDump(ctx: ?*anyopaque, bytes: []const u8) void {
+ host_io.writeDump(of(ctx).core, bytes);
+ }
+
+ fn watchFile(ctx: ?*anyopaque, pane: u8, _: []const u8, on: bool, mode: pardes.WatchMode) void {
+ const s = of(ctx);
+ if (file_watch.applyEffect(s.core, s.io, s.inotify_fd, &s.watches, pane, on, mode))
+ s.loop.postEvent(.files_changed) catch {};
+ }
+
+ fn watchTheme(ctx: ?*anyopaque, generation: u32, on: bool) void {
+ const s = of(ctx);
+ if (file_watch.applyThemeEffect(s.core, s.gpa, s.inotify_fd, &s.watches, generation, on, s.threads_ok))
+ s.loop.postEvent(.files_changed) catch {};
+ }
+
+ fn dumpThemes(ctx: ?*anyopaque, pane: u8) void {
+ const s = of(ctx);
+ host_io.dumpThemes(s.core, s.io, s.gpa, pane);
+ }
+
+ fn setClipboard(ctx: ?*anyopaque, text: []const u8) void {
+ const s = of(ctx);
+ // Detached, the session keeps it (a 9P read, a paste here).
+ const sc = s.term() orelse return s.core.fallback.setClipboard(text);
+ if (!sc.on) return s.core.fallback.setClipboard(text);
+ copyToClipboard(&sc.vx, &sc.tty, s.gpa, text);
+ }
+
+ fn readClipboard(ctx: ?*anyopaque) void {
+ const s = of(ctx);
+ const sc = s.term() orelse return s.core.update(.{ .paste = s.core.fallback.clipboard.items });
+ if (!sc.on) return s.core.update(.{ .paste = s.core.fallback.clipboard.items });
+ requestClipboard(&sc.vx, &sc.tty);
+ }
+
+ fn openLink(_: ?*anyopaque, url: []const u8) void {
+ look.openLink(url); // desktop browser; no terminal in it, so Attach calls this one directly
+ }
+
+ fn lsp(ctx: ?*anyopaque, req: host_io.Lsp.Request) void {
+ const s = of(ctx);
+ if (!s.threads_ok) {
+ s.core.update(.{ .lsp_resp = .{ .id = req.id, .rows = null } });
+ return s.core.reportError(req.pane, "lsp", error.WorkersUnavailable);
+ }
+ host_io.Lsp.start(s.io, s.lsp_gpa, s.core, &s.lsp_task, req, s, deliverLspRows);
+ }
+
+ fn deliverLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
+ const s = of(ctx);
+ s.loop.postEvent(.{ .lsp_done = .{ .id = id, .rows = rows } }) catch if (rows) |owned| s.lsp_gpa.free(owned);
+ }
+
+ fn pipe(ctx: ?*anyopaque, id: u32) void {
+ const s = of(ctx);
+ if (!s.threads_ok) {
+ s.core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
+ return s.core.reportError(s.core.active, "pipe", error.WorkersUnavailable);
+ }
+ selection_pipe.start(s.io, s.gpa, s.core, &s.pipe_tasks, id, s, deliverPipe);
+ }
+
+ fn search(ctx: ?*anyopaque, gen: u32) void {
+ const s = of(ctx);
+ if (s.threads_ok) return pardes.Stream.start(s.io, s.gpa, s.core, gen, s, deliverSearch);
+ pardes.Stream.runHere(s.core, gen);
+ }
+
+ /// The loop's queue waits for room (a wait the worker's cancel ends).
+ fn deliverSearch(ctx: ?*anyopaque, batch: pardes.Stream.Batch) bool {
+ const s = of(ctx);
+ s.loop.postEvent(.{ .search_rows = batch }) catch {
+ batch.deinit(s.gpa);
+ return false;
+ };
+ return true;
+ }
+
+ fn deliverPipe(ctx: ?*anyopaque, response: selection_pipe.Response) void {
+ const s = of(ctx);
+ var owned = response;
+ s.loop.postEvent(.{ .pipe_done = owned }) catch owned.deinit(s.gpa);
+ }
+};
+
+test "TTY queued results reject old PTY generations and LSP request IDs" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 });
+ defer core.deinit();
+ var shell: Shell = .{
+ .io = std.testing.io,
+ .gpa = gpa,
+ .lsp_gpa = gpa,
+ .core = core,
+ .prompt_rcs = undefined,
+ .loop = undefined,
+ .frame = undefined,
+ .paste_buf = undefined,
+ .inotify_fd = -1,
+ };
+ shell.gens[0] = 2;
+ _ = shell.apply(.{ .pty_read = .{ .id = 0, .gen = 1, .bytes = try gpa.dupe(u8, "old session\n") } });
+ _ = shell.apply(.{ .pty_read = .{ .id = 0, .gen = 2, .bytes = try gpa.dupe(u8, "current session\n") } });
+ const text = try pardes.panes.terminal.screenTextAlloc(core.panes[0].?, gpa);
+ defer gpa.free(text);
+ try std.testing.expect(std.mem.indexOf(u8, text, "old session") == null);
+ try std.testing.expect(std.mem.indexOf(u8, text, "current session") != null);
+
+ core.lspRequest(0, .status, "");
+ const old_id = core.lsp_wait.?.id;
+ core.lspRequest(0, .status, "");
+ const current_id = core.lsp_wait.?.id;
+ shell.lsp_task = .{ .id = current_id, .future = .{ .any_future = null, .result = {} } };
+ _ = shell.apply(.{ .lsp_done = .{ .id = old_id, .rows = try gpa.dupe(u8, "stale result\n") } });
+ try std.testing.expect(shell.lsp_task != null);
+ try std.testing.expectEqual(current_id, shell.lsp_task.?.id);
+ try std.testing.expectEqual(current_id, core.lsp_wait.?.id);
+ _ = shell.apply(.{ .lsp_done = .{ .id = current_id, .rows = try gpa.dupe(u8, "") } });
+ try std.testing.expect(shell.lsp_task == null);
+ try std.testing.expect(core.lsp_wait == null);
+}
+
+test "TTY worker setup failures finish matching LSP and pipe requests" {
+ const gpa = std.testing.allocator;
+ var failing_vtable = std.testing.io.vtable.*;
+ failing_vtable.concurrent = std.Io.failingConcurrent;
+ const failing_io: std.Io = .{ .userdata = std.testing.io.userdata, .vtable = &failing_vtable };
+ for (0..2) |failure| {
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ const pane = try core.setTestFile("abc");
+ var failing = std.testing.FailingAllocator.init(gpa, .{
+ .fail_index = if (failure == 0) 0 else std.math.maxInt(usize),
+ });
+ var shell: Shell = .{
+ .io = failing_io,
+ .gpa = failing.allocator(),
+ .lsp_gpa = failing.allocator(),
+ .core = core,
+ .prompt_rcs = undefined,
+ .loop = undefined,
+ .frame = undefined,
+ .paste_buf = undefined,
+ .inotify_fd = -1,
+ .threads_ok = true,
+ };
+ core.lspRequest(core.active, .status, "");
+ const req: host_io.Lsp.Request = .{
+ .id = core.lsp_wait.?.id,
+ .kind = .status,
+ .pane = @intCast(core.active),
+ .offset = 0,
+ .arg = "",
+ };
+ Shell.lsp(&shell, req);
+ try std.testing.expect(core.lsp_wait == null);
+ try std.testing.expectEqualStrings("abc", pane.file.?.content);
+
+ pane.body.cur_col = 2;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
+ core.update(.{ .key = .{ .cp = '|' } });
+ core.update(.{ .key = .{ .cp = 't', .text = "tr a-z A-Z" } });
+ core.update(.{ .key = .{ .cp = pardes.Key.enter } });
+ const pipe_id = core.pipe.wait.?.id;
+ Shell.pipe(&shell, pipe_id);
+ try std.testing.expect(core.pipe.wait == null);
+ try std.testing.expectEqualStrings("abc", pane.file.?.content);
+ try std.testing.expect(shell.lsp_task == null);
+ try std.testing.expectEqual(@as(usize, 0), shell.pipe_tasks.len);
+ }
+}
+
+fn copyToClipboard(vx: *vaxis.Vaxis, tty: *vaxis.Tty, gpa: std.mem.Allocator, text: []const u8) void {
+ if (text.len == 0) return;
+ vx.copyToSystemClipboard(tty.writer(), text, gpa) catch {};
+}
+
+fn requestClipboard(vx: *vaxis.Vaxis, tty: *vaxis.Tty) void {
+ vx.requestSystemClipboard(tty.writer()) catch {};
+}
+
+fn lspStatusSink(ctx: ?*anyopaque, text: []const u8) void {
+ const s: *Shell = @ptrCast(@alignCast(ctx orelse return));
+ const copy = s.lsp_gpa.dupe(u8, text) catch return;
+ const posted = s.loop.tryPostEvent(.{ .lsp_status = copy }) catch false;
+ if (!posted) s.lsp_gpa.free(copy);
+}
+
+fn watchFiles(io: std.Io, fd: c_int, loop: *Loop) anyerror!void {
+ if (comptime builtin.os.tag != .linux and builtin.os.tag != .freebsd) {
+ while (file_watch.wait(fd)) loop.postEvent(.files_changed) catch break;
+ return;
+ }
+ const file: std.Io.File = .{ .handle = fd, .flags = .{ .nonblocking = false } };
+ // One buffer, read into directly: a Reader around it only added a second
+ // (and in a safe build, filled both as `undefined` on every start).
+ var buf: [4096]u8 = undefined;
+ while (true) {
+ const n = file.readStreaming(io, &.{&buf}) catch break;
+ if (n == 0) break;
+ loop.postEvent(.files_changed) catch break;
+ }
+}
+
+fn keepSignal(_: posix.SIG) callconv(.c) void {}
+
+/// A replica client's (`remote`): a hangup is its end, whoever sent it.
+var hangup_quits = false;
+
+fn winchWatch(loop: *Loop) void {
+ var set = posix.sigemptyset();
+ posix.sigaddset(&set, posix.SIG.WINCH);
+ if (daemon.link >= 0 or hangup_quits) posix.sigaddset(&set, posix.SIG.HUP);
+ while (true) {
+ var sig: c_int = 0;
+ if (libc.sigwait(&set, &sig) != 0) continue;
+ // The terminals are the loop's: it asks each its size, and takes a
+ // hangup as the end of the one that hung up.
+ const ev: @TypeOf(Command.value) = if (sig != @backingInt(posix.SIG.HUP)) .winched else if (hangup_quits) .quit else .hangup;
+ loop.postEvent(ev) catch {};
+ }
+}
+
+/// A wait with a timeout: post one `.wake` when it runs out. The wake joins
+/// the input queue, so a key or a click that lands first is handled at once
+/// instead of after a blind sleep; vaxis's queue has no timed wait. Each
+/// request bumps `wake_gen`, which cuts short a sleep still timing an
+/// earlier, longer request (an 800 ms linger interrupted by a key that
+/// starts a 16 ms fall) and times the new one instead.
+var wake_gen: std.atomic.Value(u32) = .init(0);
+var wake_ms: std.atomic.Value(u32) = .init(0);
+
+fn requestWake(io: std.Io, ms: u32) void {
+ wake_ms.store(ms, .release);
+ _ = wake_gen.fetchAdd(1, .acq_rel);
+ io.futexWake(u32, &wake_gen.raw, 1);
+}
+
+fn wakeWatch(io: std.Io, loop: *Loop) void {
+ var seen = wake_gen.load(.acquire);
+ while (true) {
+ // Asleep until a request.
+ while (wake_gen.load(.acquire) == seen) io.futexWaitUncancelable(u32, &wake_gen.raw, seen);
+ seen = wake_gen.load(.acquire);
+ if (timeWake(io, &seen)) loop.postEvent(.wake) catch {};
+ }
+}
+
+/// Sleep out the latest request; true when it ran its course, false when
+/// none is pending. A newer request met on the way restarts the timing.
+fn timeWake(io: std.Io, seen: *u32) bool {
+ while (true) {
+ const ms = wake_ms.load(.acquire);
+ const deadline = @as(u64, @intCast(std.Io.Clock.awake.now(io).nanoseconds)) + @as(u64, ms) * std.time.ns_per_ms;
+ while (true) {
+ const now: u64 = @intCast(std.Io.Clock.awake.now(io).nanoseconds);
+ if (now >= deadline) return true;
+ io.futexWaitTimeout(u32, &wake_gen.raw, seen.*, .{ .duration = .{
+ .raw = .fromNanoseconds(@intCast(deadline - now)),
+ .clock = .awake,
+ } }) catch {};
+ const gen = wake_gen.load(.acquire);
+ if (gen != seen.*) {
+ seen.* = gen;
+ break;
+ }
+ }
+ }
+}
+
+test "a short wake request cuts short a long one still sleeping" {
+ const io = std.testing.io;
+ var seen = wake_gen.load(.acquire);
+ requestWake(io, 800);
+ seen = wake_gen.load(.acquire);
+ const Timer = struct {
+ fn run(timer_io: std.Io, start_seen: u32, done: *std.atomic.Value(u64)) void {
+ var local = start_seen;
+ _ = timeWake(timer_io, &local);
+ done.store(@intCast(std.Io.Clock.awake.now(timer_io).nanoseconds), .release);
+ }
+ };
+ var done: std.atomic.Value(u64) = .init(0);
+ const start: u64 = @intCast(std.Io.Clock.awake.now(io).nanoseconds);
+ const thread = try std.Thread.spawn(.{}, Timer.run, .{ io, seen, &done });
+ try io.sleep(.fromMilliseconds(50), .awake);
+ requestWake(io, 16);
+ thread.join();
+ // The 16 ms request lands about 66 ms in: well before the 800 ms one
+ // would have, however loaded the machine.
+ try std.testing.expect(done.load(.acquire) - start < 700 * std.time.ns_per_ms);
+}
+
+fn wakeFs(ctx: ?*anyopaque) void {
+ const loop: *Loop = @ptrCast(@alignCast(ctx.?));
+ _ = loop.tryPostEvent(.fs_ready) catch {};
+}
+
+/// Each pane's reads posted and not yet taken in. Two at most: a flood the
+/// loop cannot keep up with waits in its pty, not in the queue ahead of a
+/// key and its echo (hundreds of 4 KB reads queued were half a second).
+var reads_queued: [pardes.MAX_PANES]std.atomic.Value(u32) = @splat(.init(0));
+
+/// A read of pane `id` taken in (or dropped): its reader may read on. Never
+/// below zero, for an event no reader posted (a test's).
+fn tookRead(io: std.Io, id: usize) void {
+ var queued = reads_queued[id].load(.acquire);
+ while (queued > 0) queued = reads_queued[id].cmpxchgWeak(queued, queued - 1, .acq_rel, .acquire) orelse {
+ if (queued == 2) io.futexWake(u32, &reads_queued[id].raw, 1);
+ return;
+ };
+}
+
+fn readPty(io: std.Io, gpa: std.mem.Allocator, pty: std.Io.File, id: usize, gen: u32, loop: *Loop) anyerror!void {
+ // One buffer, read into directly: a Reader around it only added a second
+ // (and in a safe build, filled both as `undefined` on every start).
+ var buf: [0x10000]u8 = undefined;
+ read: while (true) {
+ while (true) {
+ const queued = reads_queued[id].load(.acquire);
+ if (queued < 2) break;
+ io.futexWait(u32, &reads_queued[id].raw, queued) catch break :read;
+ }
+ const n = pty.readStreaming(io, &.{&buf}) catch break;
+ if (n == 0) break;
+ const bytes = try gpa.dupe(u8, buf[0..n]);
+ _ = reads_queued[id].fetchAdd(1, .acq_rel);
+ loop.postEvent(.{ .pty_read = .{ .id = id, .gen = gen, .bytes = bytes } }) catch {
+ tookRead(io, id);
+ gpa.free(bytes);
+ break;
+ };
+ }
+ _ = loop.tryPostEvent(.{ .pty_eof = .{ .id = id, .gen = gen } }) catch {};
+}
+
+const max_paste_bytes: usize = pardes.memory.limits.max_paste_bytes;
+
+fn pasteBytes(key: vaxis.Key) []const u8 {
+ const text = key.text orelse "";
+ if (text.len > 0) return text;
+ const cp = vaxis_input.mapKey(vaxis_input.effCp(key));
+ if (cp == pardes.Key.tab) return "\t";
+ if (cp == pardes.Key.enter or (key.mods.ctrl and cp == 'j')) return "\n";
+ return "";
+}
+
+test "a terminal pane gets function keys as their sequences and lone modifiers not at all" {
+ if (comptime builtin.os.tag == .windows) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(io, gpa, &env, .{});
+ var output: std.Io.Writer.Allocating = .init(gpa);
+ defer output.deinit();
+ defer vx.deinit(gpa, &output.writer);
+ vx.queries_done.store(false, .unordered);
+ var tty: vaxis.Tty = undefined;
+ var loop: Loop = .init(io, &tty, &vx);
+ var feed: Feed = .{};
+ const Reader = struct {
+ parts: []const []const u8,
+ next: usize = 0,
+ fn getWinsize(_: *@This()) !vaxis.Winsize {
+ return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 };
+ }
+ pub fn inputFollows(self: *@This(), _: u32) bool {
+ return self.next < self.parts.len;
+ }
+ fn read(self: *@This(), buf: []u8) !usize {
+ if (self.next == self.parts.len) return 0;
+ const part = self.parts[self.next];
+ self.next += 1;
+ @memcpy(buf[0..part.len], part);
+ return part.len;
+ }
+ };
+ var reader: Reader = .{
+ .parts = &.{
+ // The startup width queries' answers from a terminal without
+ // explicit width (foot, ghostty, tmux): two F3s, typed at the prompt.
+ "\x1b[1;1R\x1b[1;1R\x1b[?62;c",
+ // Kitty reports Ctrl and Shift pressed on their own: the Ctrl of a
+ // Ctrl-V typed `\x1b[57442;5u` into the shell.
+ "\x1b[57442;5u\x1b[57441;2u\x1b[57358u",
+ // F3, F5 and Insert the kitty way, F3 the legacy way and the
+ // keypad's Up: once typed as private-use junk, now what htop,
+ // mc and vim read them as.
+ "\x1b[13~\x1b[15~\x1b[2~\x1bOR\x1b[57419u",
+ "\x1b[104;;104u",
+ },
+ };
+ try readInput(&loop, &reader, &vx, &feed);
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ while (try loop.tryEvent()) |event| switch (event) {
+ .key_press => |key| core.update(vaxis_input.keyEvent(key)),
+ else => {},
+ };
+ var written: std.Io.Writer.Allocating = .init(gpa);
+ defer written.deinit();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings("\x1bOR\x1b[15~\x1b[2~\x1bOR\x1b[Ah", written.written());
+}
+
+test "the terminal's keys reach a program as its cursor keys' mode and keyboard flags say" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ var written: std.Io.Writer.Allocating = .init(gpa);
+ defer written.deinit();
+ // What the outer terminal sends, what the program asked for, and what
+ // it should read.
+ const Case = struct { modes: []const u8, in: []const u8, sent: []const u8 };
+ const cases = [_]Case{
+ .{ .modes = "", .in = "\x1b[A\x1b[H\x1bOP\x1b[15~", .sent = "\x1b[A\x1b[H\x1bOP\x1b[15~" },
+ .{ .modes = "\x1b[?1h", .in = "\x1b[A\x1b[F\x1b[1;5D", .sent = "\x1bOA\x1bOF\x1b[1;5D" },
+ .{ .modes = "\x1b[?1l\x1b[>7u", .in = "\x1b[99;5u\x1b[97;3u\x1b[A", .sent = "\x1b[99;5u\x1b[97;3u\x1b[1;1:1A" },
+ };
+ for (cases) |case| {
+ core.update(.{ .output = .{ .pane = 0, .bytes = case.modes } });
+ while (core.nextEffect()) |_| {}
+ var parser: vaxis.Parser = .{};
+ var bytes = case.in;
+ while (bytes.len > 0) {
+ const result = try parser.parse(bytes, gpa);
+ if (result.n == 0) break;
+ bytes = bytes[result.n..];
+ if (result.event) |event| switch (event) {
+ .key_press => |key| core.update(vaxis_input.keyEvent(key)),
+ else => {},
+ };
+ }
+ written.clearRetainingCapacity();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings(case.sent, written.written());
+ }
+}
+
+test "keypad Enter matches Return for editor input terminal writes and paste" {
+ for ([_]u21{ vaxis.Key.enter, vaxis.Key.kp_enter }) |codepoint| {
+ const key: vaxis.Key = .{ .codepoint = codepoint };
+ const event = vaxis_input.keyEvent(key);
+ try std.testing.expectEqual(pardes.Key.enter, event.key.cp);
+ try std.testing.expectEqualStrings("\n", pasteBytes(key));
+ {
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer core.deinit();
+ const pane = try core.setTestFile("ab");
+ core.update(.{ .key = .{ .cp = 'i' } });
+ core.update(event);
+ try std.testing.expectEqualStrings("\nab", pane.file.?.content);
+ }
+ {
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ core.update(event);
+ var written: std.Io.Writer.Allocating = .init(std.testing.allocator);
+ defer written.deinit();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings("\r", written.written());
+ }
+ }
+}
+
+fn mouseEvent(m: vaxis.Mouse) ?pardes.Event {
+ const button: pardes.Mouse.Button = switch (m.button) {
+ .left => .left,
+ .middle => .middle,
+ .right => .right,
+ .wheel_up => .wheel_up,
+ .wheel_down => .wheel_down,
+ .wheel_left => .wheel_left,
+ .wheel_right => .wheel_right,
+ // A mouse's side buttons, as xterm reports them: Back and Forward.
+ .button_8 => .back,
+ .button_9 => .forward,
+ .none => .none, // button-less motion: hover tracking
+ else => return null,
+ };
+ return .{ .mouse = .{
+ .button = button,
+ .kind = switch (m.type) {
+ .press => .press,
+ .release => .release,
+ .motion => .motion,
+ .drag => .drag,
+ },
+ .col = cellOf(m.col),
+ .row = cellOf(m.row),
+ .ctrl = m.mods.ctrl,
+ .shift = m.mods.shift,
+ .alt = m.mods.alt,
+ } };
+}
+
+/// A report's cell, 0-based: one before the first (SGR's 0, a drag past
+/// the window's top or left edge, in cells or in 1016's pixels) is the
+/// first, never a panic; past the far edge the core clamps it.
+pub fn cellOf(v: i16) u16 {
+ return @intCast(@max(0, v));
+}
+
+test "a mouse report at row or column 0, or before it, is the window's edge, never a panic" {
+ const p = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ for ([_][]const u8{ "\x1b[<1;42;0M", "\x1b[<0;0;5M", "\x1b[<32;0;0M", "\x1b[<0;0;0m" }) |sequence| {
+ var parser: vaxis.Parser = .{};
+ const result = try parser.parse(sequence, std.testing.allocator);
+ const m = result.event.?.mouse;
+ const event = mouseEvent(m) orelse continue;
+ try std.testing.expect(event.mouse.col <= 41 and event.mouse.row <= 4);
+ p.update(event);
+ }
+}
+
+test "a mouse's side buttons, xterm's 8 and 9, are Back and Forward, as SDL's X1 and X2 are" {
+ for ([_]vaxis.Mouse.Button{ .button_8, .button_9 }, [_]pardes.Mouse.Button{ .back, .forward }) |from, to| {
+ const event = mouseEvent(.{ .col = 3, .row = 2, .button = from, .mods = .{}, .type = .press }).?;
+ try std.testing.expectEqual(to, event.mouse.button);
+ }
+}
+
+/// A replica client's own line over its frame's last row (`Remote.notify`),
+/// reversed. `text` is printable ASCII and outlives the render (vaxis keeps
+/// the slices).
+fn noticeLine(win: vaxis.Window, text: []const u8, cols: u16, rows: u16) void {
+ if (rows == 0) return;
+ for (0..cols) |x| win.writeCell(@intCast(x), rows - 1, .{
+ .char = .{ .grapheme = if (x < text.len) text[x..][0..1] else " " },
+ .style = .{ .reverse = true },
+ });
+}
+
+/// A blank whose ink alone changed is not sent: vaxis's render skips it
+/// (pardes's patch to Vaxis.zig in build.zig), since a blank's ink shows
+/// nowhere. Deciding that here cost every cell of every frame a look at the
+/// frame before; vaxis already makes that comparison.
+fn paintCells(win: vaxis.Window, cells: []const pardes.Cell, cols: u16, rows: u16) void {
+ win.clear();
+ var y: u16 = 0;
+ while (y < rows) : (y += 1) {
+ var x: u16 = 0;
+ while (x < cols) : (x += 1) {
+ const cell = &cells[@as(usize, y) * cols + x];
+ if (cell.default) continue;
+ win.writeCell(x, y, .{
+ .char = .{ .grapheme = cell.grapheme() },
+ .style = vaxisStyle(cell.style),
+ });
+ }
+ }
+}
+
+test "a fade sends the text it dims, not the blanks beside it" {
+ const gpa = std.testing.allocator;
+ var env = try std.testing.environ.createMap(gpa);
+ defer env.deinit();
+ var vx = try vaxis.init(std.testing.io, gpa, &env, .{});
+ var out: std.Io.Writer.Allocating = .init(gpa);
+ defer out.deinit();
+ defer vx.deinit(gpa, &out.writer);
+ try vx.resize(gpa, &out.writer, .{ .rows = 1, .cols = 32, .x_pixel = 0, .y_pixel = 0 });
+ // `a`, a gap, `b`, a two-cell gap, `c`, a gap, an underlined blank
+ // (which shows its ink) and one more blank.
+ var cells: [32]pardes.Cell = @splat(.{ .default = false });
+ cells[0].text[0] = 'a';
+ cells[12].text[0] = 'b';
+ cells[15].text[0] = 'c';
+ cells[30].style.ul = .single;
+ var sent: [2][]u8 = .{ &.{}, &.{} };
+ defer for (sent) |bytes| gpa.free(bytes);
+ for ([_][3]u8{ .{ 200, 200, 200 }, .{ 90, 90, 90 } }, 0..) |ink, frame| {
+ for (&cells) |*cell| cell.style.fg = .{ .rgb = ink };
+ out.clearRetainingCapacity();
+ paintCells(vx.window(), &cells, 32, 1);
+ try vx.render(&out.writer);
+ sent[frame] = try out.toOwnedSlice();
+ }
+ // Against a cleared screen every cell goes. After the fade the letters
+ // go and the underlined blank; every plain blank is jumped.
+ try std.testing.expectEqual(@as(usize, 29), std.mem.count(u8, sent[0], " "));
+ try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, sent[1], " "));
+ try std.testing.expect(std.mem.indexOfScalar(u8, sent[1], 'b') != null);
+ try std.testing.expect(std.mem.indexOfScalar(u8, sent[1], 'c') != null);
+ try std.testing.expect(std.mem.indexOf(u8, sent[1], "90:90:90") != null);
+ try std.testing.expect(std.mem.indexOfScalar(u8, sent[1], 'a') != null);
+}
+
+/// T1 (§9.2): each notice chip casts a shadow one cell right and one down,
+/// inside its own pane's body: its ground 35% toward black in OKLab on a
+/// cell with text; on a blank one a half block (▌ on the right, ▀ below,
+/// ▘ at the corner) in the darker colour, so the shadow is half a cell
+/// thick and reads as one. Never the cursor's cell, a selection, a tag or
+/// another chip. Truecolor terminals only.
+fn chipShadows(arena: std.mem.Allocator, surface: *pardes.Surface, core: *pardes.Pardes, truecolor: bool) !*pardes.Surface {
+ if (!core.settings.chip_shadow or !truecolor) return surface;
+ const regions = surface.regionList();
+ const any = for (regions) |region| {
+ if (region.kind == .notice) break true;
+ } else false;
+ if (!any) return surface;
+ const out = try arena.create(pardes.Surface);
+ out.* = surface.*;
+ out.cells = try arena.dupe(pardes.Cell, surface.cells);
+ const theme = core.theme();
+ const page = theme.bg orelse pardes.colors.null_page;
+ for (regions) |chip| {
+ if (chip.kind != .notice or chip.rect.w == 0) continue;
+ const body = for (regions) |region| {
+ if (region.kind == .body and region.owner == chip.owner) break region.rect;
+ } else continue;
+ const right = chip.rect.x + chip.rect.w;
+ const below = chip.rect.y + chip.rect.h;
+ // The column right of it (from its second row), the row below (from
+ // its second column), and the corner.
+ var y = chip.rect.y;
+ while (y <= below) : (y += 1) {
+ var x = chip.rect.x;
+ while (x <= right) : (x += 1) {
+ const side = x == right and y > chip.rect.y and y < below;
+ const foot = y == below and x > chip.rect.x and x < right;
+ const corner = x == right and y == below;
+ if (!side and !foot and !corner) continue;
+ if (x < body.x or y < body.y or x >= body.x + body.w or y >= body.y + body.h or x >= out.cols or y >= out.rows) continue;
+ if (surface.cursor) |cu| if (cu.x == x and cu.y == y) continue;
+ const covered = for (regions) |region| {
+ if ((region.kind == .notice or region.kind == .tag or region.kind == .grip) and x >= region.rect.x and x < region.rect.x + region.rect.w and y >= region.rect.y and y < region.rect.y + region.rect.h) break true;
+ } else false;
+ if (covered) continue;
+ const cell = &out.cells[@as(usize, y) * out.cols + x];
+ const ground: [3]u8 = if (cell.default) page else switch (cell.style.bg) {
+ .rgb => |rgb| rgb,
+ else => page,
+ };
+ if (std.mem.eql(u8, &ground, &theme.sel_bg)) continue;
+ const dark = pardes.colors.mixOklab(ground, .{ 0, 0, 0 }, 0.35);
+ const blank = cell.default or cell.len == 0 or (cell.len == 1 and cell.text[0] == ' ');
+ if (blank) {
+ const glyph: []const u8 = if (corner) "▘" else if (side) "▌" else "▀";
+ cell.* = .{ .default = false, .style = .{ .fg = .{ .rgb = dark }, .bg = .{ .rgb = ground } } };
+ @memcpy(cell.text[0..glyph.len], glyph);
+ cell.len = @intCast(glyph.len);
+ } else {
+ cell.default = false;
+ cell.style.bg = .{ .rgb = dark };
+ }
+ }
+ }
+ }
+ return out;
+}
+
+/// T7 (§9.2): a pane whose view moved (Region.line) has its scroll thumb
+/// brighten, drawn most of the way to the text's colour, and fade back
+/// over 250 ms with an ease-out: where you are in the file, as you move.
+/// The rail is chrome, not a focus indicator. Truecolor terminals only.
+const ThumbFlash = struct {
+ lines: [pardes.MAX_PANES]i32 = @splat(std.math.minInt(i32)),
+ since: [pardes.MAX_PANES]u64 = @splat(0),
+
+ const life_ns: u64 = 250 * std.time.ns_per_ms;
+
+ fn apply(flash: *ThumbFlash, arena: std.mem.Allocator, surface: *pardes.Surface, core: *pardes.Pardes, truecolor: bool) !*pardes.Surface {
+ const on = core.settings.thumb_flash and truecolor and core.settings.motion != .off;
+ var out: ?*pardes.Surface = null;
+ const theme = core.theme();
+ const ink = theme.fg orelse .{ 0xcc, 0xcc, 0xcc };
+ for (surface.regionList()) |body| {
+ if (body.kind != .body or body.owner >= flash.lines.len) continue;
+ const id = body.owner;
+ if (flash.lines[id] != std.math.minInt(i32) and flash.lines[id] != body.line) flash.since[id] = core.now_ns;
+ flash.lines[id] = body.line;
+ const age = core.now_ns -| flash.since[id];
+ if (!on or flash.since[id] == 0 or age >= life_ns) continue;
+ const rail = for (surface.regionList()) |region| {
+ if (region.kind == .rail and region.owner == id) break region;
+ } else continue;
+ if (rail.thumb_h == 0) continue;
+ const t = @as(f32, @floatFromInt(age)) / @as(f32, @floatFromInt(life_ns));
+ const strength = 0.6 * (1 - t) * (1 - t);
+ if (out == null) {
+ const copy = try arena.create(pardes.Surface);
+ copy.* = surface.*;
+ copy.cells = try arena.dupe(pardes.Cell, surface.cells);
+ out = copy;
+ }
+ const o = out.?;
+ var y = rail.rect.y + rail.thumb_y;
+ while (y < rail.rect.y + rail.thumb_y + rail.thumb_h and y < o.rows) : (y += 1) {
+ var x = rail.rect.x;
+ while (x < rail.rect.x + rail.rect.w and x < o.cols) : (x += 1) {
+ const cell = &o.cells[@as(usize, y) * o.cols + x];
+ const ground: [3]u8 = switch (cell.style.bg) {
+ .rgb => |rgb| rgb,
+ else => continue,
+ };
+ if (!std.mem.eql(u8, &ground, &core.chromeTheme().scroll_thumb)) continue;
+ cell.style.bg = .{ .rgb = pardes.colors.mixOklab(ground, ink, strength) };
+ }
+ }
+ core.shell_continuous = true;
+ }
+ return out orelse surface;
+ }
+};
+
+/// Truecolor by COLORTERM (truecolor or 24bit), for a terminal that does
+/// not answer vaxis's query (§9.2: vaxis caps or COLORTERM).
+fn colortermTruecolor() bool {
+ const value = std.mem.span(std.c.getenv("COLORTERM") orelse return false);
+ return std.mem.eql(u8, value, "truecolor") or std.mem.eql(u8, value, "24bit");
+}
+
+/// T2 (docs/render-pipeline.md §9.2): the cursor jumping three cells or
+/// more leaves a trail of three to five cells along its path, just behind
+/// it, their ground drawn toward the text's colour, most beside the
+/// cursor, all fading out over 120 ms. Truecolor terminals only; a cell a
+/// frame changes, a few bytes. Never the cursor's own cell, a selection or
+/// anything outside the focused pane's body; off with Motion off.
+const JumpTrail = struct {
+ last: ?[2]u16 = null,
+ from: [2]u16 = .{ 0, 0 },
+ to: [2]u16 = .{ 0, 0 },
+ start_ns: u64 = 0,
+ active: bool = false,
+
+ const life_ns: u64 = 120 * std.time.ns_per_ms;
+
+ fn apply(trail: *JumpTrail, arena: std.mem.Allocator, surface: *pardes.Surface, core: *pardes.Pardes, truecolor: bool) !*pardes.Surface {
+ defer core.shell_continuous = trail.active or core.shell_continuous;
+ const on = core.settings.jump_trail and truecolor and core.settings.motion != .off;
+ const cursor = surface.cursor orelse {
+ trail.active = false;
+ return surface;
+ };
+ const here: [2]u16 = .{ cursor.x, cursor.y };
+ if (trail.last) |was| {
+ const dx = @as(i32, here[0]) - was[0];
+ const dy = @as(i32, here[1]) - was[1];
+ if (on and @max(@abs(dx), @abs(dy)) >= 3) {
+ trail.* = .{ .last = here, .from = was, .to = here, .start_ns = core.now_ns, .active = true };
+ }
+ }
+ trail.last = here;
+ if (!on or !trail.active) {
+ trail.active = false;
+ return surface;
+ }
+ const age = core.now_ns -| trail.start_ns;
+ if (age >= life_ns or !std.meta.eql(trail.to, here)) {
+ trail.active = false;
+ return surface;
+ }
+ const out = try arena.create(pardes.Surface);
+ out.* = surface.*;
+ out.cells = try arena.dupe(pardes.Cell, surface.cells);
+ const theme = core.theme();
+ const ink = theme.fg orelse .{ 0xcc, 0xcc, 0xcc };
+ const page = theme.bg orelse pardes.colors.null_page;
+ const body = for (surface.regionList()) |region| {
+ if (region.kind == .body and region.owner == core.active) break region.rect;
+ } else return out;
+ const t = @as(f32, @floatFromInt(age)) / @as(f32, @floatFromInt(life_ns));
+ const fade = (1 - t) * (1 - t);
+ const dx = @as(f32, @floatFromInt(@as(i32, trail.from[0]) - trail.to[0]));
+ const dy = @as(f32, @floatFromInt(@as(i32, trail.from[1]) - trail.to[1]));
+ const span = @max(@abs(dx), @abs(dy));
+ const n: usize = @intFromFloat(std.math.clamp(@round(span / 4), 3, 5));
+ var k: usize = 1;
+ var last_cell: ?[2]i32 = null;
+ var step: f32 = 1;
+ while (k <= n and step <= span) : (step += 1) {
+ const x: i32 = @intFromFloat(@round(@as(f32, @floatFromInt(trail.to[0])) + dx * step / span));
+ const y: i32 = @intFromFloat(@round(@as(f32, @floatFromInt(trail.to[1])) + dy * step / span));
+ if (last_cell) |seen| if (seen[0] == x and seen[1] == y) continue;
+ last_cell = .{ x, y };
+ defer k += 1;
+ if (x < body.x or y < body.y or x >= @as(i32, body.x) + body.w or y >= @as(i32, body.y) + body.h) continue;
+ const cell = &out.cells[@as(usize, @intCast(y)) * out.cols + @as(usize, @intCast(x))];
+ const ground: [3]u8 = if (cell.default) page else switch (cell.style.bg) {
+ .rgb => |rgb| rgb,
+ else => page,
+ };
+ if (std.mem.eql(u8, &ground, &theme.sel_bg)) continue;
+ const strength = 0.55 * fade * (1 - @as(f32, @floatFromInt(k - 1)) / @as(f32, @floatFromInt(n)));
+ if (strength < 0.02) continue;
+ const was_default = cell.default;
+ cell.default = false;
+ if (was_default) cell.style = .{};
+ cell.style.bg = .{ .rgb = pardes.colors.mixOklab(ground, ink, strength) };
+ }
+ return out;
+ }
+};
+
+fn paintCursor(win: vaxis.Window, x: u16, y: u16, bar: bool) void {
+ win.showCursor(x, y);
+ win.setCursorShape(if (bar) .beam else .default);
+}
+
+fn vaxisStyle(s: pardes.CellStyle) vaxis.Style {
+ return .{
+ .fg = vaxisColor(s.fg),
+ .bg = vaxisColor(s.bg),
+ .bold = s.bold,
+ .dim = s.dim,
+ .italic = s.italic,
+ .blink = s.blink,
+ .reverse = s.reverse,
+ .invisible = s.invisible,
+ .strikethrough = s.strikethrough,
+ .ul_style = switch (s.ul) {
+ .off => .off,
+ .single => .single,
+ .double => .double,
+ .curly => .curly,
+ .dotted => .dotted,
+ .dashed => .dashed,
+ },
+ };
+}
+
+fn vaxisColor(c: pardes.Color) vaxis.Color {
+ return switch (c) {
+ .default => .default,
+ .index => |i| .{ .index = i },
+ .rgb => |rgb| .{ .rgb = rgb },
+ };
+}
+
+test "a jump leaves a trail of a few cells behind the cursor that fades in 120 ms" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([20][20]u8, @splat("some text on a line\n".*))));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme forge"));
+ core.settings.jump_trail = true;
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const s = try core.render(arena.allocator());
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region.rect;
+ } else return error.NoBody;
+ var trail: JumpTrail = .{};
+ core.now_ns = std.time.ns_per_s;
+ s.cursor = .{ .x = body.x + 2, .y = body.y + 1 };
+ _ = try trail.apply(arena.allocator(), s, core, true);
+ // Ten cells right: a trail back toward where it was.
+ s.cursor = .{ .x = body.x + 12, .y = body.y + 1 };
+ core.now_ns += 16 * std.time.ns_per_ms;
+ const lit = try trail.apply(arena.allocator(), s, core, true);
+ try std.testing.expect(trail.active and core.shell_continuous);
+ var changed: usize = 0;
+ for (lit.cells, s.cells, 0..) |a, b, i| {
+ if (std.meta.eql(a.style.bg, b.style.bg)) continue;
+ changed += 1;
+ // On the cursor's row, behind it, never its own cell.
+ try std.testing.expectEqual(@as(usize, body.y + 1), i / s.cols);
+ try std.testing.expect(i % s.cols < body.x + 12 and i % s.cols > body.x + 2);
+ }
+ try std.testing.expect(changed >= 3 and changed <= 5);
+ // Gone by 120 ms; a step of a cell leaves none; nor a terminal without
+ // truecolor.
+ core.now_ns += 130 * std.time.ns_per_ms;
+ core.shell_continuous = false;
+ const faded = try trail.apply(arena.allocator(), s, core, true);
+ try std.testing.expect(faded == s and !trail.active and !core.shell_continuous);
+ s.cursor = .{ .x = body.x + 13, .y = body.y + 1 };
+ try std.testing.expect(try trail.apply(arena.allocator(), s, core, true) == s);
+ s.cursor = .{ .x = body.x + 2, .y = body.y + 1 };
+ try std.testing.expect(try trail.apply(arena.allocator(), s, core, false) == s);
+}
+
+test "a notice chip casts a cell's shadow right and down, inside its body, off the cursor" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([20][20]u8, @splat("some text on a line\n".*))));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme forge"));
+ core.settings.chip_shadow = true;
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a notice"));
+ for (0..60) |_| core.update(.tick);
+ core.sync();
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const s = try core.render(arena.allocator());
+ const chip = for (s.regionList()) |region| {
+ if (region.kind == .notice) break region.rect;
+ } else return error.NoNotice;
+ s.cursor = null;
+ const out = try chipShadows(arena.allocator(), s, core, true);
+ try std.testing.expect(out != s);
+ var changed: usize = 0;
+ for (out.cells, s.cells, 0..) |a, b, i| {
+ if (std.meta.eql(a, b)) continue;
+ changed += 1;
+ const x = i % s.cols;
+ const y = i / s.cols;
+ // Right of the chip or below it, never inside it.
+ try std.testing.expect(x == chip.x + chip.w or y == chip.y + chip.h);
+ try std.testing.expect(!(x >= chip.x and x < chip.x + chip.w and y >= chip.y and y < chip.y + chip.h));
+ }
+ try std.testing.expect(changed >= chip.w - 1);
+ // Off, or without truecolor: the frame as it was.
+ try std.testing.expect(try chipShadows(arena.allocator(), s, core, false) == s);
+ core.settings.chip_shadow = false;
+ try std.testing.expect(try chipShadows(arena.allocator(), s, core, true) == s);
+}
+
+test "a scrolled pane's thumb brightens and fades back in 250 ms" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([200][20]u8, @splat("some text on a line\n".*))));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme forge"));
+ core.settings.thumb_flash = true;
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ var flash: ThumbFlash = .{};
+ core.now_ns = std.time.ns_per_s;
+ const first = try core.render(arena.allocator());
+ try std.testing.expect(try flash.apply(arena.allocator(), first, core, true) == first);
+ pane.scrollBy(20);
+ core.now_ns += 16 * std.time.ns_per_ms;
+ const moved = try core.render(arena.allocator());
+ const lit = try flash.apply(arena.allocator(), moved, core, true);
+ try std.testing.expect(lit != moved and core.shell_continuous);
+ var brighter: usize = 0;
+ for (lit.cells, moved.cells) |a, b| {
+ if (!std.meta.eql(a.style.bg, b.style.bg)) brighter += 1;
+ }
+ try std.testing.expect(brighter >= 1);
+ core.now_ns += 300 * std.time.ns_per_ms;
+ core.shell_continuous = false;
+ const later = try core.render(arena.allocator());
+ try std.testing.expect(try flash.apply(arena.allocator(), later, core, true) == later);
+ try std.testing.expect(!core.shell_continuous);
+}