wip: macos

Fixes #49.

If a user has passed an initial working directory, set that as the
set that as the terminal's working directory when we spawn the widget.

README.md

@@ -32,6 +32,7 @@ Unix-likes.
 | Synchronized Output (DEC 2026) |     ✅     |
 | Unicode Core (DEC 2027)        |     ✅     |
 | Color Mode Updates (DEC 2031)  |     ✅     |
+| [In-Band Resize Reports](https://gist.github.com/rockorager/e695fb2924d36b2bcf1fff4a3704bd83)   |     ✅     |
 | Images (kitty)                 |     ✅     |
 
 ## Usage

build.zig.zon

@@ -23,8 +23,8 @@
             .lazy = true,
         },
         .aio = .{
-            .url = "git+https://github.com/Cloudef/zig-aio#be8e2b374bf223202090e282447fa4581029c2eb",
+            .url = "git+https://github.com/Cloudef/zig-aio#407bb416136b61087cec2c561fa4b4103a44c5b1",
-            .hash = "122012a11b37a350395a32fdb514e57ff54a0f9d8d4ce09498b6c45ffb7211232920",
+            .hash = "12202405ca6dd40f314dba6472983fcbb388118ab7446d75065b1efb982d03f515d2",
             .lazy = true,
         },
     },

examples/aio.zig

