fix: update zigimg + libvaxis to fix image segfault during image processing

build.zig.zon

···
     .name = .jido,
     .fingerprint = 0xee45eabe36cafb57,
     .version = "1.3.0",
-    .minimum_zig_version = "0.14.0",
+    .minimum_zig_version = "0.15.2",
 
     .dependencies = .{
+        // Replace with rockorager/libvaxis once https://github.com/rockorager/libvaxis/pull/293 is merged
         .vaxis = .{
-            .url = "git+https://github.com/rockorager/libvaxis.git#75035b169e91a51c233f3742161f8eb8eafca659",
-            .hash = "vaxis-0.5.1-BWNV_IE-CQBYmSf_boEKUyv6den0Gmj5LksxvdCx2pBL",
+            .url = "git+https://github.com/rob9315/libvaxis.git#8d04cffd9137b4a8c56b356de98b32023ae752f3",
+            .hash = "vaxis-0.5.1-BWNV_OA-CQDeFBHIx9ryyASogr2GE3FsAm-l5Ii5-HZT",
         },
         .fuzzig = .{
             .url = "git+https://github.com/fjebaker/fuzzig#4251fe4230d38e721514394a485db62ee1667ff3",
···
         .zuid = .{
             .url = "https://github.com/BrookJeynes/zuid/archive/refs/heads/bj/2025-12-31/feat/0.15.1.tar.gz",
             .hash = "zuid-3.0.0-l7aPyUlXAAAk9BLSDm2roA3i78Sy6_GvQI4hwe0PHI_m",
+        },
+        // Replace with zigimg/zigimg once https://github.com/zigimg/zigimg/pull/305 is merged
+        .zigimg = .{
+            .url = "git+https://github.com/brookjeynes/zigimg.git#9714df09f76891323c7fdbbbf23a17b79024fffb",
+            .hash = "zigimg-0.1.0-8_eo2j4mFwCU7tWnqvkYtzqe-OPRn_bxEql_IJhW85LT",
         },
     },
 

src/app.zig

···
 };
 
 pub const Image = struct {
+    const buf_size = (1024 * 1024) * 5; // 5mb
     const Status = enum {
         ready,
         processing,
+        failed,
     };
 
     ///Only use on first transmission. Subsequent draws should use
···
     path: ?[]const u8 = null,
     status: Status = .processing,
 
-    pub fn deinit(self: @This(), alloc: std.mem.Allocator) void {
+    pub fn deinit(self: @This(), alloc: std.mem.Allocator, vx: vaxis.Vaxis, tty: *vaxis.Tty) void {
+        if (self.image) |image| {
+            vx.freeImage(tty.writer(), image.id);
+        }
         if (self.data) |data| {
             var d = data;
             d.deinit(alloc);
···
 
     var image_iter = self.images.cache.iterator();
     while (image_iter.next()) |img| {
-        img.value_ptr.deinit(self.alloc);
+        img.value_ptr.deinit(self.alloc, self.vx, &self.tty);
     }
     self.images.cache.deinit();
 }

src/drawer.zig

···
                         break :file;
                     }
 
+                    if (cache_entry.status == .failed) {
+                        _ = preview_win.print(&.{
+                            .{ .text = "Failed to process image." },
+                        }, .{});
+                        break :file;
+                    }
+
                     if (cache_entry.image) |img| {
                         img.draw(preview_win, .{ .scale = .contain }) catch |err| {
                             const message = try std.fmt.allocPrint(app.alloc, "Failed to draw image to screen - {}.", .{err});
···
                     } else {
                         if (cache_entry.data == null) {
                             const path = try app.alloc.dupe(u8, self.current_item_path);
-                            var buffer: [1024]u8 = undefined;
-                            processImage(app, path, &buffer) catch break :unsupported;
+                            processImage(app, path) catch {
+                                app.alloc.free(path);
+                                break :unsupported;
+                            };
+                            _ = preview_win.print(&.{
+                                .{ .text = "Image still processing." },
+                            }, .{});
+                            break :file;
                         }
 
                         if (app.vx.transmitImage(app.alloc, app.tty.writer(), &cache_entry.data.?, .rgba)) |img| {
···
                                 break :file;
                             };
                             cache_entry.image = img;
-                            cache_entry.data.?.deinit(app.alloc);
+                            if (cache_entry.data) |data| {
+                                var d = data;
+                                d.deinit(app.alloc);
+                            }
                             cache_entry.data = null;
                         } else |_| {
                             break :unsupported;
···
 
                     break :file;
                 } else {
+                    _ = preview_win.print(&.{
+                        .{ .text = "Processing image." },
+                    }, .{});
+
                     const path = try app.alloc.dupe(u8, self.current_item_path);
-                    var buffer: [1024]u8 = undefined;
-                    processImage(app, path, &buffer) catch break :unsupported;
+                    processImage(app, path) catch {
+                        app.alloc.free(path);
+                        break :unsupported;
+                    };
                 }
 
                 break :file;
···
     }, .{ .wrap = .word });
 }
 
-fn processImage(app: *App, path: []const u8, buffer: *[1024]u8) error{ Unsupported, OutOfMemory }!void {
+fn processImage(app: *App, path: []const u8) error{ Unsupported, OutOfMemory }!void {
     app.images.cache.put(path, .{ .path = path, .status = .processing }) catch {
         const message = try std.fmt.allocPrint(app.alloc, "Failed to load image '{s}' - error occurred while attempting to add image to cache.", .{path});
         defer app.alloc.free(message);
···
     const load_img_thread = std.Thread.spawn(.{}, loadImage, .{
         app,
         path,
-        buffer,
-    }) catch return error.Unsupported;
+    }) catch {
+        app.images.mutex.lock();
+        if (app.images.cache.getPtr(path)) |entry| {
+            entry.status = .failed;
+        }
+        app.images.mutex.unlock();
+
+        const message = try std.fmt.allocPrint(app.alloc, "Failed to load image '{s}' - error occurred while attempting to spawn processing thread.", .{path});
+        defer app.alloc.free(message);
+        app.notification.write(message, .err) catch {};
+        if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {};
+
+        return error.Unsupported;
+    };
     load_img_thread.detach();
 }
 
-fn loadImage(app: *App, path: []const u8, buffer: *[1024]u8) error{ Unsupported, OutOfMemory }!void {
-    const data = vaxis.zigimg.Image.fromFilePath(app.alloc, path, buffer) catch {
+fn loadImage(app: *App, path: []const u8) error{OutOfMemory}!void {
+    var buf: [(1024 * 1024) * 5]u8 = undefined;
+    const data = vaxis.zigimg.Image.fromFilePath(app.alloc, path, &buf) catch {
+        app.images.mutex.lock();
+        if (app.images.cache.getPtr(path)) |entry| {
+            entry.status = .failed;
+        }
+        app.images.mutex.unlock();
+
         const message = try std.fmt.allocPrint(app.alloc, "Failed to load image '{s}' - error occurred while attempting to read image from path.", .{path});
         defer app.alloc.free(message);
         app.notification.write(message, .err) catch {};
         if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {};
-        return error.Unsupported;
+
+        return;
     };
 
     app.images.mutex.lock();
···
         defer app.alloc.free(message);
         app.notification.write(message, .err) catch {};
         if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {};
-        return error.Unsupported;
+        return;
     }
     app.images.mutex.unlock();