fix: port terminal widget to zig-0.15

examples/vt.zig

···
     try loop.start();
     defer loop.stop();
 
-    var buffered = tty.bufferedWriter();
-
     try vx.enterAltScreen(tty.writer());
     try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
     var env = try std.process.getEnvMap(alloc);
···
     };
     const shell = env.get("SHELL") orelse "bash";
     const argv = [_][]const u8{shell};
+    var write_buf: [4096]u8 = undefined;
     var vt = try vaxis.widgets.Terminal.init(
         alloc,
         &argv,
         &env,
         &vx.unicode,
         vt_opts,
+        &write_buf,
     );
     defer vt.deinit();
     try vt.spawn();
···
             .x_pixel = 0,
             .y_pixel = 0,
         });
-        try vt.draw(child);
+        try vt.draw(alloc, child);
 
-        try vx.render(buffered.writer().any());
-        try buffered.flush();
+        try vx.render(tty.writer());
+        try tty.writer().flush();
     }
 }

src/widgets/terminal/Command.zig

···
 
         // set the controlling terminal
         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 (posix.system.ioctl(self.pty.tty.handle, posix.T.IOCSCTTY, @intFromPtr(&u)) != 0) return error.IoctlError;
 
         // set up io
-        try posix.dup2(self.pty.tty, std.posix.STDIN_FILENO);
-        try posix.dup2(self.pty.tty, std.posix.STDOUT_FILENO);
-        try posix.dup2(self.pty.tty, std.posix.STDERR_FILENO);
+        try posix.dup2(self.pty.tty.handle, std.posix.STDIN_FILENO);
+        try posix.dup2(self.pty.tty.handle, std.posix.STDOUT_FILENO);
+        try posix.dup2(self.pty.tty.handle, std.posix.STDERR_FILENO);
 
-        posix.close(self.pty.tty);
-        if (self.pty.pty > 2) posix.close(self.pty.pty);
+        self.pty.tty.close();
+        if (self.pty.pty.handle > 2) self.pty.pty.close();
 
         if (self.working_directory) |wd| {
             try std.posix.chdir(wd);
···
     return;
 }
 
