refactor: rename anyWriter() to writer()

Now that the writer interfaces are no longer generic, the anyWriter term does not
make sense. This commit renames it to just writer() to match idiomatic zig usage.

README.md

···
     var vx = try vaxis.init(alloc, .{});
     // deinit takes an optional allocator. If your program is exiting, you can
     // choose to pass a null allocator to save some exit time.
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
 
     // The event loop requires an intrusive init. We create an instance with
···
     defer loop.stop();
 
     // Optionally enter the alternate screen
-    try vx.enterAltScreen(tty.anyWriter());
+    try vx.enterAltScreen(tty.writer());
 
     // We'll adjust the color index every keypress for the border
     var color_idx: u8 = 0;
···
 
     // Sends queries to terminal to detect certain features. This should always
     // be called after entering the alt screen, if you are using the alt screen
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
 
     while (true) {
         // nextEvent blocks until an event is in the queue
···
             // more than one byte will incur an allocation on the first render
             // after it is drawn. Thereafter, it will not allocate unless the
             // screen is resized
-            .winsize => |ws| try vx.resize(alloc, tty.anyWriter(), ws),
+            .winsize => |ws| try vx.resize(alloc, tty.writer(), ws),
             else => {},
         }
 
···
 
         // Render the screen. Using a buffered writer will offer much better
 	// performance, but is not required
