Try 4, lol.

src/superblock.zig

@@ -1,10 +1,4 @@
-const math = @import("std").math;
-
-const SuperblockError = error{
-    InvalidMagic,
-    InvalidBlockLog,
-    InvalidVersion,
-};
+const std = @import("std");
 
 pub const Superblock = packed struct {
     magic: u32,
@@ -12,28 +6,70 @@ pub const Superblock = packed struct {
     mod_time: u32,
     block_size: u32,
     frag_count: u32,
-    decomp: @import("decompress.zig").DecompressType,
+    comp: Compression,
     block_log: u16,
-    flags: u16,
+    flags: packed struct {
+        _: u4,
+        id_uncomp: bool,
+        comp_options: bool,
+        no_xattr: bool,
+        xattr_uncomp: bool,
+        has_export: bool,
+        de_dupe: bool,
+        frag_always: bool,
+        no_frag: bool,
+        frag_uncomp: bool,
+        check: bool,
+        data_uncomp: bool,
+        inode_uncomp: bool,
+    },
     id_count: u16,
     ver_maj: u16,
     ver_min: u16,
-    root_ref: @import("inode/inode.zig").InodeRef,
+    root_ref: u64,
     size: u64,
-    id_table_start: u64,
-    xattr_table_start: u64,
-    inode_table_start: u64,
-    dir_table_start: u64,
-    frag_table_start: u64,
-    export_table_start: u64,
+    id_start: u64,
+    xattr_start: u64,
+    inode_start: u64,
+    dir_start: u64,
+    frag_start: u64,
+    export_start: u64,
+};
 
-    pub fn validate(self: Superblock) SuperblockError!void {
-        if (self.magic != 0x73717368) {
-            return SuperblockError.InvalidMagic;
-        } else if (self.block_log != math.log2(self.block_size)) {
-            return SuperblockError.InvalidBlockLog;
-        } else if (self.ver_maj != 4 or self.ver_min != 0) {
-            return SuperblockError.InvalidVersion;
+const DecompressError = error{
+    LzoUnavailable,
+    Lz4Unavailable,
+};
+
+pub const Compression = enum(u16) {
+    gzip = 1,
+    lzma,
+    lzo,
+    xz,
+    lz4,
+    zstd,
+
+    pub fn decompress(self: Compression, comptime max_size: u16, alloc: std.mem.Allocator, source: anytype, dest: *[max_size]u8) !usize {
+        switch (self) {
+            .gzip => {
+                const decomp = std.compress.zlib.decompressor(source);
+                return decomp.read(dest);
+            },
+            .lzma => {
+                const decomp = try std.compress.lzma.decompress(alloc, source);
+                return decomp.read(dest);
+            },
+            .lzo => return DecompressError.LzoUnavailable,
+            .xz => {
+                const decomp = try std.compress.xz.decompress(alloc, source);
+                return decomp.read(dest);
+            },
+            .lz4 => return DecompressError.Lz4Unavailable,
+            .zstd => {
+                const window: [@min(std.compress.zstd.DecompressorOptions.default_window_buffer_len, max_size)]u8 = undefined;
+                const decomp = std.compress.zstd.decompressor(source, .{ .window_buffer = window });
+                return decomp.read(dest);
+            },
         }
     }
 };