@@ -41,7 +41,7 @@ fn audioTask(allocator: std.mem.Allocator) !void {
 
     const sound = blk: {
         var tpool: coro.ThreadPool = .{};
-        try tpool.start(allocator, 1);
+        try tpool.start(allocator, .{});
         defer tpool.deinit();
         break :blk try tpool.yieldForCompletition(downloadTask, .{ allocator, "https://keroserene.net/lol/roll.s16" });
     };

examples/table.zig

@@ -25,6 +25,7 @@ pub fn main() !void {
     defer user_list.deinit();
 
     var tty = try vaxis.Tty.init();
+    defer tty.deinit();
 
     var vx = try vaxis.init(alloc, .{});
     defer vx.deinit(alloc, tty.anyWriter());

examples/vaxis.zig

@@ -21,6 +21,8 @@ pub fn main() !void {
     const alloc = gpa.allocator();
 
     var tty = try vaxis.Tty.init();
+    defer tty.deinit();
+
     var vx = try vaxis.init(alloc, .{});
     defer vx.deinit(alloc, tty.anyWriter());
 

examples/vt.zig

@@ -49,6 +49,7 @@ pub fn main() !void {
     };
     const shell = env.get("SHELL") orelse "bash";
     const argv = [_][]const u8{shell};
+    std.debug.print("executing: {s}\n", .{shell});
     var vt = try vaxis.widgets.Terminal.init(
         alloc,
         &argv,
@@ -61,9 +62,10 @@ pub fn main() !void {
 
     var redraw: bool = false;
     while (true) {
-        std.time.sleep(8 * std.time.ns_per_ms);
+        std.debug.print("inside while loop before resize\n", .{});
         // try vt events first
         while (vt.tryEvent()) |event| {
+            std.debug.print("inside stryEventloop \n", .{});
             redraw = true;
             switch (event) {
                 .bell => {},
@@ -74,6 +76,7 @@ pub fn main() !void {
             }
         }
         while (loop.tryEvent()) |event| {
+            std.debug.print("inside loop.tryEvent\n", .{});
             redraw = true;
             switch (event) {
                 .key_press => |key| {

src/Cell.zig

@@ -6,6 +6,9 @@ style: Style = .{},
 link: Hyperlink = .{},
 image: ?Image.Placement = null,
 default: bool = false,
+/// Set to true if this cell is the last cell printed in a row before wrap. Vaxis will determine if
+/// it should rely on the terminal's autowrap feature which can help with primary screen resizes
+wrapped: bool = false,
 
 /// Segment is a contiguous run of text that has a constant style
 pub const Segment = struct {

src/Image.zig

@@ -6,8 +6,6 @@ const zigimg = @import("zigimg");
 
 const Window = @import("Window.zig");
 
-const log = std.log.scoped(.image);
-
 const Image = @This();
 
 const transmit_opener = "\x1b_Gf=32,i={d},s={d},v={d},m={d};";

src/InternalScreen.zig

@@ -5,7 +5,7 @@ const Cell = @import("Cell.zig");
 const MouseShape = @import("Mouse.zig").Shape;
 const CursorShape = Cell.CursorShape;
 
-const log = std.log.scoped(.internal_screen);
+const log = std.log.scoped(.vaxis);
 
 const InternalScreen = @This();
 

src/Loop.zig

@@ -6,17 +6,18 @@ const grapheme = @import("grapheme");
 const GraphemeCache = @import("GraphemeCache.zig");
 const Parser = @import("Parser.zig");
 const Queue = @import("queue.zig").Queue;
-const Tty = @import("main.zig").Tty;
+const vaxis = @import("main.zig");
+const Tty = vaxis.Tty;
 const Vaxis = @import("Vaxis.zig");
 
+const log = std.log.scoped(.vaxis);
+
 pub fn Loop(comptime T: type) type {
     return struct {
         const Self = @This();
 
         const Event = T;
 
-        const log = std.log.scoped(.loop);
-
         tty: *Tty,
         vaxis: *Vaxis,
 
@@ -51,6 +52,8 @@ pub fn Loop(comptime T: type) type {
 
         /// stops reading from the tty.
         pub fn stop(self: *Self) void {
+            // If we don't have a thread, we have nothing to stop
+            if (self.thread == null) return;
             self.should_quit = true;
             // trigger a read
             self.vaxis.deviceStatusReport(self.tty.anyWriter()) catch {};
@@ -90,6 +93,8 @@ pub fn Loop(comptime T: type) type {
 
         pub fn winsizeCallback(ptr: *anyopaque) void {
             const self: *Self = @ptrCast(@alignCast(ptr));
+            // We will be receiving winsize updates in-band
+            if (self.vaxis.state.in_band_resize) return;
 
             const winsize = Tty.getWinsize(self.tty.fd) catch return;
             if (@hasField(Event, "winsize")) {
@@ -108,40 +113,12 @@ pub fn Loop(comptime T: type) type {
 
             switch (builtin.os.tag) {
                 .windows => {
+                    var parser: Parser = .{
+                        .grapheme_data = grapheme_data,
+                    };
                     while (!self.should_quit) {
-                        const event = try self.tty.nextEvent();
+                        const event = try self.tty.nextEvent(&parser, paste_allocator);
-                        switch (event) {
+                        try handleEventGeneric(self, self.vaxis, &cache, Event, event, null);
-                            .winsize => |ws| {
-                                if (@hasField(Event, "winsize")) {
-                                    self.postEvent(.{ .winsize = ws });
-                                }
-                            },
-                            .key_press => |key| {
-                                if (@hasField(Event, "key_press")) {
-                                    // HACK: yuck. there has to be a better way
-                                    var mut_key = key;
-                                    if (key.text) |text| {
-                                        mut_key.text = cache.put(text);
-                                    }
-                                    self.postEvent(.{ .key_press = mut_key });
-                                }
-                            },
-                            .key_release => |*key| {
-                                if (@hasField(Event, "key_release")) {
-                                    // HACK: yuck. there has to be a better way
-                                    var mut_key = key;
-                                    if (key.text) |text| {
-                                        mut_key.text = cache.put(text);
-                                    }
-                                    self.postEvent(.{ .key_release = mut_key });
-                                }
-                            },
-                            .cap_da1 => {
-                                std.Thread.Futex.wake(&self.vaxis.query_futex, 10);
-                            },
-                            .mouse => {}, // Unsupported currently
-                            else => {},
-                        }
                     }
                 },
                 else => {
@@ -178,7 +155,24 @@ pub fn Loop(comptime T: type) type {
                             seq_start += result.n;
 
                             const event = result.event orelse continue;
+                            try handleEventGeneric(self, self.vaxis, &cache, Event, event, paste_allocator);
+                        }
+                    }
+                },
+            }
+        }
+    };
+}
+
+pub fn handleEventGeneric(self: anytype, vx: *Vaxis, cache: *GraphemeCache, Event: type, event: anytype, paste_allocator: ?std.mem.Allocator) !void {
+    switch (builtin.os.tag) {
+        .windows => {
             switch (event) {
+                .winsize => |ws| {
+                    if (@hasField(Event, "winsize")) {
+                        return self.postEvent(.{ .winsize = ws });
+                    }
+                },
                 .key_press => |key| {
                     if (@hasField(Event, "key_press")) {
                         // HACK: yuck. there has to be a better way
@@ -186,7 +180,7 @@ pub fn Loop(comptime T: type) type {
                         if (key.text) |text| {
                             mut_key.text = cache.put(text);
                         }
-                                        self.postEvent(.{ .key_press = mut_key });
+                        return self.postEvent(.{ .key_press = mut_key });
                     }
                 },
                 .key_release => |*key| {
@@ -196,37 +190,66 @@ pub fn Loop(comptime T: type) type {
                         if (key.text) |text| {
                             mut_key.text = cache.put(text);
                         }
-                                        self.postEvent(.{ .key_release = mut_key });
+                        return self.postEvent(.{ .key_release = mut_key });
+                    }
+                },
+                .cap_da1 => {
+                    std.Thread.Futex.wake(&vx.query_futex, 10);
+                },
+                .mouse => {}, // Unsupported currently
+                else => {},
+            }
+        },
+        else => {
+            switch (event) {
+                .key_press => |key| {
+                    if (@hasField(Event, "key_press")) {
+                        // HACK: yuck. there has to be a better way
+                        var mut_key = key;
+                        if (key.text) |text| {
+                            mut_key.text = cache.put(text);
+                        }
+                        return self.postEvent(.{ .key_press = mut_key });
+                    }
+                },
+                .key_release => |*key| {
+                    if (@hasField(Event, "key_release")) {
+                        // HACK: yuck. there has to be a better way
+                        var mut_key = key;
+                        if (key.text) |text| {
+                            mut_key.text = cache.put(text);
+                        }
+                        return self.postEvent(.{ .key_release = mut_key });
                     }
                 },
                 .mouse => |mouse| {
                     if (@hasField(Event, "mouse")) {
-                                        self.postEvent(.{ .mouse = self.vaxis.translateMouse(mouse) });
+                        return self.postEvent(.{ .mouse = vx.translateMouse(mouse) });
                     }
                 },
                 .focus_in => {
                     if (@hasField(Event, "focus_in")) {
-                                        self.postEvent(.focus_in);
+                        return self.postEvent(.focus_in);
                     }
                 },
                 .focus_out => {
                     if (@hasField(Event, "focus_out")) {
-                                        self.postEvent(.focus_out);
+                        return self.postEvent(.focus_out);
                     }
                 },
                 .paste_start => {
                     if (@hasField(Event, "paste_start")) {
-                                        self.postEvent(.paste_start);
+                        return self.postEvent(.paste_start);
                     }
                 },
                 .paste_end => {
                     if (@hasField(Event, "paste_end")) {
-                                        self.postEvent(.paste_end);
+                        return self.postEvent(.paste_end);
                     }
                 },
                 .paste => |text| {
                     if (@hasField(Event, "paste")) {
-                                        self.postEvent(.{ .paste = text });
+                        return self.postEvent(.{ .paste = text });
                     } else {
                         if (paste_allocator) |_|
                             paste_allocator.?.free(text);
@@ -234,50 +257,51 @@ pub fn Loop(comptime T: type) type {
                 },
                 .color_report => |report| {
                     if (@hasField(Event, "color_report")) {
-                                        self.postEvent(.{ .color_report = report });
+                        return self.postEvent(.{ .color_report = report });
                     }
                 },
                 .color_scheme => |scheme| {
                     if (@hasField(Event, "color_scheme")) {
-                                        self.postEvent(.{ .color_scheme = scheme });
+                        return self.postEvent(.{ .color_scheme = scheme });
                     }
                 },
                 .cap_kitty_keyboard => {
                     log.info("kitty keyboard capability detected", .{});
-                                    self.vaxis.caps.kitty_keyboard = true;
+                    vx.caps.kitty_keyboard = true;
                 },
                 .cap_kitty_graphics => {
-                                    if (!self.vaxis.caps.kitty_graphics) {
+                    if (!vx.caps.kitty_graphics) {
                         log.info("kitty graphics capability detected", .{});
-                                        self.vaxis.caps.kitty_graphics = true;
+                        vx.caps.kitty_graphics = true;
                     }
                 },
                 .cap_rgb => {
                     log.info("rgb capability detected", .{});
-                                    self.vaxis.caps.rgb = true;
+                    vx.caps.rgb = true;
                 },
                 .cap_unicode => {
                     log.info("unicode capability detected", .{});
-                                    self.vaxis.caps.unicode = .unicode;
+                    vx.caps.unicode = .unicode;
-                                    self.vaxis.screen.width_method = .unicode;
+                    vx.screen.width_method = .unicode;
                 },
                 .cap_sgr_pixels => {
                     log.info("pixel mouse capability detected", .{});
-                                    self.vaxis.caps.sgr_pixels = true;
+                    vx.caps.sgr_pixels = true;
                 },
                 .cap_color_scheme_updates => {
                     log.info("color_scheme_updates capability detected", .{});
-                                    self.vaxis.caps.color_scheme_updates = true;
+                    vx.caps.color_scheme_updates = true;
                 },
                 .cap_da1 => {
-                                    std.Thread.Futex.wake(&self.vaxis.query_futex, 10);
+                    std.Thread.Futex.wake(&vx.query_futex, 10);
                 },
-                                .winsize => unreachable, // handled elsewhere for posix
+                .winsize => |winsize| {
-                            }
+                    vx.state.in_band_resize = true;
-                        }
+                    if (@hasField(Event, "winsize")) {
+                        self.postEvent(.{ .winsize = winsize });
                     }
                 },
             }
+        },
     }
-    };
 }

src/Parser.zig

@@ -6,8 +6,9 @@ const Key = @import("Key.zig");
 const Mouse = @import("Mouse.zig");
 const code_point = @import("code_point");
 const grapheme = @import("grapheme");
+const Winsize = @import("main.zig").Winsize;
 
-const log = std.log.scoped(.parser);
+const log = std.log.scoped(.vaxis_parser);
 
 const Parser = @This();
 
@@ -138,8 +139,17 @@ inline fn parseGround(input: []const u8, data: *const grapheme.GraphemeData) !Re
 }
 
 inline fn parseSs3(input: []const u8) Result {
-    std.debug.assert(input.len >= 3);
+    if (input.len < 3) {
+        return .{
+            .event = null,
+            .n = 0,
+        };
+    }
     const key: Key = switch (input[2]) {
+        0x1B => return .{
+            .event = null,
+            .n = 2,
+        },
         'A' => .{ .codepoint = Key.up },
         'B' => .{ .codepoint = Key.down },
         'C' => .{ .codepoint = Key.right },
@@ -166,7 +176,12 @@ inline fn parseSs3(input: []const u8) Result {
 }
 
 inline fn parseApc(input: []const u8) Result {
-    std.debug.assert(input.len >= 3);
+    if (input.len < 3) {
+        return .{
+            .event = null,
+            .n = 0,
+        };
+    }
     const end = std.mem.indexOfScalarPos(u8, input, 2, 0x1b) orelse return .{
         .event = null,
         .n = 0,
@@ -187,11 +202,22 @@ inline fn parseApc(input: []const u8) Result {
 
 /// Skips sequences until we see an ST (String Terminator, ESC \)
 inline fn skipUntilST(input: []const u8) Result {
-    std.debug.assert(input.len >= 3);
+    if (input.len < 3) {
+        return .{
+            .event = null,
+            .n = 0,
+        };
+    }
     const end = std.mem.indexOfScalarPos(u8, input, 2, 0x1b) orelse return .{
         .event = null,
         .n = 0,
     };
+    if (input.len < end + 1 + 1) {
+        return .{
+            .event = null,
+            .n = 0,
+        };
+    }
     const sequence = input[0 .. end + 1 + 1];
     return .{
         .event = null,
@@ -201,6 +227,12 @@ inline fn skipUntilST(input: []const u8) Result {
 
 /// Parses an OSC sequence
 inline fn parseOsc(input: []const u8, paste_allocator: ?std.mem.Allocator) !Result {
+    if (input.len < 3) {
+        return .{
+            .event = null,
+            .n = 0,
+        };
+    }
     var bel_terminated: bool = false;
     // end is the index of the terminating byte(s) (either the last byte of an
     // ST or BEL)
@@ -288,7 +320,13 @@ inline fn parseOsc(input: []const u8, paste_allocator: ?std.mem.Allocator) !Resu
 }
 
 inline fn parseCsi(input: []const u8, text_buf: []u8) Result {
-    // We start iterating at index 2 to get past te '['
+    if (input.len < 3) {
+        return .{
+            .event = null,
+            .n = 0,
+        };
+    }
+    // We start iterating at index 2 to get past the '['
     const sequence = for (input[2..], 2..) |b, i| {
         switch (b) {
             0x40...0xFF => break input[0 .. i + 1],
@@ -470,6 +508,32 @@ inline fn parseCsi(input: []const u8, text_buf: []u8) Result {
                 else => return null_event,
             }
         },
+        't' => {
+            // XTWINOPS
+            // Split first into fields delimited by ';'
+            var iter = std.mem.splitScalar(u8, sequence[2 .. sequence.len - 1], ';');
+            const ps = iter.first();
+            if (std.mem.eql(u8, "48", ps)) {
+                // in band window resize
+                // CSI 48 ; height ; width ; height_pix ; width_pix t
+                const height_char = iter.next() orelse return null_event;
+                const width_char = iter.next() orelse return null_event;
+                const height_pix = iter.next() orelse "0";
+                const width_pix = iter.next() orelse "0";
+
+                const winsize: Winsize = .{
+                    .rows = std.fmt.parseUnsigned(usize, height_char, 10) catch return null_event,
+                    .cols = std.fmt.parseUnsigned(usize, width_char, 10) catch return null_event,
+                    .x_pixel = std.fmt.parseUnsigned(usize, width_pix, 10) catch return null_event,
+                    .y_pixel = std.fmt.parseUnsigned(usize, height_pix, 10) catch return null_event,
+                };
+                return .{
+                    .event = .{ .winsize = winsize },
+                    .n = sequence.len,
+                };
+            }
+            return null_event;
+        },
         'u' => {
             // Kitty keyboard
             // CSI unicode-key-code:alternate-key-codes ; modifiers:event-type ; text-as-codepoints u

src/Screen.zig

@@ -8,8 +8,6 @@ const Winsize = @import("main.zig").Winsize;
 const Unicode = @import("Unicode.zig");
 const Method = @import("gwidth.zig").Method;
 
-const log = std.log.scoped(.screen);
-
 const Screen = @This();
 
 width: usize = 0,

src/Vaxis.zig

@@ -68,7 +68,7 @@ unicode: Unicode,
 
 // statistics
 renders: usize = 0,
-render_dur: i128 = 0,
+render_dur: u64 = 0,
 render_timer: std.time.Timer,
 
 sgr: enum {
@@ -85,6 +85,7 @@ state: struct {
     mouse: bool = false,
     pixel_mouse: bool = false,
     color_scheme_updates: bool = false,
+    in_band_resize: bool = false,
     cursor: struct {
         row: usize = 0,
         col: usize = 0,
@@ -151,6 +152,10 @@ pub fn resetState(self: *Vaxis, tty: AnyWriter) !void {
         try tty.writeAll(ctlseqs.color_scheme_reset);
         self.state.color_scheme_updates = false;
     }
+    if (self.state.in_band_resize) {
+        try tty.writeAll(ctlseqs.in_band_resize_reset);
+        self.state.in_band_resize = false;
+    }
 }
 
 /// resize allocates a slice of cells equal to the number of cells
@@ -244,6 +249,7 @@ pub fn queryTerminalSend(_: Vaxis, tty: AnyWriter) !void {
     try tty.writeAll(ctlseqs.decrqm_sgr_pixels ++
         ctlseqs.decrqm_unicode ++
         ctlseqs.decrqm_color_scheme ++
+        ctlseqs.in_band_resize_set ++
         ctlseqs.xtversion ++
         ctlseqs.csi_u_query ++
         ctlseqs.kitty_graphics_query ++
@@ -360,6 +366,8 @@ pub fn render(self: *Vaxis, tty: AnyWriter) !void {
         if (col >= self.screen.width) {
             row += 1;
             col = 0;
+            // Rely on terminal wrapping to reposition into next row instead of forcing it
+            if (!cell.wrapped)
                 reposition = true;
         }
         // If cell is the same as our last frame, we don't need to do
@@ -488,7 +496,7 @@ pub fn render(self: *Vaxis, tty: AnyWriter) !void {
         }
         // underline color
         if (!Cell.Color.eql(cursor.ul, cell.style.ul)) {
-            switch (cell.style.bg) {
+            switch (cell.style.ul) {
                 .default => try tty.writeAll(ctlseqs.ul_reset),
                 .index => |idx| {
                     switch (self.sgr) {

src/Window.zig

@@ -7,8 +7,6 @@ const Segment = @import("Cell.zig").Segment;
 const Unicode = @import("Unicode.zig");
 const gw = @import("gwidth.zig");
 
-const log = std.log.scoped(.window);
-
 const Window = @This();
 
 pub const Size = union(enum) {
@@ -311,6 +309,7 @@ pub fn print(self: Window, segments: []const Segment, opts: PrintOptions) !Print
                         },
                         .style = segment.style,
                         .link = segment.link,
+                        .wrapped = col + w >= self.width,
                     });
                     col += w;
                 }

src/aio.zig

@@ -3,14 +3,9 @@ const std = @import("std");
 const aio = @import("aio");
 const coro = @import("coro");
 const vaxis = @import("main.zig");
+const handleEventGeneric = @import("Loop.zig").handleEventGeneric;
 const log = std.log.scoped(.vaxis_aio);
 
-comptime {
-    if (builtin.target.os.tag == .windows) {
-        @compileError("Windows is not supported right now");
-    }
-}
-
 const Yield = enum { no_state, took_event };
 
 /// zig-aio based event loop
@@ -52,10 +47,12 @@ pub fn Loop(comptime T: type) type {
 
             // keep on stack
             var ctx: Context = .{ .loop = self, .tty = tty };
+            if (builtin.target.os.tag != .windows) {
                 if (@hasField(Event, "winsize")) {
                     const handler: vaxis.Tty.SignalHandler = .{ .context = &ctx, .callback = Context.cb };
                     try vaxis.Tty.notifyWinsize(handler);
                 }
+            }
 
             while (true) {
                 try coro.io.single(aio.WaitEventSource{ .source = &self.source });
@@ -74,7 +71,32 @@ pub fn Loop(comptime T: type) type {
             };
         }
 
-        fn ttyReaderInner(self: *@This(), vx: *vaxis.Vaxis, tty: *vaxis.Tty, paste_allocator: ?std.mem.Allocator) !void {
+        fn windowsReadEvent(tty: *vaxis.Tty) !vaxis.Event {
+            var state: vaxis.Tty.EventState = .{};
+            while (true) {
+                var bytes_read: usize = 0;
+                var input_record: vaxis.Tty.INPUT_RECORD = undefined;
+                try coro.io.single(aio.ReadTty{
+                    .tty = .{ .handle = tty.stdin },
+                    .buffer = std.mem.asBytes(&input_record),
+                    .out_read = &bytes_read,
+                });
+
+                if (try tty.eventFromRecord(&input_record, &state)) |ev| {
+                    return ev;
+                }
+            }
+        }
+
+        fn ttyReaderWindows(self: *@This(), vx: *vaxis.Vaxis, tty: *vaxis.Tty) !void {
+            var cache: vaxis.GraphemeCache = .{};
+            while (true) {
+                const event = try windowsReadEvent(tty);
+                try handleEventGeneric(self, vx, &cache, Event, event, null);
+            }
+        }
+
+        fn ttyReaderPosix(self: *@This(), vx: *vaxis.Vaxis, tty: *vaxis.Tty, paste_allocator: ?std.mem.Allocator) !void {
             // initialize a grapheme cache
             var cache: vaxis.GraphemeCache = .{};
 
@@ -93,7 +115,7 @@ pub fn Loop(comptime T: type) type {
                 var buf: [4096]u8 = undefined;
                 var n: usize = undefined;
                 var read_start: usize = 0;
-                try coro.io.single(aio.Read{ .file = file, .buffer = buf[read_start..], .out_read = &n });
+                try coro.io.single(aio.ReadTty{ .tty = file, .buffer = buf[read_start..], .out_read = &n });
                 var seq_start: usize = 0;
                 while (seq_start < n) {
                     const result = try parser.parse(buf[seq_start..n], paste_allocator);
@@ -111,108 +133,16 @@ pub fn Loop(comptime T: type) type {
                     seq_start += result.n;
 
                     const event = result.event orelse continue;
-                    switch (event) {
+                    try handleEventGeneric(self, vx, &cache, Event, event, paste_allocator);
-                        .key_press => |key| {
-                            if (@hasField(Event, "key_press")) {
-                                // HACK: yuck. there has to be a better way
-                                var mut_key = key;
-                                if (key.text) |text| {
-                                    mut_key.text = cache.put(text);
-                                }
-                                try self.postEvent(.{ .key_press = mut_key });
-                            }
-                        },
-                        .key_release => |*key| {
-                            if (@hasField(Event, "key_release")) {
-                                // HACK: yuck. there has to be a better way
-                                var mut_key = key;
-                                if (key.text) |text| {
-                                    mut_key.text = cache.put(text);
-                                }
-                                try self.postEvent(.{ .key_release = mut_key });
-                            }
-                        },
-                        .mouse => |mouse| {
-                            if (@hasField(Event, "mouse")) {
-                                try self.postEvent(.{ .mouse = vx.translateMouse(mouse) });
-                            }
-                        },
-                        .focus_in => {
-                            if (@hasField(Event, "focus_in")) {
-                                try self.postEvent(.focus_in);
-                            }
-                        },
-                        .focus_out => {
-                            if (@hasField(Event, "focus_out")) {
-                                try self.postEvent(.focus_out);
-                            }
-                        },
-                        .paste_start => {
-                            if (@hasField(Event, "paste_start")) {
-                                try self.postEvent(.paste_start);
-                            }
-                        },
-                        .paste_end => {
-                            if (@hasField(Event, "paste_end")) {
-                                try self.postEvent(.paste_end);
-                            }
-                        },
-                        .paste => |text| {
-                            if (@hasField(Event, "paste")) {
-                                try self.postEvent(.{ .paste = text });
-                            } else {
-                                if (paste_allocator) |_|
-                                    paste_allocator.?.free(text);
-                            }
-                        },
-                        .color_report => |report| {
-                            if (@hasField(Event, "color_report")) {
-                                try self.postEvent(.{ .color_report = report });
-                            }
-                        },
-                        .color_scheme => |scheme| {
-                            if (@hasField(Event, "color_scheme")) {
-                                try self.postEvent(.{ .color_scheme = scheme });
-                            }
-                        },
-                        .cap_kitty_keyboard => {
-                            log.info("kitty keyboard capability detected", .{});
-                            vx.caps.kitty_keyboard = true;
-                        },
-                        .cap_kitty_graphics => {
-                            if (!vx.caps.kitty_graphics) {
-                                log.info("kitty graphics capability detected", .{});
-                                vx.caps.kitty_graphics = true;
-                            }
-                        },
-                        .cap_rgb => {
-                            log.info("rgb capability detected", .{});
-                            vx.caps.rgb = true;
-                        },
-                        .cap_unicode => {
-                            log.info("unicode capability detected", .{});
-                            vx.caps.unicode = .unicode;
-                            vx.screen.width_method = .unicode;
-                        },
-                        .cap_sgr_pixels => {
-                            log.info("pixel mouse capability detected", .{});
-                            vx.caps.sgr_pixels = true;
-                        },
-                        .cap_color_scheme_updates => {
-                            log.info("color_scheme_updates capability detected", .{});
-                            vx.caps.color_scheme_updates = true;
-                        },
-                        .cap_da1 => {
-                            std.Thread.Futex.wake(&vx.query_futex, 10);
-                        },
-                        .winsize => unreachable, // handled elsewhere for posix
-                    }
                 }
             }
         }
 
         fn ttyReaderTask(self: *@This(), vx: *vaxis.Vaxis, tty: *vaxis.Tty, paste_allocator: ?std.mem.Allocator) void {
-            self.ttyReaderInner(vx, tty, paste_allocator) catch |err| {
+            return switch (builtin.target.os.tag) {
+                .windows => self.ttyReaderWindows(vx, tty),
+                else => self.ttyReaderPosix(vx, tty, paste_allocator),
+            } catch |err| {
                 if (err != error.Canceled) log.err("ttyReader: {}", .{err});
                 self.fatal = true;
             };

src/ctlseqs.zig

@@ -20,6 +20,10 @@ pub const mouse_set = "\x1b[?1002;1003;1004;1006h";
 pub const mouse_set_pixels = "\x1b[?1002;1003;1004;1016h";
 pub const mouse_reset = "\x1b[?1002;1003;1004;1006;1016l";
 
+// in-band window size reports
+pub const in_band_resize_set = "\x1b[?2048h";
+pub const in_band_resize_reset = "\x1b[?2048l";
+
 // sync
 pub const sync_set = "\x1b[?2026h";
 pub const sync_reset = "\x1b[?2026l";

src/main.zig

@@ -64,6 +64,10 @@ pub fn panic_handler(msg: []const u8, error_return_trace: ?*std.builtin.StackTra
     std.builtin.default_panic(msg, error_return_trace, ret_addr);
 }
 
+pub const log_scopes = enum {
+    vaxis,
+};
+
 /// the vaxis logo. In PixelCode
 pub const logo =
     \\▄   ▄  ▄▄▄  ▄   ▄ ▄▄▄  ▄▄▄

src/queue.zig

@@ -3,8 +3,6 @@ const assert = std.debug.assert;
 const atomic = std.atomic;
 const Condition = std.Thread.Condition;
 
-const log = std.log.scoped(.queue);
-
 /// Thread safe. Fixed size. Blocking push and pop.
 pub fn Queue(
     comptime T: type,

src/widgets/TextInput.zig

@@ -6,8 +6,6 @@ const Window = @import("../Window.zig");
 const GapBuffer = @import("gap_buffer").GapBuffer;
 const Unicode = @import("../Unicode.zig");
 
-const log = std.log.scoped(.text_input);
-
 const TextInput = @This();
 
 /// The events that this widget handles

src/widgets/terminal/Command.zig

@@ -17,6 +17,23 @@ pid: ?std.posix.pid_t = null,
 env_map: *const std.process.EnvMap,
 
 pty: Pty,
+const TIOCSCTTY = if (builtin.os.tag == .macos) 536900705 else c.TIOCSCTTY;
+const TIOCSWINSZ = if (builtin.os.tag == .macos) 2148037735 else c.TIOCSWINSZ;
+const TIOCGWINSZ = if (builtin.os.tag == .macos) 1074295912 else c.TIOCGWINSZ;
+// extern "c" fn setsid() std.c.pid_t;
+const c = struct {
+    usingnamespace switch (builtin.os.tag) {
+        .macos => @cImport({
+            @cInclude("sys/ioctl.h"); // ioctl and constants
+            @cInclude("util.h");
+            @cInclude("unistd.h"); // openpty()
+        }),
+        else => @cImport({
+            @cInclude("sys/ioctl.h"); // ioctl and constants
+            @cInclude("pty.h");
+        }),
+    };
+};
 
 pub fn spawn(self: *Command, allocator: std.mem.Allocator) !void {
     var arena_allocator = std.heap.ArenaAllocator.init(allocator);
@@ -31,12 +48,26 @@ pub fn spawn(self: *Command, allocator: std.mem.Allocator) !void {
 
     const pid = try std.posix.fork();
     if (pid == 0) {
-        // we are the child
+        std.posix.close(self.pty.pty);
-        _ = std.os.linux.setsid();
+        std.debug.print("inside child\n", .{});
-
+        if (c.setsid() != 0) return error.SetSid;
-        // set the controlling terminal
+        std.debug.print("setting up io for tty\n", .{});
         var u: c_uint = std.posix.STDIN_FILENO;
-        if (posix.system.ioctl(self.pty.tty, posix.T.IOCSCTTY, @intFromPtr(&u)) != 0) return error.IoctlError;
+
+        if (c.ioctl(self.pty.tty, TIOCSCTTY, @intFromPtr(&u)) != 0) return error.IoctlError;
+
+        // switch (builtin.os.tag) {
+        //     .linux => {},
+        //     .ios, .macos => {
+        //         // Mac doesn't support dup3 so we use dup2. We purposely clear
+        //         // CLO_ON_EXEC for this fd.
+        //         const flags = try posix.fcntl(self.pty.tty, posix.F.GETFD, 0);
+        //         if (flags & posix.FD_CLOEXEC != 0) {
+        //             _ = try posix.fcntl(self.pty.tty, posix.F.SETFD, flags & ~@as(u32, posix.FD_CLOEXEC));
+        //         }
+        //     },
+        //     else => @compileError("unsupported platform"),
+        // }
 
         // set up io
         try posix.dup2(self.pty.tty, std.posix.STDIN_FILENO);
@@ -51,13 +82,17 @@ pub fn spawn(self: *Command, allocator: std.mem.Allocator) !void {
         }
 
         // exec
-        const err = std.posix.execvpeZ(argv_buf.ptr[0].?, argv_buf.ptr, envp);
+        _ = std.posix.execvpeZ(argv_buf.ptr[0].?, argv_buf.ptr, envp) catch null;
-        _ = err catch {};
+
+        //return error.ExecFailed;
+        // const err = std.posix.execvpeZ("/bin/zsh", "/bin/zsh", envp);
+        // _ = err catch {};
     }
 
     // we are the parent
     self.pid = @intCast(pid);
-
+    _ = posix.waitpid(pid, 0);
+    std.debug.print("waitpid in parent\n", .{});
     if (!Terminal.global_sigchild_installed) {
         Terminal.global_sigchild_installed = true;
         var act = posix.Sigaction{

src/widgets/terminal/Pty.zig

@@ -7,6 +7,25 @@ const Winsize = @import("../../main.zig").Winsize;
 
 const posix = std.posix;
 
+extern "c" fn setsid() std.c.pid_t;
+
+const c = struct {
+    usingnamespace switch (builtin.os.tag) {
+        .macos => @cImport({
+            @cInclude("sys/ioctl.h"); // ioctl and constants
+            @cInclude("util.h"); // openpty()
+        }),
+        else => @cImport({
+            @cInclude("sys/ioctl.h"); // ioctl and constants
+            @cInclude("pty.h");
+        }),
+    };
+};
+
+const TIOCSCTTY = if (builtin.os.tag == .macos) 536900705 else c.TIOCSCTTY;
+const TIOCSWINSZ = if (builtin.os.tag == .macos) 2148037735 else c.TIOCSWINSZ;
+const TIOCGWINSZ = if (builtin.os.tag == .macos) 1074295912 else c.TIOCGWINSZ;
+
 pty: posix.fd_t,
 tty: posix.fd_t,
 
@@ -14,6 +33,7 @@ tty: posix.fd_t,
 pub fn init() !Pty {
     switch (builtin.os.tag) {
         .linux => return openPtyLinux(),
+        .macos => return openPtyMacos(),
         else => @compileError("unsupported os"),
     }
 }
@@ -32,10 +52,75 @@ pub fn setSize(self: Pty, ws: Winsize) !void {
         .ws_xpixel = @truncate(ws.x_pixel),
         .ws_ypixel = @truncate(ws.y_pixel),
     };
-    if (posix.system.ioctl(self.pty, posix.T.IOCSWINSZ, @intFromPtr(&_ws)) != 0)
+    if (c.ioctl(self.pty, TIOCSWINSZ, @intFromPtr(&_ws)) != 0)
         return error.SetWinsizeError;
 }
 
+fn openPtyMacos2() !Pty {
+    const p = try posix.open("/dev/ptmx", .{ .ACCMODE = .RDWR, .NOCTTY = true }, 0);
+    errdefer posix.close(p);
+
+    // unlockpt
+    // var n: c_uint = 0;
+    if (c.ioctl(p, c.TIOCPTYUNLK) != 0) return error.IoctlError;
+
+    // ptsname
+    if (c.ioctl(p, c.TIOCPTYGRANT) != 0) return error.IoctlError;
+
+    var buf: [128]u8 = undefined;
+    // var buf2: [128]u8 = undefined;
+    if (c.ioctl(p, c.TIOCPTYGNAME, &buf) != 0) return error.IoctlError;
+    const sname = buf[0 .. 13 - 1];
+    // std.debug.print("sizeof buf: {d}", .{buf.len});
+    // const sname = try std.fmt.bufPrint(&buf2, "{s}", .{buf});
+    std.debug.print("slave name: {s}\n", .{sname});
+    // const sname = try std.fmt.bufPrint(&buf, "/dev/pts/{d}", .{n});
+    // std.log.err("pts: {s}", .{sname});
+
+    const t = try posix.open(sname, .{ .ACCMODE = .RDWR, .NOCTTY = true }, 0);
+    std.debug.print("posix opened : {s}\n", .{sname});
+
+    var attrs: c.termios = undefined;
+    if (c.tcgetattr(p, &attrs) != 0)
+        return error.OpenptyFailed;
+    attrs.c_iflag |= c.IUTF8;
+    if (c.tcsetattr(p, c.TCSANOW, &attrs) != 0)
+        return error.OpenptyFailed;
+
+    return .{
+        .pty = p,
+        .tty = t,
+    };
+}
+
+fn openPtyMacos() !Pty {
+    var master_fd: posix.fd_t = undefined;
+    var slave_fd: posix.fd_t = undefined;
+    if (c.openpty(
+        &master_fd,
+        &slave_fd,
+        null,
+        null,
+        null,
+    ) < 0)
+        return error.OpenptyFailed;
+    errdefer {
+        _ = posix.system.close(master_fd);
+        _ = posix.system.close(slave_fd);
+    }
+    var attrs: c.termios = undefined;
+    if (c.tcgetattr(master_fd, &attrs) != 0)
+        return error.OpenptyFailed;
+    attrs.c_iflag |= c.IUTF8;
+    if (c.tcsetattr(master_fd, c.TCSANOW, &attrs) != 0)
+        return error.OpenptyFailed;
+
+    return .{
+        .pty = master_fd,
+        .tty = slave_fd,
+    };
+}
+
 fn openPtyLinux() !Pty {
     const p = try posix.open("/dev/ptmx", .{ .ACCMODE = .RDWR, .NOCTTY = true }, 0);
     errdefer posix.close(p);

src/widgets/terminal/Screen.zig

@@ -4,7 +4,7 @@ const vaxis = @import("../../main.zig");
 
 const ansi = @import("ansi.zig");
 
-const log = std.log.scoped(.terminal);
+const log = std.log.scoped(.vaxis_terminal);
 
 const Screen = @This();
 

src/widgets/terminal/Terminal.zig

@@ -94,8 +94,12 @@ pub fn init(
     unicode: *const vaxis.Unicode,
     opts: Options,
 ) !Terminal {
+    if (opts.initial_working_directory) |pwd| {
+        if (!std.fs.path.isAbsolute(pwd)) return error.InvalidWorkingDirectory;
+    }
     const pty = try Pty.init();
     try pty.setSize(opts.winsize);
+    std.debug.print("set size done\n", .{});
     const cmd: Command = .{
         .argv = argv,
         .env_map = env,
@@ -155,11 +159,22 @@ pub fn deinit(self: *Terminal) void {
 }
 
 pub fn spawn(self: *Terminal) !void {
+    std.debug.print("inside spawn", .{});
     if (self.thread != null) return;
     self.back_screen = &self.back_screen_pri;
 
     try self.cmd.spawn(self.allocator);
 
+    self.working_directory.clearRetainingCapacity();
+    if (self.cmd.working_directory) |pwd| {
+        try self.working_directory.appendSlice(pwd);
+    } else {
+        const pwd = std.fs.cwd();
+        var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+        const out_path = try std.os.getFdPath(pwd.fd, &buffer);
+        try self.working_directory.appendSlice(out_path);
+    }
+
     {
         // add to our global list
         global_vt_mutex.lock();
@@ -259,6 +274,7 @@ fn anyReader(self: *const Terminal) std.io.AnyReader {
 
 /// process the output from the command on the pty
 fn run(self: *Terminal) !void {
+    std.debug.print("inside run\n", .{});
     var parser: Parser = .{
         .buf = try std.ArrayList(u8).initCapacity(self.allocator, 128),
     };
@@ -268,6 +284,7 @@ fn run(self: *Terminal) !void {
     var reader = std.io.bufferedReader(self.anyReader());
 
     while (!self.should_quit) {
+        std.debug.print("inside while loop\n", .{});
         const event = try parser.parseReader(&reader);
         self.back_mutex.lock();
         defer self.back_mutex.unlock();
@@ -275,8 +292,10 @@ fn run(self: *Terminal) !void {
         if (!self.dirty and self.event_queue.tryPush(.redraw))
             self.dirty = true;
 
+        std.debug.print("before switch event\n", .{});
         switch (event) {
             .print => |str| {
+                std.debug.print("inside print event\n", .{});
                 var iter = grapheme.Iterator.init(str, &self.unicode.grapheme_data);
                 while (iter.next()) |g| {
                     const gr = g.bytes(str);
@@ -287,6 +306,7 @@ fn run(self: *Terminal) !void {
             },
             .c0 => |b| try self.handleC0(b),
             .escape => |esc| {
+                std.debug.print("inside escape event\n", .{});
                 const final = esc[esc.len - 1];
                 switch (final) {
                     'B' => {}, // TODO: handle charsets
@@ -700,6 +720,7 @@ fn run(self: *Terminal) !void {
 }
 
 inline fn handleC0(self: *Terminal, b: ansi.C0) !void {
+    std.debug.print("inside handlec0\n", .{});
     switch (b) {
         .NUL, .SOH, .STX => {},
         .EOT => {}, // we send EOT to quit the read thread
@@ -716,6 +737,7 @@ inline fn handleC0(self: *Terminal, b: ansi.C0) !void {
 }
 
 pub fn setMode(self: *Terminal, mode: u16, val: bool) void {
+    std.debug.print("inside setmode\n", .{});
     switch (mode) {
         7 => self.mode.autowrap = val,
         25 => self.mode.cursor = val,

src/widgets/terminal/log.lg

@@ -0,0 +1,5 @@
+info(loop): pixel mouse capability detected
+info(loop): unicode capability detected
+info(loop): color_scheme_updates capability detected
+info(loop): kitty keyboard capability detected
+info(loop): kitty graphics capability detected

src/windows/Tty.zig

@@ -6,6 +6,7 @@ const std = @import("std");
 const Event = @import("../event.zig").Event;
 const Key = @import("../Key.zig");
 const Mouse = @import("../Mouse.zig");
+const Parser = @import("../Parser.zig");
 const windows = std.os.windows;
 
 stdin: windows.HANDLE,
@@ -117,57 +118,64 @@ pub fn bufferedWriter(self: *const Tty) std.io.BufferedWriter(4096, std.io.AnyWr
     return std.io.bufferedWriter(self.anyWriter());
 }
 
-pub fn nextEvent(self: *Tty) !Event {
+pub fn nextEvent(self: *Tty, parser: *Parser, paste_allocator: ?std.mem.Allocator) !Event {
     // We use a loop so we can ignore certain events
-    var ansi_buf: [128]u8 = undefined;
+    var state: EventState = .{};
-    var ansi_idx: usize = 0;
-    var escape_st: bool = false;
     while (true) {
         var event_count: u32 = 0;
         var input_record: INPUT_RECORD = undefined;
         if (ReadConsoleInputW(self.stdin, &input_record, 1, &event_count) == 0)
             return windows.unexpectedError(windows.kernel32.GetLastError());
 
-        switch (input_record.EventType) {
+        if (try self.eventFromRecord(&input_record, &state, parser, paste_allocator)) |ev| {
-            0x0001 => { // Key event
+            return ev;
-                const event = input_record.Event.KeyEvent;
+        }
+    }
+}
 
-                const base_layout: u21 = switch (event.wVirtualKeyCode) {
+pub const EventState = struct {
-                    0x00 => { // delivered when we get an escape sequence
+    ansi_buf: [128]u8 = undefined,
-                        ansi_buf[ansi_idx] = event.uChar.AsciiChar;
+    ansi_idx: usize = 0,
-                        ansi_idx += 1;
+    utf16_buf: [2]u16 = undefined,
-                        if (ansi_idx <= 2) {
+    utf16_half: bool = false,
-                            continue;
+};
+
+pub fn eventFromRecord(self: *Tty, record: *const INPUT_RECORD, state: *EventState, parser: *Parser, paste_allocator: ?std.mem.Allocator) !?Event {
+    switch (record.EventType) {
+        0x0001 => { // Key event
+            const event = record.Event.KeyEvent;
+
+            if (state.utf16_half) half: {
+                state.utf16_half = false;
+                state.utf16_buf[1] = event.uChar.UnicodeChar;
+                const codepoint: u21 = std.unicode.utf16DecodeSurrogatePair(&state.utf16_buf) catch break :half;
+                const n = std.unicode.utf8Encode(codepoint, &self.buf) catch return null;
+
+                const key: Key = .{
+                    .codepoint = codepoint,
+                    .base_layout_codepoint = codepoint,
+                    .mods = translateMods(event.dwControlKeyState),
+                    .text = self.buf[0..n],
+                };
+
+                switch (event.bKeyDown) {
+                    0 => return .{ .key_release = key },
+                    else => return .{ .key_press = key },
                 }
-                        switch (ansi_buf[1]) {
-                            '[' => { // CSI, read until 0x40 to 0xFF
-                                switch (event.uChar.AsciiChar) {
-                                    0x40...0xFF => {
-                                        return .cap_da1;
-                                    },
-                                    else => continue,
-                                }
-                            },
-                            ']' => { // OSC, read until ESC \ or BEL
-                                switch (event.uChar.AsciiChar) {
-                                    0x07 => {
-                                        return .cap_da1;
-                                    },
-                                    0x1B => {
-                                        escape_st = true;
-                                        continue;
-                                    },
-                                    '\\' => {
-                                        if (escape_st) {
-                                            return .cap_da1;
-                                        }
-                                        continue;
-                                    },
-                                    else => continue,
-                                }
-                            },
-                            else => continue,
             }
+
+            const base_layout: u16 = switch (event.wVirtualKeyCode) {
+                0x00 => blk: { // delivered when we get an escape sequence or a unicode codepoint
+                    if (state.ansi_idx == 0 and event.uChar.AsciiChar != 27)
+                        break :blk event.uChar.UnicodeChar;
+                    state.ansi_buf[state.ansi_idx] = event.uChar.AsciiChar;
+                    state.ansi_idx += 1;
+                    if (state.ansi_idx <= 2) return null;
+                    const result = try parser.parse(state.ansi_buf[0..state.ansi_idx], paste_allocator);
+                    return if (result.n == 0) null else evt: {
+                        state.ansi_idx = 0;
+                        break :evt result.event;
+                    };
                 },
                 0x08 => Key.backspace,
                 0x09 => Key.tab,
@@ -257,16 +265,25 @@ pub fn nextEvent(self: *Tty) !Event {
                 0xdc => '\\',
                 0xdd => ']',
                 0xde => '\'',
-                    else => continue,
+                else => return null,
             };
 
+            if (std.unicode.utf16IsHighSurrogate(base_layout)) {
+                state.utf16_buf[0] = base_layout;
+                state.utf16_half = true;
+                return null;
+            }
+            if (std.unicode.utf16IsLowSurrogate(base_layout)) {
+                return null;
+            }
+
             var codepoint: u21 = base_layout;
             var text: ?[]const u8 = null;
             switch (event.uChar.UnicodeChar) {
                 0x00...0x1F => {},
                 else => |cp| {
                     codepoint = cp;
-                        const n = try std.unicode.utf8Encode(cp, &self.buf);
+                    const n = try std.unicode.utf8Encode(codepoint, &self.buf);
                     text = self.buf[0..n];
                 },
             }
@@ -286,7 +303,7 @@ pub fn nextEvent(self: *Tty) !Event {
         0x0002 => { // Mouse event
             // see https://learn.microsoft.com/en-us/windows/console/mouse-event-record-str
 
-                const event = input_record.Event.MouseEvent;
+            const event = record.Event.MouseEvent;
 
             // High word of dwButtonState represents mouse wheel. Positive is wheel_up, negative
             // is wheel_down
@@ -349,7 +366,7 @@ pub fn nextEvent(self: *Tty) !Event {
                 },
                 else => {
                     std.log.warn("unknown mouse event: {}", .{event});
-                        continue;
+                    return null;
                 },
             };
 
@@ -391,14 +408,14 @@ pub fn nextEvent(self: *Tty) !Event {
             };
         },
         0x0010 => { // Focus events
-                switch (input_record.Event.FocusEvent.bSetFocus) {
+            switch (record.Event.FocusEvent.bSetFocus) {
                 0 => return .focus_out,
                 else => return .focus_in,
             }
         },
         else => {},
     }
-    }
+    return null;
 }
 
 fn translateMods(mods: u32) Key.Modifiers {

src/xev.zig

@@ -9,7 +9,7 @@ const Key = @import("Key.zig");
 const Mouse = @import("Mouse.zig");
 const Color = @import("Cell.zig").Color;
 
-const log = std.log.scoped(.tty_watcher);
+const log = std.log.scoped(.vaxis_xev);
 
 pub const Event = union(enum) {
     key_press: Key,
@@ -99,8 +99,6 @@ pub fn TtyWatcher(comptime Userdata: type) type {
                 .callback = Self.signalCallback,
             };
             try Tty.notifyWinsize(handler);
-            const winsize = try Tty.getWinsize(self.tty.fd);
-            _ = self.callback(self.ud, loop, self, .{ .winsize = winsize });
         }
 
         fn signalCallback(ptr: *anyopaque) void {