diff --git a/src/keybind/keybind.zig b/src/keybind/keybind.zig
index 0143f97..d22c9fb 100644
--- a/src/keybind/keybind.zig
+++ b/src/keybind/keybind.zig
@@ -25,7 +25,6 @@ const builtin_keybinds = std.StaticStringMap([]const u8).initComptime(.{
 });
 
 pub var enable_match_events: bool = false;
-pub var enable_insert_events: bool = false;
 var integer_argument: ?usize = null;
 var mode_flag: KeybindMode = .normal;
 
@@ -648,8 +647,6 @@ const BindingSet = struct {
                 globals.insert_command = self.insert_command;
                 globals.insert_command_id = null;
             }
-            if (enable_insert_events)
-                self.send_insert_event(globals.insert_command, globals.input_buffer.items);
             const id = globals.insert_command_id orelse
                 command.get_id_cache(globals.insert_command, &globals.insert_command_id) orelse {
                 return tp.exit_error(error.InputTargetNotFound, null);
@@ -678,16 +675,7 @@ const BindingSet = struct {
             const key_event = input.KeyEvent.from_message(event, keypress, keypress_shifted, text, modifiers);
             if (self.process_key_event(key_event) catch |e| return tp.exit_error(e, @errorReturnTrace())) |binding| {
                 if (enable_match_events)
-                    self.send_match_event(if (key_event.event != input.event.release)
-                        globals.current_sequence.items
-                    else
-                        &[_]KeyEvent{key_event}, binding.commands);
-
-                if (key_event.event != input.event.release) {
-                    globals.current_sequence.clearRetainingCapacity();
-                    globals.current_sequence_egc.clearRetainingCapacity();
-                }
-
+                    self.send_match_event(key_event, binding);
                 for (binding.commands) |*cmd| try cmd.execute();
             }
         } else if (try m.match(.{"F"})) {
@@ -739,7 +727,11 @@ const BindingSet = struct {
 
         for (self.press.items) |*binding| {
             switch (binding.match(globals.current_sequence.items)) {
-                .matched => return binding,
+                .matched => {
+                    globals.current_sequence.clearRetainingCapacity();
+                    globals.current_sequence_egc.clearRetainingCapacity();
+                    return binding;
+                },
                 .match_possible => {
                     all_matches_impossible = false;
                 },
@@ -782,21 +774,21 @@ const BindingSet = struct {
         }
     }
 
-    fn send_match_event(self: *const @This(), key_events: []const KeyEvent, cmds: []Command) void {
+    fn send_match_event(self: *const @This(), key_event: KeyEvent, binding: *const Binding) void {
         var buf: [tp.max_message_size]u8 = undefined;
         var stream: std.Io.Writer = .fixed(&buf);
 
         var key_event_buf: [256]u8 = undefined;
         var key_event_str: std.Io.Writer = .fixed(&key_event_buf);
-        key_event_str.print("{f}", .{key_event_sequence_long_fmt(key_events)}) catch return;
+        key_event_str.print("{f}", .{key_event}) catch return;
 
         cbor.writeArrayHeader(&stream, 5) catch return;
         cbor.writeValue(&stream, "K") catch return;
         cbor.writeValue(&stream, get_namespace()) catch return;
         cbor.writeValue(&stream, self.config_section) catch return;
         cbor.writeValue(&stream, key_event_str.buffered()) catch return;
-        cbor.writeArrayHeader(&stream, cmds.len) catch return;
-        for (cmds) |cmd| {
+        cbor.writeArrayHeader(&stream, binding.commands.len) catch return;
+        for (binding.commands) |cmd| {
             cbor.writeArrayHeader(&stream, 2) catch return;
             cbor.writeValue(&stream, cmd.command) catch return;
             stream.writeAll(cmd.args) catch return;
@@ -804,10 +796,6 @@ const BindingSet = struct {
         _ = tp.self_pid().send_raw(.{ .buf = stream.buffered() }) catch {};
     }
 
-    fn send_insert_event(self: *const @This(), insert_cmd: []const u8, bytes: []const u8) void {
-        _ = tp.self_pid().send(.{ "N", get_namespace(), self.config_section, insert_cmd, bytes }) catch {};
-    }
-
     fn log_keyhints_message() void {
         for (globals.current_sequence.items) |item| switch (item.key) {
             input.key.left_control, input.key.right_control => return,
@@ -933,42 +921,14 @@ const KeyEventSequenceFmt = struct {
     }
 };
 
-const KeyEventSequenceLongFmt = struct {
-    key_events: []const KeyEvent,
-
-    pub fn format(self: @This(), writer: anytype) !void {
-        var first = true;
-        for (self.key_events) |key_event| {
-            if (first) {
-                first = false;
-            } else {
-                try writer.print(" ", .{});
-            }
-            if (key_event.event == input.event.press) {
-                try writer.print("{f}", .{input.key_event_short_fmt(key_event)});
-            } else {
-                try writer.print("{f}:{f}", .{ input.event_fmt(key_event.event), input.key_event_short_fmt(key_event) });
-            }
-        }
-    }
-};
-
 pub fn key_event_sequence_fmt(key_events: []const KeyEvent) KeyEventSequenceFmt {
     return .{ .key_events = key_events };
 }
 
-pub fn key_event_sequence_long_fmt(key_events: []const KeyEvent) KeyEventSequenceLongFmt {
-    return .{ .key_events = key_events };
-}
-
 pub fn current_key_event_sequence_fmt() KeyEventSequenceFmt {
     return .{ .key_events = globals.current_sequence.items };
 }
 
-pub fn current_key_event_sequence_long_fmt() KeyEventSequenceLongFmt {
-    return .{ .key_events = globals.current_sequence.items };
-}
-
 pub fn current_integer_argument() ?usize {
     return integer_argument;
 }
diff --git a/src/renderer/vaxis/input.zig b/src/renderer/vaxis/input.zig
index 48f8dc2..44f79a2 100644
--- a/src/renderer/vaxis/input.zig
+++ b/src/renderer/vaxis/input.zig
@@ -349,7 +349,7 @@ pub fn event_fmt(evt: Event) struct {
             event.press => writer.writeAll("press"),
             event.repeat => writer.writeAll("repeat"),
             event.release => writer.writeAll("release"),
-            else => writer.print("unknown({d})", .{self.event}),
+            else => {},
         };
     }
 } {
@@ -363,7 +363,7 @@ pub fn event_short_fmt(evt: Event) struct {
             event.press => writer.writeAll("P"),
             event.repeat => writer.writeAll("RP"),
             event.release => writer.writeAll("R"),
-            else => writer.print("U({d})", .{self.event}),
+            else => {},
         };
     }
 } {
diff --git a/src/tui/keybindview.zig b/src/tui/keybindview.zig
index fe5a875..4e2f532 100644
--- a/src/tui/keybindview.zig
+++ b/src/tui/keybindview.zig
@@ -3,7 +3,6 @@ const time = @import("std").time;
 const Allocator = @import("std").mem.Allocator;
 const ArrayList = @import("std").ArrayList;
 const Writer = @import("std").Io.Writer;
-const hexEscape = @import("std").ascii.hexEscape;
 
 const tp = @import("thespian");
 const cbor = @import("cbor");
@@ -90,37 +89,23 @@ fn keybind_match(self: *Self, _: tp.pid_ref, m: tp.message) MessageFilter.Error!
     var section: []const u8 = undefined;
     var key_event: []const u8 = undefined;
     var cmds: []const u8 = undefined;
-    var insert_cmd: []const u8 = undefined;
-    var bytes: []const u8 = undefined;
+    if (!(m.match(.{ "K", tp.extract(&namespace), tp.extract(&section), tp.extract(&key_event), tp.extract_cbor(&cmds) }) catch false)) return false;
 
-    if (m.match(.{ "K", tp.extract(&namespace), tp.extract(&section), tp.extract(&key_event), tp.extract_cbor(&cmds) }) catch false) {
-        var result: Writer.Allocating = .init(self.allocator);
-        defer result.deinit();
-        const writer = &result.writer;
+    var result: Writer.Allocating = .init(self.allocator);
+    defer result.deinit();
+    const writer = &result.writer;
 
-        writer.print("{s}:{s} {s} => ", .{ namespace, section, key_event }) catch return true;
-        cbor.toJsonWriter(cmds, writer, .{}) catch return true;
+    writer.print("{s}:{s} {s} -> ", .{ namespace, section, key_event }) catch return true;
+    cbor.toJsonWriter(cmds, writer, .{}) catch return true;
 
-        self.append(result.toOwnedSlice() catch return true);
-        return true;
-    } else if (m.match(.{ "N", tp.extract(&namespace), tp.extract(&section), tp.extract(&insert_cmd), tp.extract(&bytes) }) catch false) {
-        var result: Writer.Allocating = .init(self.allocator);
-        defer result.deinit();
-        result.writer.print("{s}:{s} insert => [\"{s}\", \"{f}\"] ", .{ namespace, section, insert_cmd, hexEscape(bytes, .lower) }) catch return true;
-        self.append(result.toOwnedSlice() catch return true);
-        return true;
-    }
-    return false;
-}
-
-pub fn append(self: *Self, msg: []const u8) void {
     const ts = time.microTimestamp();
     const tdiff = if (self.buffer.items.len > 0) ts -| self.buffer.items[self.buffer.items.len - 1].time else 0;
-    (self.buffer.addOne(self.allocator) catch return).* = .{
+    (try self.buffer.addOne(self.allocator)).* = .{
         .time = ts,
         .tdiff = tdiff,
-        .msg = msg,
+        .msg = result.toOwnedSlice() catch return true,
     };
+    return true;
 }
 
 pub fn receive(_: *Self, _: tp.pid_ref, _: tp.message) error{Exit}!bool {
diff --git a/src/tui/tui.zig b/src/tui/tui.zig
index 60c75c2..b23d803 100644
--- a/src/tui/tui.zig
+++ b/src/tui/tui.zig
@@ -503,9 +503,6 @@ fn receive_safe(self: *Self, from: tp.pid_ref, m: tp.message) !void {
     if (try m.match(.{ "K", tp.more }))
         return;
 
-    if (try m.match(.{ "N", tp.more }))
-        return;
-
     if (try self.send_widgets(from, m))
         return;
 
@@ -2366,10 +2363,8 @@ pub fn set_last_palette(type_: PaletteType, ctx: command.Context) void {
 
 pub fn enable_match_events() void {
     keybind.enable_match_events = true;
-    keybind.enable_insert_events = true;
 }
 
 pub fn disable_match_events() void {
     keybind.enable_match_events = false;
-    keybind.enable_insert_events = false;
 }