-fn handleSigChild(_: c_int) callconv(.C) void {
+fn handleSigChild(_: c_int) callconv(.c) void {
     const result = std.posix.waitpid(-1, 0);
 
     Terminal.global_vt_mutex.lock();
···
     {
         var it = map.iterator();
         while (it.next()) |pair| {
-            envp_buf[i] = try std.fmt.allocPrintZ(arena, "{s}={s}", .{ pair.key_ptr.*, pair.value_ptr.* });
+            envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "{s}={s}", .{ pair.key_ptr.*, pair.value_ptr.* }, 0);
             i += 1;
         }
     }

src/widgets/terminal/Parser.zig

···
 const Parser = @This();
 
 const std = @import("std");
-const Reader = std.io.AnyReader;
+const Reader = std.Io.Reader;
 const ansi = @import("ansi.zig");
-const BufferedReader = std.io.BufferedReader(4096, std.io.AnyReader);
 
 /// A terminal event
 const Event = union(enum) {
···
     apc: []const u8,
 };
 
-buf: std.ArrayList(u8),
+buf: std.array_list.Managed(u8),
 /// a leftover byte from a ground event
 pending_byte: ?u8 = null,
 
-pub fn parseReader(self: *Parser, buffered: *BufferedReader) !Event {
-    const reader = buffered.reader().any();
+pub fn parseReader(self: *Parser, reader: *Reader) !Event {
     self.buf.clearRetainingCapacity();
     while (true) {
-        const b = if (self.pending_byte) |p| p else try reader.readByte();
+        const b = if (self.pending_byte) |p| p else try reader.takeByte();
         self.pending_byte = null;
         switch (b) {
             // Escape sequence
             0x1b => {
-                const next = try reader.readByte();
+                const next = try reader.takeByte();
                 switch (next) {
-                    0x4E => return .{ .ss2 = try reader.readByte() },
-                    0x4F => return .{ .ss3 = try reader.readByte() },
+                    0x4E => return .{ .ss2 = try reader.takeByte() },
+                    0x4F => return .{ .ss3 = try reader.takeByte() },
                     0x50 => try skipUntilST(reader), // DCS
                     0x58 => try skipUntilST(reader), // SOS
                     0x5B => return self.parseCsi(reader), // CSI
···
             => return .{ .c0 = @enumFromInt(b) },
             else => {
                 try self.buf.append(b);
-                return self.parseGround(buffered);
+                return self.parseGround(reader);
             },
         }
     }
 }
 
-inline fn parseGround(self: *Parser, reader: *BufferedReader) !Event {
+inline fn parseGround(self: *Parser, reader: *Reader) !Event {
     var buf: [1]u8 = undefined;
     {
         std.debug.assert(self.buf.items.len > 0);
···
         const len = try std.unicode.utf8ByteSequenceLength(self.buf.items[0]);
         var i: usize = 1;
         while (i < len) : (i += 1) {
-            const read = try reader.read(&buf);
+            const read = try reader.readSliceShort(&buf);
             if (read == 0) return error.EOF;
             try self.buf.append(buf[0]);
         }
     }
     while (true) {
-        if (reader.start == reader.end) return .{ .print = self.buf.items };
-        const n = try reader.read(&buf);
+        if (reader.bufferedLen() == 0) return .{ .print = self.buf.items };
+        const n = try reader.readSliceShort(&buf);
         if (n == 0) return error.EOF;
         const b = buf[0];
         switch (b) {
···
                 const len = try std.unicode.utf8ByteSequenceLength(b);
                 var i: usize = 1;
                 while (i < len) : (i += 1) {
-                    const read = try reader.read(&buf);
+                    const read = try reader.readSliceShort(&buf);
                     if (read == 0) return error.EOF;
 
                     try self.buf.append(buf[0]);
···
 }
 
 /// parse until b >= 0x30
-inline fn parseEscape(self: *Parser, reader: Reader) !Event {
+inline fn parseEscape(self: *Parser, reader: *Reader) !Event {
     while (true) {
-        const b = try reader.readByte();
+        const b = try reader.takeByte();
         switch (b) {
             0x20...0x2F => continue,
             else => {
···
     }
 }
 
-inline fn parseApc(self: *Parser, reader: Reader) !Event {
+inline fn parseApc(self: *Parser, reader: *Reader) !Event {
     while (true) {
-        const b = try reader.readByte();
+        const b = try reader.takeByte();
         switch (b) {
             0x00...0x17,
             0x19,
             0x1c...0x1f,
             => continue,
             0x1b => {
-                try reader.skipBytes(1, .{ .buf_size = 1 });
+                _ = try reader.discard(std.Io.Limit.limited(1));
                 return .{ .apc = self.buf.items };
             },
             else => try self.buf.append(b),
···
 }
 
 /// Skips sequences until we see an ST (String Terminator, ESC \)
-inline fn skipUntilST(reader: Reader) !void {
-    try reader.skipUntilDelimiterOrEof('\x1b');
-    try reader.skipBytes(1, .{ .buf_size = 1 });
+inline fn skipUntilST(reader: *Reader) !void {
+    _ = try reader.discardDelimiterExclusive('\x1b');
+    _ = try reader.discard(std.Io.Limit.limited(1));
 }
 
 /// Parses an OSC sequence
-inline fn parseOsc(self: *Parser, reader: Reader) !Event {
+inline fn parseOsc(self: *Parser, reader: *Reader) !Event {
     while (true) {
-        const b = try reader.readByte();
+        const b = try reader.takeByte();
         switch (b) {
             0x00...0x06,
             0x08...0x17,
···
             0x1c...0x1f,
             => continue,
             0x1b => {
-                try reader.skipBytes(1, .{ .buf_size = 1 });
+                _ = try reader.discard(std.Io.Limit.limited(1));
                 return .{ .osc = self.buf.items };
             },
             0x07 => return .{ .osc = self.buf.items },
···
     }
 }
 
-inline fn parseCsi(self: *Parser, reader: Reader) !Event {
+inline fn parseCsi(self: *Parser, reader: *Reader) !Event {
     var intermediate: ?u8 = null;
     var pm: ?u8 = null;
 
     while (true) {
-        const b = try reader.readByte();
+        const b = try reader.takeByte();
         switch (b) {
             0x20...0x2F => intermediate = b,
             0x30...0x3B => try self.buf.append(b),

src/widgets/terminal/Pty.zig

···
 
 const posix = std.posix;
 
-pty: posix.fd_t,
-tty: posix.fd_t,
+pty: std.fs.File,
+tty: std.fs.File,
 
 /// opens a new tty/pty pair
 pub fn init() !Pty {
···
 
 /// closes the tty and pty
 pub fn deinit(self: Pty) void {
-    posix.close(self.pty);
-    posix.close(self.tty);
+    self.pty.close();
+    self.tty.close();
 }
 
 /// sets the size of the pty
···
         .xpixel = @truncate(ws.x_pixel),
         .ypixel = @truncate(ws.y_pixel),
     };
-    if (posix.system.ioctl(self.pty, posix.T.IOCSWINSZ, @intFromPtr(&_ws)) != 0)
+    if (posix.system.ioctl(self.pty.handle, posix.T.IOCSWINSZ, @intFromPtr(&_ws)) != 0)
         return error.SetWinsizeError;
 }
 
···
     const t = try posix.open(sname, .{ .ACCMODE = .RDWR, .NOCTTY = true }, 0);
 
     return .{
-        .pty = p,
-        .tty = t,
+        .pty = .{ .handle = p },
+        .tty = .{ .handle = t },
     };
 }

src/widgets/terminal/Screen.zig

···
 const Screen = @This();
 
 pub const Cell = struct {
-    char: std.ArrayList(u8) = undefined,
+    char: std.ArrayList(u8) = .empty,
     style: vaxis.Style = .{},
-    uri: std.ArrayList(u8) = undefined,
-    uri_id: std.ArrayList(u8) = undefined,
+    uri: std.ArrayList(u8) = .empty,
+    uri_id: std.ArrayList(u8) = .empty,
     width: u8 = 1,
 
     wrapped: bool = false,
     dirty: bool = true,
 
-    pub fn erase(self: *Cell, bg: vaxis.Color) void {
+    pub fn erase(self: *Cell, allocator: std.mem.Allocator, bg: vaxis.Color) void {
         self.char.clearRetainingCapacity();
-        self.char.append(' ') catch unreachable; // we never completely free this list
+        self.char.append(allocator, ' ') catch unreachable; // we never completely free this list
         self.style = .{};
         self.style.bg = bg;
         self.uri.clearRetainingCapacity();
···
         self.dirty = true;
     }
 
-    pub fn copyFrom(self: *Cell, src: Cell) !void {
+    pub fn copyFrom(self: *Cell, allocator: std.mem.Allocator, src: Cell) !void {
         self.char.clearRetainingCapacity();
-        try self.char.appendSlice(src.char.items);
+        try self.char.appendSlice(allocator, src.char.items);
         self.style = src.style;
         self.uri.clearRetainingCapacity();
-        try self.uri.appendSlice(src.uri.items);
+        try self.uri.appendSlice(allocator, src.uri.items);
         self.uri_id.clearRetainingCapacity();
-        try self.uri_id.appendSlice(src.uri_id.items);
+        try self.uri_id.appendSlice(allocator, src.uri_id.items);
         self.width = src.width;
         self.wrapped = src.wrapped;
 
···
     }
 };
 
+allocator: std.mem.Allocator,
+
 width: u16 = 0,
 height: u16 = 0,
 
···
 /// sets each cell to the default cell
 pub fn init(alloc: std.mem.Allocator, w: u16, h: u16) !Screen {
     var screen = Screen{
+        .allocator = alloc,
         .buf = try alloc.alloc(Cell, @as(usize, @intCast(w)) * h),
         .scrolling_region = .{
             .top = 0,
···
     };
     for (screen.buf, 0..) |_, i| {
         screen.buf[i] = .{
-            .char = try std.ArrayList(u8).initCapacity(alloc, 1),
-            .uri = std.ArrayList(u8).init(alloc),
-            .uri_id = std.ArrayList(u8).init(alloc),
+            .char = try .initCapacity(alloc, 1),
         };
-        try screen.buf[i].char.append(' ');
+        try screen.buf[i].char.append(alloc, ' ');
     }
     return screen;
 }
 
 pub fn deinit(self: *Screen, alloc: std.mem.Allocator) void {
     for (self.buf, 0..) |_, i| {
-        self.buf[i].char.deinit();
-        self.buf[i].uri.deinit();
-        self.buf[i].uri_id.deinit();
+        self.buf[i].char.deinit(alloc);
+        self.buf[i].uri.deinit(alloc);
+        self.buf[i].uri_id.deinit(alloc);
     }
 
     alloc.free(self.buf);
 }
 
 /// copies the visible area to the destination screen
-pub fn copyTo(self: *Screen, dst: *Screen) !void {
+pub fn copyTo(self: *Screen, allocator: std.mem.Allocator, dst: *Screen) !void {
     dst.cursor = self.cursor;
     for (self.buf, 0..) |cell, i| {
         if (!cell.dirty) continue;
         self.buf[i].dirty = false;
         const grapheme = cell.char.items;
         dst.buf[i].char.clearRetainingCapacity();
-        try dst.buf[i].char.appendSlice(grapheme);
+        try dst.buf[i].char.appendSlice(allocator, grapheme);
         dst.buf[i].width = cell.width;
         dst.buf[i].style = cell.style;
     }
···
     const i = (row * self.width) + col;
     assert(i < self.buf.len);
     self.buf[i].char.clearRetainingCapacity();
-    self.buf[i].char.appendSlice(grapheme) catch {
+    self.buf[i].char.appendSlice(self.allocator, grapheme) catch {
         log.warn("couldn't write grapheme", .{});
     };
     self.buf[i].uri.clearRetainingCapacity();
-    self.buf[i].uri.appendSlice(self.cursor.uri.items) catch {
+    self.buf[i].uri.appendSlice(self.allocator, self.cursor.uri.items) catch {
         log.warn("couldn't write uri", .{});
     };
     self.buf[i].uri_id.clearRetainingCapacity();
-    self.buf[i].uri_id.appendSlice(self.cursor.uri_id.items) catch {
+    self.buf[i].uri_id.appendSlice(self.allocator, self.cursor.uri_id.items) catch {
         log.warn("couldn't write uri_id", .{});
     };
     self.buf[i].style = self.cursor.style;
···
     const end = (self.cursor.row * self.width) + (self.width);
     var i = (self.cursor.row * self.width) + self.cursor.col;
     while (i < end) : (i += 1) {
-        self.buf[i].erase(self.cursor.style.bg);
+        self.buf[i].erase(self.allocator, self.cursor.style.bg);
     }
 }
 
···
     const end = start + self.cursor.col + 1;
     var i = start;
     while (i < end) : (i += 1) {
-        self.buf[i].erase(self.cursor.style.bg);
+        self.buf[i].erase(self.allocator, self.cursor.style.bg);
     }
 }
 
···
     const end = start + self.width;
     var i = start;
     while (i < end) : (i += 1) {
-        self.buf[i].erase(self.cursor.style.bg);
+        self.buf[i].erase(self.allocator, self.cursor.style.bg);
     }
 }
 
···
         while (col <= self.scrolling_region.right) : (col += 1) {
             const i = (row * self.width) + col;
             if (row + cnt > self.scrolling_region.bottom)
-                self.buf[i].erase(self.cursor.style.bg)
+                self.buf[i].erase(self.allocator, self.cursor.style.bg)
             else
-                try self.buf[i].copyFrom(self.buf[i + stride]);
+                try self.buf[i].copyFrom(self.allocator, self.buf[i + stride]);
         }
     }
 }
···
         var col: usize = self.scrolling_region.left;
         while (col <= self.scrolling_region.right) : (col += 1) {
             const i = (row * self.width) + col;
-            try self.buf[i].copyFrom(self.buf[i - stride]);
+            try self.buf[i].copyFrom(self.allocator, self.buf[i - stride]);
         }
     }
 
···
         var col: usize = self.scrolling_region.left;
         while (col <= self.scrolling_region.right) : (col += 1) {
             const i = (row * self.width) + col;
-            self.buf[i].erase(self.cursor.style.bg);
+            self.buf[i].erase(self.allocator, self.cursor.style.bg);
         }
     }
 }
···
     const start = (self.cursor.row * self.width) + (self.width);
     var i = start;
     while (i < self.buf.len) : (i += 1) {
-        self.buf[i].erase(self.cursor.style.bg);
+        self.buf[i].erase(self.allocator, self.cursor.style.bg);
     }
 }
 
···
     const end = self.cursor.row * self.width;
     var i = start;
     while (i < end) : (i += 1) {
-        self.buf[i].erase(self.cursor.style.bg);
+        self.buf[i].erase(self.allocator, self.cursor.style.bg);
     }
 }
 
 pub fn eraseAll(self: *Screen) void {
     var i: usize = 0;
     while (i < self.buf.len) : (i += 1) {
-        self.buf[i].erase(self.cursor.style.bg);
+        self.buf[i].erase(self.allocator, self.cursor.style.bg);
     }
 }
 
···
     var col = self.cursor.col;
     while (col <= self.scrolling_region.right) : (col += 1) {
         if (col + n <= self.scrolling_region.right)
-            try self.buf[col].copyFrom(self.buf[col + n])
+            try self.buf[col].copyFrom(self.allocator, self.buf[col + n])
         else
-            self.buf[col].erase(self.cursor.style.bg);
+            self.buf[col].erase(self.allocator, self.cursor.style.bg);
     }
 }
 

src/widgets/terminal/Terminal.zig

···
 scrollback_size: u16,
 
 pty: Pty,
+pty_writer: std.fs.File.Writer,
 cmd: Command,
 thread: ?std.Thread = null,
 
···
 mode: Mode = .{},
 
 tab_stops: std.ArrayList(u16),
-title: std.ArrayList(u8),
-working_directory: std.ArrayList(u8),
+title: std.ArrayList(u8) = .empty,
+working_directory: std.ArrayList(u8) = .empty,
 
 last_printed: []const u8 = "",
 
···
     env: *const std.process.EnvMap,
     unicode: *const vaxis.Unicode,
     opts: Options,
+    write_buf: []u8,
 ) !Terminal {
     // Verify we have an absolute path
     if (opts.initial_working_directory) |pwd| {
···
         .pty = pty,
         .working_directory = opts.initial_working_directory,
     };
-    var tabs = try std.ArrayList(u16).initCapacity(allocator, opts.winsize.cols / 8);
+    var tabs: std.ArrayList(u16) = try .initCapacity(allocator, opts.winsize.cols / 8);
     var col: u16 = 0;
     while (col < opts.winsize.cols) : (col += 8) {
-        try tabs.append(col);
+        try tabs.append(allocator, col);
     }
     return .{
         .allocator = allocator,
         .pty = pty,
+        .pty_writer = pty.pty.writerStreaming(write_buf),
         .cmd = cmd,
         .scrollback_size = opts.scrollback_size,
         .front_screen = try Screen.init(allocator, opts.winsize.cols, opts.winsize.rows),
···
         .back_screen_alt = try Screen.init(allocator, opts.winsize.cols, opts.winsize.rows),
         .unicode = unicode,
         .tab_stops = tabs,
-        .title = std.ArrayList(u8).init(allocator),
-        .working_directory = std.ArrayList(u8).init(allocator),
     };
 }
 
···
     if (self.thread) |thread| {
         // write an EOT into the tty to trigger a read on our thread
         const EOT = "\x04";
-        _ = std.posix.write(self.pty.tty, EOT) catch {};
+        _ = self.pty.tty.write(EOT) catch {};
         thread.join();
         self.thread = null;
     }
···
     self.front_screen.deinit(self.allocator);
     self.back_screen_pri.deinit(self.allocator);
     self.back_screen_alt.deinit(self.allocator);
-    self.tab_stops.deinit();
-    self.title.deinit();
-    self.working_directory.deinit();
+    self.tab_stops.deinit(self.allocator);
+    self.title.deinit(self.allocator);
+    self.working_directory.deinit(self.allocator);
 }
 
 pub fn spawn(self: *Terminal) !void {
···
 
     self.working_directory.clearRetainingCapacity();
     if (self.cmd.working_directory) |pwd| {
-        try self.working_directory.appendSlice(pwd);
+        try self.working_directory.appendSlice(self.allocator, 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);
+        try self.working_directory.appendSlice(self.allocator, out_path);
     }
 
     {
···
     try self.pty.setSize(ws);
 }
 
-pub fn draw(self: *Terminal, win: vaxis.Window) !void {
+pub fn draw(self: *Terminal, allocator: std.mem.Allocator, win: vaxis.Window) !void {
     if (self.back_mutex.tryLock()) {
         defer self.back_mutex.unlock();
         // We keep this as a separate condition so we don't deadlock by obtaining the lock but not
         // having sync
         if (!self.mode.sync) {
-            try self.back_screen.copyTo(&self.front_screen);
+            try self.back_screen.copyTo(allocator, &self.front_screen);
             self.dirty = false;
         }
     }
···
     }
 }
 
-fn opaqueWrite(ptr: *const anyopaque, buf: []const u8) !usize {
-    const self: *const Terminal = @ptrCast(@alignCast(ptr));
-    return posix.write(self.pty.pty, buf);
-}
-
-pub fn writer(self: *const Terminal) *std.io.Writer {
-    const local = struct {
-        var writer: std.io.Writer = .{
-            .context = self,
-            .writeFn = Terminal.opaqueWrite,
-        };
-    };
-    return &local.writer;
-}
-
-fn opaqueRead(ptr: *const anyopaque, buf: []u8) !usize {
-    const self: *const Terminal = @ptrCast(@alignCast(ptr));
-    return posix.read(self.pty.pty, buf);
+pub fn writer(self: *Terminal) *std.Io.Writer {
+    return &self.pty_writer.interface;
 }
 
-fn anyReader(self: *const Terminal) std.io.AnyReader {
-    return .{
-        .context = self,
-        .readFn = Terminal.opaqueRead,
-    };
+fn reader(self: *const Terminal, buf: []u8) std.fs.File.Reader {
+    return self.pty.pty.readerStreaming(buf);
 }
 
 /// process the output from the command on the pty
 fn run(self: *Terminal) !void {
     var parser: Parser = .{
-        .buf = try std.ArrayList(u8).initCapacity(self.allocator, 128),
+        .buf = try .initCapacity(self.allocator, 128),
     };
     defer parser.buf.deinit();
 
-    // Use our anyReader to make a buffered reader, then get *that* any reader
-    var reader = std.io.bufferedReader(self.anyReader());
+    var reader_buf: [4096]u8 = undefined;
+    var reader_ = self.reader(&reader_buf);
 
     while (!self.should_quit) {
-        const event = try parser.parseReader(&reader);
+        const event = try parser.parseReader(&reader_.interface);
         self.back_mutex.lock();
         defer self.back_mutex.unlock();
 
···
                             if (ts == self.back_screen.cursor.col) break true;
                         } else false;
                         if (already_set) continue;
-                        try self.tab_stops.append(@truncate(self.back_screen.cursor.col));
+                        try self.tab_stops.append(self.allocator, @truncate(self.back_screen.cursor.col));
                         std.mem.sort(u16, self.tab_stops.items, {}, std.sort.asc(u16));
                     },
                     // Reverse Index
···
                             self.tab_stops.clearRetainingCapacity();
                             var col: u16 = 0;
                             while (col < self.back_screen.width) : (col += 8) {
-                                try self.tab_stops.append(col);
+                                try self.tab_stops.append(self.allocator, col);
                             }
                         }
                     },
···
                         );
                         var i: usize = start;
                         while (i < end) : (i += 1) {
-                            self.back_screen.buf[i].erase(self.back_screen.cursor.style.bg);
+                            self.back_screen.buf[i].erase(self.allocator, self.back_screen.cursor.style.bg);
                         }
                     },
                     'Z' => {
···
                                 // Secondary
                                 '>' => try self.writer().writeAll("\x1B[>1;69;0c"),
                                 '=' => try self.writer().writeAll("\x1B[=0000c"),
-                                else => log.info("unhandled CSI: {}", .{seq}),
+                                else => log.info("unhandled CSI: {f}", .{seq}),
                             }
                         } else {
                             // Primary
···
                         const n = iter.next() orelse 0;
                         switch (n) {
                             0 => {
-                                const current = try self.tab_stops.toOwnedSlice();
-                                defer self.tab_stops.allocator.free(current);
+                                const current = try self.tab_stops.toOwnedSlice(self.allocator);
+                                defer self.allocator.free(current);
                                 self.tab_stops.clearRetainingCapacity();
                                 for (current) |stop| {
                                     if (stop == self.back_screen.cursor.col) continue;
-                                    try self.tab_stops.append(stop);
+                                    try self.tab_stops.append(self.allocator, stop);
                                 }
                             },
-                            3 => self.tab_stops.clearAndFree(),
-                            else => log.info("unhandled CSI: {}", .{seq}),
+                            3 => self.tab_stops.clearAndFree(self.allocator),
+                            else => log.info("unhandled CSI: {f}", .{seq}),
                         }
                     },
                     'h', 'l' => {
···
                                     self.back_screen.cursor.row + 1,
                                     self.back_screen.cursor.col + 1,
                                 }),
-                                else => log.info("unhandled CSI: {}", .{seq}),
+                                else => log.info("unhandled CSI: {f}", .{seq}),
                             }
                         }
                     },
···
                                         },
                                     }
                                 },
-                                else => log.info("unhandled CSI: {}", .{seq}),
+                                else => log.info("unhandled CSI: {f}", .{seq}),
                             }
                         }
                     },
···
                                     "\x1bP>|libvaxis {s}\x1B\\",
                                     .{"dev"},
                                 ),
-                                else => log.info("unhandled CSI: {}", .{seq}),
+                                else => log.info("unhandled CSI: {f}", .{seq}),
                             }
                         }
                     },
