chore: upgrade libghostty and preserve terminal behavior (#3906)

1 files changed, 78 insertions, 22 deletions

diff --git a/vendor/libghostty-vt/src/apprt/ipc.zig b/vendor/libghostty-vt/src/apprt/ipc.zig
index dda794ae..d5d860a7 100644
--- a/vendor/libghostty-vt/src/apprt/ipc.zig
+++ b/vendor/libghostty-vt/src/apprt/ipc.zig
@@ -70,23 +70,82 @@ pub const Action = union(enum) {
     //    entry. If the value type is void then only the key needs to be
     //    added. Ensure the order matches exactly with the Zig code.
 
-    /// The arguments to pass to Ghostty as the command.
+    /// Create a new window.
     new_window: NewWindow,
 
+    /// Create a new tab.
+    new_tab: NewTab,
+
     /// Toggle the quick terminal.
     toggle_quick_terminal: void,
 
     pub const NewWindow = struct {
-        /// A list of command arguments to launch in the new window. If this is
-        /// `null` the command configured in the config or the user's default
-        /// shell should be launched.
+        /// A list of configuration entries that will override the configuration
+        /// of the first surface of the new window. If this is `null` there
+        /// are no overrides. Note that not all configuration entries may be
+        /// overridden.
         ///
         /// It is an error for this to be non-`null`, but zero length.
         arguments: ?[][:0]const u8,
 
         pub const C = extern struct {
-            /// null terminated list of arguments
-            /// it will be null itself if there are no arguments
+            /// A list of configuration entries that will override the
+            /// configuration of the first surface of the new tab. If this is
+            /// `null` there are no overrides. Note that not all configuration
+            /// entries may be overridden.
+            ///
+            /// It is an error for this to be non-`null`, but zero length.
+            arguments: ?[*]?[*:0]const u8,
+
+            pub fn deinit(self: *NewWindow.C, alloc: Allocator) void {
+                if (self.arguments) |arguments| alloc.free(arguments);
+            }
+        };
+
+        pub fn cval(self: *NewWindow, alloc: Allocator) Allocator.Error!NewWindow.C {
+            var result: NewWindow.C = undefined;
+
+            if (self.arguments) |arguments| {
+                result.arguments = try alloc.alloc([*:0]const u8, arguments.len + 1);
+
+                for (arguments, 0..) |argument, i|
+                    result.arguments[i] = argument.ptr;
+
+                // add null terminator
+                result.arguments[arguments.len] = null;
+            } else {
+                result.arguments = null;
+            }
+
+            return result;
+        }
+    };
+
+    pub const NewTab = struct {
+        /// The unique ID of a surface. If the ID is zero the currently focused
+        /// surface is assumed. This will be used to identify the window to add
+        /// the tab to.
+        surface_id: u64,
+
+        /// A list of configuration entries that will override the configuration
+        /// of the first surface of the new tab. If this is `null` there
+        /// are no overrides. Note that not all configuration entries may be
+        /// overridden.
+        ///
+        /// It is an error for this to be non-`null`, but zero length.
+        arguments: ?[][:0]const u8,
+
+        pub const C = extern struct {
+            /// The unique ID of a surface. If the ID is zero the currently
+            /// focused surface is assumed. This will be used to identify the
+            /// window to add the tab to.
+            surface_id: u64,
+            /// A list of configuration entries that will override the
+            /// configuration of the first surface of the new tab. If this is
+            /// `null` there are no overrides. Note that not all configuration
+            /// entries may be overridden.
+            ///
+            /// It is an error for this to be non-`null`, but zero length.
             arguments: ?[*]?[*:0]const u8,
 
             pub fn deinit(self: *NewWindow.C, alloc: Allocator) void {
@@ -116,6 +175,7 @@ pub const Action = union(enum) {
     /// Sync with: ghostty_ipc_action_tag_e
     pub const Key = enum(c_int) {
         new_window,
+        new_tab,
         toggle_quick_terminal,
 
         test "ghostty.h Action.Key" {
@@ -126,8 +186,12 @@ pub const Action = union(enum) {
     /// Sync with: ghostty_ipc_action_u
     pub const CValue = cvalue: {
         const key_fields = @typeInfo(Key).@"enum".fields;
-        var union_fields: [key_fields.len]std.builtin.Type.UnionField = undefined;
-        for (key_fields, 0..) |field, i| {
+
+        var names: [key_fields.len][]const u8 = undefined;
+        var types: [key_fields.len]type = undefined;
+        var attrs: [key_fields.len]std.builtin.Type.UnionField.Attributes = undefined;
+
+        for (key_fields, &names, &types, &attrs) |field, *name, *ty, *attr| {
             const action = @unionInit(Action, field.name, undefined);
             const Type = t: {
                 const Type = @TypeOf(@field(action, field.name));
@@ -135,20 +199,12 @@ pub const Action = union(enum) {
                 if (Type != void and @hasDecl(Type, "C")) break :t Type.C;
                 break :t Type;
             };
-
-            union_fields[i] = .{
-                .name = field.name,
-                .type = Type,
-                .alignment = @alignOf(Type),
-            };
+            name.* = field.name;
+            ty.* = Type;
+            attr.* = .{ .@"align" = @alignOf(Type) };
         }
 
-        break :cvalue @Type(.{ .@"union" = .{
-            .layout = .@"extern",
-            .tag_type = null,
-            .fields = &union_fields,
-            .decls = &.{},
-        } });
+        break :cvalue @Union(.@"extern", null, &names, &types, &attrs);
     };
 
     /// Sync with: ghostty_ipc_action_s
@@ -162,8 +218,8 @@ pub const Action = union(enum) {
         // At the time of writing, we don't promise ABI compatibility
         // so we can change this but I want to be aware of it.
         assert(@sizeOf(CValue) == switch (@sizeOf(usize)) {
-            4 => 4,
-            8 => 8,
+            4 => 12,
+            8 => 16,
             else => unreachable,
         });
     }