fix: don't forget to flush the Terminal writer

examples/vt.zig

···
 
     var buffer: [1024]u8 = undefined;
     var tty = try vaxis.Tty.init(&buffer);
+    const writer = tty.writer();
     var vx = try vaxis.init(alloc, .{});
-    defer vx.deinit(alloc, tty.writer());
+    defer vx.deinit(alloc, writer);
 
     var loop: vaxis.Loop(Event) = .{ .tty = &tty, .vaxis = &vx };
     try loop.init();
···
     try loop.start();
     defer loop.stop();
 
-    try vx.enterAltScreen(tty.writer());
-    try vx.queryTerminal(tty.writer(), 1 * std.time.ns_per_s);
+    try vx.enterAltScreen(writer);
+    try vx.queryTerminal(writer, 1 * std.time.ns_per_s);
     var env = try std.process.getEnvMap(alloc);
     defer env.deinit();
 
···
                     if (key.matches('c', .{ .ctrl = true })) return;
                     try vt.update(.{ .key_press = key });
                 },
-                .winsize => |ws| {
-                    try vx.resize(alloc, tty.writer(), ws);
-                },
+                .winsize => |ws| try vx.resize(alloc, writer, ws),
             }
         }
         if (!redraw) continue;
···
         const child = win.child(.{
             .x_off = 4,
             .y_off = 2,
-            .width = 8,
-            .height = 6,
+            .width = 120,
+            .height = 40,
             .border = .{
                 .where = .all,
             },
···
         });
         try vt.draw(alloc, child);
 
-        try vx.render(tty.writer());
-        try tty.writer().flush();
+        try vx.render(writer);
     }
 }

src/widgets/terminal/Terminal.zig

···
 
 pub fn update(self: *Terminal, event: InputEvent) !void {
     switch (event) {
-        .key_press => |k| try key.encode(self.writer(), k, true, self.back_screen.csi_u_flags),
+        .key_press => |k| {
+            const pty_writer = self.get_pty_writer();
+            defer pty_writer.flush() catch {};
+            try key.encode(pty_writer, k, true, self.back_screen.csi_u_flags);
+        },
     }
 }
 
-pub fn writer(self: *Terminal) *std.Io.Writer {
+pub fn get_pty_writer(self: *Terminal) *std.Io.Writer {
     return &self.pty_writer.interface;
 }
 
···
                     },
                     // Device Attributes
                     'c' => {
+                        const pty_writer = self.get_pty_writer();
+                        defer pty_writer.flush() catch {};
                         if (seq.private_marker) |pm| {
                             switch (pm) {
                                 // Secondary
-                                '>' => try self.writer().writeAll("\x1B[>1;69;0c"),
-                                '=' => try self.writer().writeAll("\x1B[=0000c"),
+                                '>' => try pty_writer.writeAll("\x1B[>1;69;0c"),
+                                '=' => try pty_writer.writeAll("\x1B[=0000c"),
                                 else => log.info("unhandled CSI: {f}", .{seq}),
                             }
                         } else {
                             // Primary
-                            try self.writer().writeAll("\x1B[?62;22c");
+                            try pty_writer.writeAll("\x1B[?62;22c");
                         }
                     },
                     // Cursor Vertical Position Absolute
···
                         var iter = seq.iterator(u16);
                         const ps = iter.next() orelse 0;
                         if (seq.intermediate == null and seq.private_marker == null) {
+                            const pty_writer = self.get_pty_writer();
+                            defer pty_writer.flush() catch {};
                             switch (ps) {
-                                5 => try self.writer().writeAll("\x1b[0n"),
-                                6 => try self.writer().print("\x1b[{d};{d}R", .{
+                                5 => try pty_writer.writeAll("\x1b[0n"),
+                                6 => try pty_writer.print("\x1b[{d};{d}R", .{
                                     self.back_screen.cursor.row + 1,
                                     self.back_screen.cursor.col + 1,
                                 }),
···
                             switch (int) {
                                 // report mode
                                 '$' => {
+                                    const pty_writer = self.get_pty_writer();
+                                    defer pty_writer.flush() catch {};
                                     switch (ps) {
-                                        2026 => try self.writer().writeAll("\x1b[?2026;2$p"),
+                                        2026 => try pty_writer.writeAll("\x1b[?2026;2$p"),
                                         else => {
                                             std.log.warn("unhandled mode: {}", .{ps});
-                                            try self.writer().print("\x1b[?{d};0$p", .{ps});
+                                            try pty_writer.print("\x1b[?{d};0$p", .{ps});
                                         },
                                     }
                                 },
···
                             }
                         }
                         if (seq.private_marker) |pm| {
+                            const pty_writer = self.get_pty_writer();
+                            defer pty_writer.flush() catch {};
                             switch (pm) {
                                 // XTVERSION
-                                '>' => try self.writer().print(
+                                '>' => try pty_writer.print(
                                     "\x1bP>|libvaxis {s}\x1B\\",
                                     .{"dev"},
                                 ),