···
                             self.back_screen.cursor.row = 0;
                         }
                     },
-                    else => log.info("unhandled CSI: {}", .{seq}),
+                    else => log.info("unhandled CSI: {f}", .{seq}),
                 }
             },
             .osc => |osc| {
···
                 switch (ps) {
                     0 => {
                         self.title.clearRetainingCapacity();
-                        try self.title.appendSlice(osc[semicolon + 1 ..]);
+                        try self.title.appendSlice(self.allocator, osc[semicolon + 1 ..]);
                         self.event_queue.push(.{ .title_change = self.title.items });
                     },
                     7 => {
···
                                 defer i += 2;
                                 break :blk try std.fmt.parseUnsigned(u8, enc[i + 1 .. i + 3], 16);
                             } else enc[i];
-                            try self.working_directory.append(b);
+                            try self.working_directory.append(self.allocator, b);
                         }
                         self.event_queue.push(.{ .pwd_change = self.working_directory.items });
                     },

src/widgets/terminal/ansi.zig

···
         return .{ .bytes = self.params };
     }
 
-    pub fn format(
-        self: CSI,
-        comptime layout: []const u8,
-        opts: std.fmt.FormatOptions,
-        writer: anytype,
-    ) !void {
-        _ = layout;
-        _ = opts;
+    pub fn format(self: CSI, writer: anytype) !void {
         if (self.private_marker == null and self.intermediate == null)
-            try std.fmt.format(writer, "CSI {s} {c}", .{
+            try writer.print("CSI {s} {c}", .{
                 self.params,
                 self.final,
             })
         else if (self.private_marker != null and self.intermediate == null)
-            try std.fmt.format(writer, "CSI {c} {s} {c}", .{
+            try writer.print("CSI {c} {s} {c}", .{
                 self.private_marker.?,
                 self.params,
                 self.final,
             })
         else if (self.private_marker == null and self.intermediate != null)
-            try std.fmt.format(writer, "CSI {s} {c} {c}", .{
+            try writer.print("CSI {s} {c} {c}", .{
                 self.params,
                 self.intermediate.?,
                 self.final,
             })
         else
-            try std.fmt.format(writer, "CSI {c} {s} {c} {c}", .{
+            try writer.print("CSI {c} {s} {c} {c}", .{
                 self.private_marker.?,
                 self.params,
                 self.intermediate.?,

src/widgets/terminal/key.zig

···
 const vaxis = @import("../../main.zig");
 
 pub fn encode(
-    writer: std.io.AnyWriter,
+    writer: *std.Io.Writer,
     key: vaxis.Key,
     press: bool,
     kitty_flags: vaxis.Key.KittyFlags,
···
     }
 }
 
-fn legacy(writer: std.io.AnyWriter, key: vaxis.Key) !void {
+fn legacy(writer: *std.Io.Writer, key: vaxis.Key) !void {
     // If we have text, we always write it directly
     if (key.text) |text| {
         try writer.writeAll(text);