-        try vx.render(tty.anyWriter());
+        try vx.render(tty.writer());
     }
 }
 ```

USAGE.md

···
                         self.vx.caps.color_scheme_updates = true;
                     },
                     .cap_da1 => {
-                        self.vx.enableDetectedFeatures(self.tty.anyWriter()) catch |err| {
+                        self.vx.enableDetectedFeatures(self.tty.writer()) catch |err| {
                             log.err("couldn't enable features: {}", .{err});
                         };
                     },
···
         }
 
         pub fn deinit(self: *@This(), vx: *vaxis.Vaxis, tty: *vaxis.Tty) void {
-            vx.deviceStatusReport(tty.anyWriter()) catch {};
+            vx.deviceStatusReport(tty.writer()) catch {};
             if (self.winsize_task) |task| task.cancel();
             if (self.reader_task) |task| task.cancel();
             self.source.deinit();

examples/cli.zig

···
     defer tty.deinit();
 
     var vx = try vaxis.init(alloc, .{});
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
     try loop.start();
     defer loop.stop();
 
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
 
     var text_input = TextInput.init(alloc, &vx.unicode);
     defer text_input.deinit();
···
                 }
             },
             .winsize => |ws| {
-                try vx.resize(alloc, tty.anyWriter(), ws);
+                try vx.resize(alloc, tty.writer(), ws);
             },
             else => {},
         }
···
                 _ = win.print(&seg, .{ .row_offset = @intCast(j + 1) });
             }
         }
-        try vx.render(tty.anyWriter());
+        try vx.render(tty.writer());
     }
 }
 

examples/image.zig

···
     defer tty.deinit();
 
     var vx = try vaxis.init(alloc, .{});
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
     try loop.start();
     defer loop.stop();
 
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
 
     var read_buffer: [1024 * 1024]u8 = undefined; // 1MB buffer
     var img1 = try vaxis.zigimg.Image.fromFilePath(alloc, "examples/zig.png", &read_buffer);
     defer img1.deinit();
 
     const imgs = [_]vaxis.Image{
-        try vx.transmitImage(alloc, tty.anyWriter(), &img1, .rgba),
+        try vx.transmitImage(alloc, tty.writer(), &img1, .rgba),
         // var img1 = try vaxis.zigimg.Image.fromFilePath(alloc, "examples/zig.png");
-        // try vx.loadImage(alloc, tty.anyWriter(), .{ .path = "examples/zig.png" }),
-        try vx.loadImage(alloc, tty.anyWriter(), .{ .path = "examples/vaxis.png" }),
+        // try vx.loadImage(alloc, tty.writer(), .{ .path = "examples/zig.png" }),
+        try vx.loadImage(alloc, tty.writer(), .{ .path = "examples/vaxis.png" }),
     };
-    defer vx.freeImage(tty.anyWriter(), imgs[0].id);
-    defer vx.freeImage(tty.anyWriter(), imgs[1].id);
+    defer vx.freeImage(tty.writer(), imgs[0].id);
+    defer vx.freeImage(tty.writer(), imgs[1].id);
 
     var n: usize = 0;
 
···
                 else if (key.matches('k', .{}))
                     clip_y -|= 1;
             },
-            .winsize => |ws| try vx.resize(alloc, tty.anyWriter(), ws),
+            .winsize => |ws| try vx.resize(alloc, tty.writer(), ws),
         }
 
         n = (n + 1) % imgs.len;
···
             .y = clip_y,
         } });
 
-        try vx.render(tty.anyWriter());
+        try vx.render(tty.writer());
     }
 }

examples/main.zig

···
     defer tty.deinit();
 
     var vx = try vaxis.init(alloc, .{});
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
     defer loop.stop();
 
     // Optionally enter the alternate screen
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
 
     // We'll adjust the color index every keypress
     var color_idx: u8 = 0;
···
                 }
             },
             .winsize => |ws| {
-                try vx.resize(alloc, tty.anyWriter(), ws);
+                try vx.resize(alloc, tty.writer(), ws);
             },
             else => {},
         }
···
             child.writeCell(@intCast(i), scale, second_cell);
         }
         // Render the screen
-        try vx.render(tty.anyWriter());
+        try vx.render(tty.writer());
     }
 }
 

examples/table.zig

···
     var buffer: [1024]u8 = undefined;
     var tty = try vaxis.Tty.init(&buffer);
     defer tty.deinit();
-    const tty_writer = tty.anyWriter();
+    const tty_writer = tty.writer();
     var vx = try vaxis.init(alloc, .{
         .kitty_keyboard_flags = .{ .report_events = true },
     });
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(union(enum) {
         key_press: vaxis.Key,
···
     try loop.init();
     try loop.start();
     defer loop.stop();
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 250 * std.time.ns_per_ms);
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 250 * std.time.ns_per_ms);
 
     const logo =
         \\░█░█░█▀█░█░█░▀█▀░█▀▀░░░▀█▀░█▀█░█▀▄░█░░░█▀▀░
···
                 }
                 moving = false;
             },
-            .winsize => |ws| try vx.resize(alloc, tty.anyWriter(), ws),
+            .winsize => |ws| try vx.resize(alloc, tty.writer(), ws),
             else => {},
         }
 

examples/text_input.zig

···
 
     // Use a buffered writer for better performance. There are a lot of writes
     // in the render loop and this can have a significant savings
-    const writer = tty.anyWriter();
+    const writer = tty.writer();
 
     // Initialize Vaxis
     var vx = try vaxis.init(alloc, .{
         .kitty_keyboard_flags = .{ .report_events = true },
     });
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{
         .vaxis = &vx,
···
     try writer.flush();
     // Sends queries to terminal to detect certain features. This should
     // _always_ be called, but is left to the application to decide when
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
 
     // The main event loop. Vaxis provides a thread safe, blocking, buffered
     // queue which can serve as the primary event queue for an application
···
                 } else if (key.matches('l', .{ .ctrl = true })) {
                     vx.queueRefresh();
                 } else if (key.matches('n', .{ .ctrl = true })) {
-                    try vx.notify(tty.anyWriter(), "vaxis", "hello from vaxis");
+                    try vx.notify(tty.writer(), "vaxis", "hello from vaxis");
                     loop.stop();
                     var child = std.process.Child.init(&.{"nvim"}, alloc);
                     _ = try child.spawnAndWait();
                     try loop.start();
-                    try vx.enterAltScreen(tty.anyWriter());
+                    try vx.enterAltScreen(tty.writer());
                     vx.queueRefresh();
                 } else if (key.matches(vaxis.Key.enter, .{}) or key.matches('j', .{ .ctrl = true })) {
                     text_input.clearAndFree();
···
             // more than one byte will incur an allocation on the first render
             // after it is drawn. Thereafter, it will not allocate unless the
             // screen is resized
-            .winsize => |ws| try vx.resize(alloc, tty.anyWriter(), ws),
+            .winsize => |ws| try vx.resize(alloc, tty.writer(), ws),
             else => {},
         }
 

examples/vaxis.zig

···
     defer tty.deinit();
 
     var vx = try vaxis.init(alloc, .{});
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
     try loop.start();
     defer loop.stop();
 
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
 
-    try vx.queryColor(tty.anyWriter(), .fg);
-    try vx.queryColor(tty.anyWriter(), .bg);
+    try vx.queryColor(tty.writer(), .fg);
+    try vx.queryColor(tty.writer(), .bg);
     var pct: u8 = 0;
     var dir: enum {
         up,
···
         switch (event) {
             .key_press => |key| if (key.matches('c', .{ .ctrl = true })) return,
             .winsize => |ws| {
-                try vx.resize(alloc, tty.anyWriter(), ws);
+                try vx.resize(alloc, tty.writer(), ws);
                 break;
             },
         }
···
         while (loop.tryEvent()) |event| {
             switch (event) {
                 .key_press => |key| if (key.matches('c', .{ .ctrl = true })) return,
-                .winsize => |ws| try vx.resize(alloc, tty.anyWriter(), ws),
+                .winsize => |ws| try vx.resize(alloc, tty.writer(), ws),
             }
         }
 
···
         // var bw = tty.bufferedWriter();
         // try vx.render(bw.writer().any());
         // try bw.flush();
-        try vx.render(tty.anyWriter());
+        try vx.render(tty.writer());
         std.Thread.sleep(16 * std.time.ns_per_ms);
         switch (dir) {
             .up => {

examples/view.zig

···
     var tty = try vaxis.Tty.init(&buffer);
     defer tty.deinit();
 
-    const writer = tty.anyWriter();
+    const writer = tty.writer();
 
     // Initialize Vaxis
     var vx = try vaxis.init(alloc, .{
         .kitty_keyboard_flags = .{ .report_events = true },
     });
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
     var loop: vaxis.Loop(Event) = .{
         .vaxis = &vx,
         .tty = &tty,
···
     defer loop.stop();
     try vx.enterAltScreen(writer);
     try writer.flush();
-    try vx.queryTerminal(tty.anyWriter(), 20 * std.time.ns_per_s);
+    try vx.queryTerminal(tty.writer(), 20 * std.time.ns_per_s);
 
     // Initialize Views
     // - Large Map
···
                 // Mini View (Forced Width & Height Limits)
                 if (key.matches('m', .{})) use_mini_view = !use_mini_view;
             },
-            .winsize => |ws| try vx.resize(alloc, tty.anyWriter(), ws),
+            .winsize => |ws| try vx.resize(alloc, tty.writer(), ws),
         }
 
         const win = vx.window();

examples/vt.zig

···
     var buffer: [1024]u8 = undefined;
     var tty = try vaxis.Tty.init(&buffer);
     var vx = try vaxis.init(alloc, .{});
-    defer vx.deinit(alloc, tty.anyWriter());
+    defer vx.deinit(alloc, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
 
     var buffered = tty.bufferedWriter();
 
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
     var env = try std.process.getEnvMap(alloc);
     defer env.deinit();
 
···
                     try vt.update(.{ .key_press = key });
                 },
                 .winsize => |ws| {
-                    try vx.resize(alloc, tty.anyWriter(), ws);
+                    try vx.resize(alloc, tty.writer(), ws);
                 },
             }
         }

src/Loop.zig

···
             if (self.thread == null) return;
             self.should_quit = true;
             // trigger a read
-            self.vaxis.deviceStatusReport(self.tty.anyWriter()) catch {};
+            self.vaxis.deviceStatusReport(self.tty.writer()) catch {};
 
             if (self.thread) |thread| {
                 thread.join();
···
     defer tty.deinit();
 
     var vx = try vaxis.init(std.testing.allocator, .{});
-    defer vx.deinit(std.testing.allocator, tty.anyWriter());
+    defer vx.deinit(std.testing.allocator, tty.writer());
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
     defer loop.stop();
 
     // Optionally enter the alternate screen
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_ms);
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_ms);
 }

src/main.zig

···
             ctlseqs.bp_reset ++
             ctlseqs.rmcup;
 
-        gty.anyWriter().writeAll(reset) catch {};
+        gty.writer().writeAll(reset) catch {};
 
         gty.deinit();
     }

src/tty.zig

···
     reader: std.fs.File.Reader,
 
     /// File.Writer for efficient buffered writing
-    writer: std.fs.File.Writer,
+    tty_writer: std.fs.File.Writer,
 
     pub const SignalHandler = struct {
         context: *anyopaque,
···
             .fd = fd,
             .termios = termios,
             .reader = file.reader(buffer),
-            .writer = .initStreaming(file, buffer),
+            .tty_writer = .initStreaming(file, buffer),
         };
 
         global_tty = self;
···
         posix.sigaction(posix.SIG.WINCH, &act, null);
     }
 
-    pub fn anyWriter(self: *PosixTty) *std.Io.Writer {
-        return &self.writer.interface;
+    pub fn writer(self: *PosixTty) *std.Io.Writer {
+        return &self.tty_writer.interface;
     }
 
     pub fn read(self: *const PosixTty, buf: []u8) !usize {
···
 
     /// File.Writer for efficient buffered writing
     reader: std.fs.File.Writer,
-    writer: std.fs.File.Writer,
+    tty_writer: std.fs.File.Writer,
 
     /// The last mouse button that was pressed. We store the previous state of button presses on each
     /// mouse event so we can detect which button was released
···
         };
     }
 
-    pub fn anyWriter(self: *Tty) *std.Io.Writer {
-        return &self.writer.interface;
+    pub fn writer(self: *Tty) *std.Io.Writer {
+        return &self.tty_writer.interface;
     }
 
     pub fn read(self: *const Tty, buf: []u8) !usize {
···
     fd: posix.fd_t,
     pipe_read: posix.fd_t,
     pipe_write: posix.fd_t,
-    writer: *std.Io.Writer.Allocating,
+    tty_writer: *std.Io.Writer.Allocating,
 
     /// Initializes a TestTty.
     pub fn init(buffer: []u8) !TestTty {
···
             .fd = r,
             .pipe_read = r,
             .pipe_write = w,
-            .writer = list,
+            .tty_writer = list,
         };
     }
 
     pub fn deinit(self: TestTty) void {
         std.posix.close(self.pipe_read);
         std.posix.close(self.pipe_write);
-        self.writer.deinit();
-        std.testing.allocator.destroy(self.writer);
+        self.tty_writer.deinit();
+        std.testing.allocator.destroy(self.tty_writer);
     }
 
-    pub fn anyWriter(self: *TestTty) *std.Io.Writer {
-        return &self.writer.writer;
+    pub fn writer(self: *TestTty) *std.Io.Writer {
+        return &self.tty_writer.writer;
     }
 
     pub fn read(self: *const TestTty, buf: []u8) !usize {

src/vxfw/App.zig

···
 
 pub fn deinit(self: *App) void {
     self.timers.deinit(self.allocator);
-    self.vx.deinit(self.allocator, self.tty.anyWriter());
+    self.vx.deinit(self.allocator, self.tty.writer());
     self.tty.deinit();
 }
 
···
     // Also always initialize the app with a focus event
     loop.postEvent(.focus_in);
 
-    try vx.enterAltScreen(tty.anyWriter());
-    try vx.queryTerminal(tty.anyWriter(), 1 * std.time.ns_per_s);
-    try vx.setBracketedPaste(tty.anyWriter(), true);
-    try vx.subscribeToColorSchemeUpdates(tty.anyWriter());
+    try vx.enterAltScreen(tty.writer());
+    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
+    try vx.setBracketedPaste(tty.writer(), true);
+    try vx.subscribeToColorSchemeUpdates(tty.writer());
 
     {
         // This part deserves a comment. loop.init installs a signal handler for the tty. We wait to
···
 
     // NOTE: We don't use pixel mouse anywhere
     vx.caps.sgr_pixels = false;
-    try vx.setMouseMode(tty.anyWriter(), true);
+    try vx.setMouseMode(tty.writer(), true);
 
     // Give DrawContext the unicode data
     vxfw.DrawContext.init(&vx.unicode, vx.screen.width_method);
···
                     },
                     .mouse => |mouse| try mouse_handler.handleMouse(self, &ctx, mouse),
                     .winsize => |ws| {
-                        try vx.resize(self.allocator, tty.anyWriter(), ws);
+                        try vx.resize(self.allocator, tty.writer(), ws);
                         ctx.redraw = true;
                     },
                     else => {
···
     });
     surface.render(root_win, focused_widget);
 
-    try vx.render(tty.anyWriter());
+    try vx.render(tty.writer());
 }
 
 fn addTick(self: *App, tick: vxfw.Tick) Allocator.Error!void {
···
             .set_mouse_shape => |shape| self.vx.setMouseShape(shape),
             .request_focus => |widget| self.wants_focus = widget,
             .copy_to_clipboard => |content| {
-                self.vx.copyToSystemClipboard(self.tty.anyWriter(), content, self.allocator) catch |err| {
+                self.vx.copyToSystemClipboard(self.tty.writer(), content, self.allocator) catch |err| {
                     switch (err) {
                         error.OutOfMemory => return Allocator.Error.OutOfMemory,
                         else => std.log.err("copy error: {}", .{err}),
···
                 };
             },
             .set_title => |title| {
-                self.vx.setTitle(self.tty.anyWriter(), title) catch |err| {
+                self.vx.setTitle(self.tty.writer(), title) catch |err| {
                     std.log.err("set_title error: {}", .{err});
                 };
             },
             .queue_refresh => self.vx.queueRefresh(),
             .notify => |notification| {
-                self.vx.notify(self.tty.anyWriter(), notification.title, notification.body) catch |err| {
+                self.vx.notify(self.tty.writer(), notification.title, notification.body) catch |err| {
                     std.log.err("notify error: {}", .{err});
                 };
                 const alloc = self.allocator;
···
                 alloc.free(notification.body);
             },
             .query_color => |kind| {
-                self.vx.queryColor(self.tty.anyWriter(), kind) catch |err| {
+                self.vx.queryColor(self.tty.writer(), kind) catch |err| {
                     std.log.err("queryColor error: {}", .{err});
                 };
             },

src/widgets/terminal/Terminal.zig

···
 
 pub fn update(self: *Terminal, event: InputEvent) !void {
     switch (event) {
-        .key_press => |k| try key.encode(self.anyWriter(), k, true, self.back_screen.csi_u_flags),
+        .key_press => |k| try key.encode(self.writer(), k, true, self.back_screen.csi_u_flags),
     }
 }
 
···
     return posix.write(self.pty.pty, buf);
 }
 
-pub fn anyWriter(self: *const Terminal) *std.io.Writer {
-    const writer: std.io.Writer = .{
-        .context = self,
-        .writeFn = Terminal.opaqueWrite,
+pub fn writer(self: *const Terminal) *std.io.Writer {
+    const local = struct {
+        var writer: std.io.Writer = .{
+            .context = self,
+            .writeFn = Terminal.opaqueWrite,
+        };
     };
-    return @constCast(&writer);
+    return &local.writer;
 }
 
 fn opaqueRead(ptr: *const anyopaque, buf: []u8) !usize {
···
                         if (seq.private_marker) |pm| {
                             switch (pm) {
                                 // Secondary
-                                '>' => try self.anyWriter().writeAll("\x1B[>1;69;0c"),
-                                '=' => try self.anyWriter().writeAll("\x1B[=0000c"),
+                                '>' => try self.writer().writeAll("\x1B[>1;69;0c"),
+                                '=' => try self.writer().writeAll("\x1B[=0000c"),
                                 else => log.info("unhandled CSI: {}", .{seq}),
                             }
                         } else {
                             // Primary
-                            try self.anyWriter().writeAll("\x1B[?62;22c");
+                            try self.writer().writeAll("\x1B[?62;22c");
                         }
                     },
                     // Cursor Vertical Position Absolute
···
                         const ps = iter.next() orelse 0;
                         if (seq.intermediate == null and seq.private_marker == null) {
                             switch (ps) {
-                                5 => try self.anyWriter().writeAll("\x1b[0n"),
-                                6 => try self.anyWriter().print("\x1b[{d};{d}R", .{
+                                5 => try self.writer().writeAll("\x1b[0n"),
+                                6 => try self.writer().print("\x1b[{d};{d}R", .{
                                     self.back_screen.cursor.row + 1,
                                     self.back_screen.cursor.col + 1,
                                 }),
···
                                 // report mode
                                 '$' => {
                                     switch (ps) {
-                                        2026 => try self.anyWriter().writeAll("\x1b[?2026;2$p"),
+                                        2026 => try self.writer().writeAll("\x1b[?2026;2$p"),
                                         else => {
                                             std.log.warn("unhandled mode: {}", .{ps});
-                                            try self.anyWriter().print("\x1b[?{d};0$p", .{ps});
+                                            try self.writer().print("\x1b[?{d};0$p", .{ps});
                                         },
                                     }
                                 },
···
                         if (seq.private_marker) |pm| {
                             switch (pm) {
                                 // XTVERSION
-                                '>' => try self.anyWriter().print(
+                                '>' => try self.writer().print(
                                     "\x1bP>|libvaxis {s}\x1B\\",
                                     .{"dev"},
                                 ),