Finished (theoretically) file extraction.

Work on extraction
Created DataExtractor & DataReader Created Lookup tables
2026-05-30 17:29:50 -05:00 · 2026-05-30 06:22:26 -05:00 · 2026-05-29 18:50:45 -05:00 · 2026-05-29 06:20:06 -05:00 · 2026-05-28 06:13:00 -05:00 · 2026-04-02 06:27:34 -05:00
43 changed files with 1806 additions and 2101 deletions
@@ -11,7 +11,7 @@

 		"build": {
 			"command": "zig",
-			"args": ["build", "-Duse_c_libs=true", "-Ddebug=true"],
+			"args": ["build", "-Ddebug=true"],
 		},

 		"program": "zig-out/bin/unsquashfs",
@@ -1,121 +1,125 @@
 const std = @import("std");
+const Build = std.Build;

 pub fn build(b: *std.Build) !void {
-    const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse true;
-    // const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo support") orelse false;
+    const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
+    const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo decompression support.") orelse false;
+    const dynamic = b.option(bool, "dynamic", "Dynamic link C decompression libraries.") orelse false;
    const debug = b.option(bool, "debug", "Enable options to make debugging easier.") orelse false;
-    const version_string_option = b.option([]const u8, "version", "Version of the library/binary");
+    const version_string = b.option([]const u8, "version", "Version of the library/binary") orelse "0.0.0-testing";
+
+    const version: std.SemanticVersion = try .parse(version_string);

    const zig_squashfs_options = b.addOptions();
    zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
-    // zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);
+    zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);

-    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
-    const mod = b.addModule("zig_squashfs", .{
-        .root_source_file = b.path("src/root.zig"),
+    const target = b.standardTargetOptions(.{});
+
+    const c = b.addTranslateC(.{
+        .optimize = optimize,
        .target = target,
-        .optimize = if (debug == true) .Debug else optimize,
-        .valgrind = debug,
-        .error_tracing = debug,
-        .strip = if (debug == true) false else null,
+        .root_source_file = b.path("src/c.h"),
    });
-    mod.addOptions("config", zig_squashfs_options);
-    if (!use_zig_decomp) {
-        mod.link_libc = true;
-
-        const c_imports = b.addTranslateC(.{
-            .optimize = optimize,
-            .target = target,
-            .root_source_file = b.path("src/imports.c"),
-        });
-        mod.addImport("c", c_imports.createModule());
-
-        var zlib_ng = b.dependency("zlib_ng", .{
-            .target = target,
-            .optimize = optimize,
-        });
-        mod.linkLibrary(zlib_ng.artifact("zng"));
-
-        mod.linkSystemLibrary("lzma", .{ .preferred_link_mode = .static });
-
-        var minilzo = b.dependency("minilzo", .{
-            .target = target,
-            .optimize = optimize,
-        });
-        mod.linkLibrary(minilzo.artifact("minilzo"));
-
-        var lz4 = b.dependency("lz4", .{
-            .target = target,
-            .optimize = optimize,
-        });
-        mod.linkLibrary(lz4.artifact("lz4"));
-
-        var zstd = b.dependency("zstd", .{
-            .target = target,
-            .optimize = optimize,
-        });
-        mod.linkLibrary(zstd.artifact("zstd"));
+    if (allow_lzo)
+        c.defineCMacro("ALLOW_LZO", null);
+    if (dynamic) {
+        c.linkSystemLibrary("z", .{});
+        c.linkSystemLibrary("lzma", .{});
+        c.linkSystemLibrary("lz4", .{});
+        c.linkSystemLibrary("zstd", .{});
+        if (allow_lzo)
+            c.linkSystemLibrary("minilzo", .{});
    }

-    var version = version_string_option orelse "0.0.0-testing";
-    if (version[0] == 'v') version = version[1..];
-    const unsquashfs_options = b.addOptions();
-    unsquashfs_options.addOption(
-        std.SemanticVersion,
-        "version",
-        try std.SemanticVersion.parse(version),
-    );
-
-    var exe_mod = b.createModule(.{
-        .root_source_file = b.path("src/bin/unsquashfs.zig"),
-        .target = target,
-        .optimize = if (debug == true) .Debug else optimize,
-        .link_libc = !use_zig_decomp,
-        .imports = &.{
-            .{ .name = "zig_squashfs", .module = mod },
-        },
-        .valgrind = debug,
-        .error_tracing = debug,
-        .strip = if (debug == true) false else null,
-    });
-    exe_mod.addOptions("config", unsquashfs_options);
-    const exe = b.addExecutable(.{
-        .name = "unsquashfs",
-        .root_module = exe_mod,
-        .use_llvm = debug,
-    });
+    const deps = try getDependencies(b, optimize, target, allow_lzo);

    const lib = b.addLibrary(.{
        .name = "squashfs",
-        .root_module = mod,
        .use_llvm = debug,
+        .version = version,
+        .root_module = b.createModule(.{
+            .imports = &.{
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
+                .{ .name = "c", .module = c.createModule() },
+            },
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/root.zig"),
+            .valgrind = debug,
+        }),
    });

+    for (deps) |d|
+        lib.root_module.linkLibrary(d);
+
    b.installArtifact(lib);
+
+    const exe_config = b.addOptions();
+    exe_config.addOption(std.SemanticVersion,"version", version);
+
+    const exe = b.addExecutable(.{
+        .name = "unsquashfs",
+        .use_llvm = debug,
+        .version = version,
+        .root_module = b.createModule(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/bin/unsquashfs.zig"),
+            .valgrind = debug,
+            .imports = &.{
+                .{ .name = "config", .module = exe_config.createModule() },
+                .{ .name = "squashfs", .module = lib.root_module }
+            },
+        }),
+    });
+
    b.installArtifact(exe);

-    const mod_tests = b.addTest(.{
-        .root_module = mod,
-        .test_runner = .{
-            .mode = .simple,
-            .path = b.path("src/test.zig"),
-        },
+    const lib_test = b.addTest(.{
+        .name = "squashfs-test",
+        .root_module = lib.root_module,
    });
-    const run_mod_tests = b.addRunArtifact(mod_tests);
    const test_step = b.step("test", "Run tests");
-    test_step.dependOn(&run_mod_tests.step);
+    test_step.dependOn(&lib_test.step);

-    // zls build check steps
+    // zls check step
    const lib_check = b.addLibrary(.{
-        .name = "squashfs",
-        .root_module = mod,
+        .name = "squashfs-check",
+        .root_module = lib.root_module,
    });
-    const exe_check = b.addExecutable(.{
-        .name = "unsquashfs",
-        .root_module = exe_mod,
+    const exe_check = b.addLibrary(.{
+        .name = "unsquashfs-check",
+        .root_module = exe.root_module,
    });
-    const check = b.step("check", "Check if unsquashfs compiles");
-    check.dependOn(&exe_check.step);
+
+    const check = b.step("check", "Check if squashfs compiles");
    check.dependOn(&lib_check.step);
+    check.dependOn(&exe_check.step);
+}
+
+fn getDependencies(b: *Build, optimize: std.builtin.OptimizeMode, target: Build.ResolvedTarget, allow_lzo: bool) ![]*Build.Step.Compile {
+    const alloc = b.allocator;
+
+    var list: std.ArrayList(*Build.Step.Compile) = .empty;
+
+    const zlib_ng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, zlib_ng.artifact("zng"));
+
+    const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, xz.artifact("lzma"));
+
+    const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, lz4.artifact("lz4"));
+
+    const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, zstd.artifact("zstd"));
+
+    if (allow_lzo) {
+        const minilzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
+        try list.append(alloc, minilzo.artifact("minilzo"));
+    }
+
+    return list.toOwnedSlice(b.allocator);
 }
@@ -5,9 +5,8 @@
    .minimum_zig_version = "0.16.0",
    .dependencies = .{
        .zlib_ng = .{
-            // .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
-            // .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
-            .path = "../zig-zlib-ng",
+            .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
+            .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
        },
        .zstd = .{
            .url = "git+https://github.com/allyourcodebase/zstd.git?ref=1.5.7-1#e1a501be57f42c541e8a5597e4b59a074dfd09a3",
@@ -18,14 +17,13 @@
            .hash = "lz4-1.10.0-6-ewyzw-4NAAAWDpY4xpiqr4LQhZQAC0x_rGnW2iPh6jk2",
        },
        .minilzo = .{
-            // .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
-            // .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
-            .path = "../zig-minilzo",
+            .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
+            .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
+        },
+        .xz = .{
+            .url = "git+https://github.com/akunaakwei/zig-xz.git#e2d389262c8291907e3e4c6fb119819141c16c0f",
+            .hash = "xz-5.8.2-6v47_JYeAABSL-jonprpL5-E_YaaGc4B5xrbe93WsJ3G",
        },
-        // .fastlzma2 = .{
-        //     .url = "git+https://github.com/allyourcodebase/fast-lzma2#d7615e0c957a62fcd6691b3fe9519a091885bfa2",
-        //     .hash = "fastlzma2-0.0.0-gNWHgVeLAAD0Tlak3xhNcgpPSYcjyJppq0tlGmPKCC_V",
-        // },
    },
    .paths = .{
        "build.zig",
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+zig test \
+	-lc \
+	-lz \
+	-llzma \
+	-lminilzo \
+	-llz4 \
+	-lzstd \
+		src/test.zig
@@ -1,125 +1,114 @@
 const std = @import("std");
 const Io = std.Io;
+const File = Io.File;
+const MemoryMap = File.MemoryMap;

-const DecompTypes = @import("decomp/types.zig");
-const Decompressor = @import("decomp.zig");
+const Decomp = @import("decomp.zig");
+const DecompCache = @import("decomp_cache.zig");
+const Extract = @import("extract.zig");
 const ExtractionOptions = @import("options.zig");
-const File = @import("file.zig");
 const Inode = @import("inode.zig");
-const BlockSize = @import("inode/file.zig").BlockSize;
-const LookupTable = @import("lookup_table.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-const Utils = @import("util/utils.zig");
-
-pub const Error = error{
-    BadMagic,
-    BadBlockLog,
-    BadVersion,
-    BadCheck,
-};
+const SfsFile = @import("file.zig");

 const Archive = @This();

-file: OffsetFile,
+const CACHE_MEM_MAX = 1024 * 1024 * 1024;

 super: Superblock,

-stateless_decomp: Decompressor,
+cache: DecompCache,

-/// Create an Archive from a File.
-pub fn init(io: Io, fil: Io.File, offset: u64) !Archive {
+pub fn init(alloc: std.mem.Allocator, io: Io, fil: File) !Archive {
+    return initAdvanced(alloc, io, fil, 0, 0);
+}
+pub fn initAdvanced(alloc: std.mem.Allocator, io: Io, fil: File, offset: u64, cache_memory_max: u64) !Archive {
+    var rdr = fil.reader(io, &[0]u8{});
+    try rdr.seekTo(offset);
    var super: Superblock = undefined;
-    var fil_rdr = fil.reader(io, &[0]u8{});
-    if (offset > 0)
-        try fil_rdr.seekTo(offset);
-    try fil_rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
+    try rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
    try super.validate();

+    const map = try fil.createMemoryMap(io, .{
+        .offset = offset,
+        .len = super.size,
+        .protection = .{ .read = true },
+    });
+
    return .{
-        .file = .{ .fil = fil, .offset = offset },
        .super = super,
-        .stateless_decomp = .{ .vtable = &.{ .stateless = try DecompTypes.getStatelessFn(super.compression) } },
-    };
-}

-pub fn root(self: Archive, alloc: std.mem.Allocator) !File {
-    return .{
-        .file = self.file,
-        .super = self.super.toMinimal(),
-        .decomp = self.stateless_decomp.statelessCopy(alloc),
-
-        .inode = try Utils.readInode(
+        .cache = try .init(
            alloc,
-            &self.stateless_decomp,
-            self.file,
-            self.super.inode_start,
-            self.super.block_size,
-            self.super.root_ref.block_start,
-            self.super.root_ref.block_offset,
+            map,
+            super.compression,
+            if (cache_memory_max != 0)
+                cache_memory_max
+            else
+                @min(CACHE_MEM_MAX, (try std.process.totalSystemMemory()) / 2),
        ),
-        .name = "",
    };
 }
-pub fn open(self: Archive, alloc: std.mem.Allocator, path: []const u8) !File {
-    if (Utils.pathIsSelf(path)) return self.root(alloc);
-    var root_file = self.root(alloc);
-    defer root_file.deinit();
-    return root_file.open(alloc, path);
+pub fn deinit(self: *Archive, io: Io) void {
+    self.cache.deinit(io);
 }

-pub fn fragEntry(self: Archive, idx: u32) !FragEntry {
-    return LookupTable.stateless(FragEntry, self.fil, &self.stateless_decomp, self.super.frag_start, idx);
-}
-pub fn id(self: Archive, idx: u32) !u16 {
-    return LookupTable.stateless(u16, self.fil, &self.stateless_decomp, self.super.id_start, idx);
-}
-pub fn inode(self: Archive, alloc: std.mem.Allocator, inode_num: u32) !Inode {
-    const ref = try LookupTable.stateless(Inode.Ref, self.file, &self.stateless_decomp, self.super.export_start, inode_num - 1);
-    return Utils.readInode(
+pub fn root(self: *Archive, alloc: std.mem.Allocator, io: Io) !SfsFile {
+    const inode: Inode = try .initRef(
        alloc,
-        &self.stateless_decomp,
-        self.file,
+        io,
+        &self.cache,
        self.super.inode_start,
        self.super.block_size,
-        ref.block_start,
-        ref.block_offset,
+        self.super.root_ref,
    );
+    return .init(alloc, self, inode, "");
+}
+pub fn open(self: *Archive, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !SfsFile {
+    const path = std.mem.trim(u8, filepath, "/");
+
+    var root_file = try self.root(alloc, io);
+
+    if (path.len == 0 or path[0] == '.') return root_file;
+
+    defer root_file.deinit();
+    return root_file.open(alloc, io, filepath);
 }

-pub fn extract(self: Archive, alloc: std.mem.Allocator, path: []const u8, options: ExtractionOptions) !void {
-    _ = self;
-    _ = alloc;
-    _ = path;
-    _ = options;
-    return error.TODO;
+pub fn extract(self: *Archive, alloc: std.mem.Allocator, io: Io, ext_loc: []const u8, options: ExtractionOptions) !void {
+    const root_inode: Inode = try .initRef(
+        alloc,
+        io,
+        &self.cache,
+        self.super.inode_start,
+        self.super.block_size,
+        self.super.root_ref,
+    );
+    return Extract.extract(alloc, io, root_inode, &self.cache, self.super, ext_loc, options);
 }

 // Superblock

-const SQUASHFS_MAGIC: u32 = std.mem.readInt(u32, "hsqs", .little);
-
-pub const Superblock = packed struct {
+pub const Superblock = extern struct {
    magic: u32,
    inode_count: u32,
    mod_time: u32,
    block_size: u32,
    frag_count: u32,
-    compression: DecompTypes.Enum,
+    compression: Decomp.Enum,
    block_log: u16,
-    flags: packed struct {
+    flags: packed struct(u16) {
        inode_uncompressed: bool,
        data_uncompressed: bool,
        check: bool,
        frag_uncompressed: bool,
-        fragment_never: bool,
-        fragment_always: bool,
-        duplicates: bool,
+        frag_never: bool,
+        frag_always: bool,
+        de_dupe: bool,
        exportable: bool,
        xattr_uncompressed: bool,
        xattr_never: bool,
        compression_options: bool,
-        ids_uncompressed: bool,
+        id_uncompressed: bool,
        _: u4,
    },
    id_count: u16,
@@ -134,51 +123,63 @@ pub const Superblock = packed struct {
    frag_start: u64,
    export_start: u64,

-    /// Validate the Superblock. If an error is returned, it's likely the archive is corrupted or not a squashfs archive.
-    fn validate(self: Superblock) !void {
-        if (self.magic != SQUASHFS_MAGIC)
-            return Error.BadMagic;
-        if (self.flags.check)
-            return Error.BadCheck;
+    pub fn validate(self: Superblock) !void {
+        if (self.magic != std.mem.readInt(u32, "hsqs", .little))
+            return error.BadMagic;
        if (self.ver_maj != 4 or self.ver_min != 0)
-            return Error.BadVersion;
-        if (std.math.log2(self.block_size) != self.block_log)
-            return Error.BadBlockLog;
-    }
-
-    pub fn toMinimal(self: Superblock) MinimalSuperblock {
-        return .{
-            .inode_count = self.inode_count,
-            .block_size = self.block_size,
-            .frag_count = self.frag_count,
-            .id_count = self.id_count,
-            .id_start = self.id_start,
-            .xattr_start = self.xattr_start,
-            .inode_start = self.inode_start,
-            .dir_start = self.dir_start,
-            .frag_start = self.frag_start,
-            .export_start = self.export_start,
-        };
+            return error.InvalidVersion;
+        if (self.block_log != std.math.log2(self.block_size))
+            return error.BadBlockLog;
+        if (self.flags.check)
+            return error.BadCheckFlag;
    }
 };

-pub const MinimalSuperblock = struct {
-    inode_count: u32,
-    block_size: u32,
-    frag_count: u32,
-    id_count: u16,
-    id_start: u64,
-    xattr_start: u64,
-    inode_start: u64,
-    dir_start: u64,
-    frag_start: u64,
-    export_start: u64,
-};
+// Test

-// Frag Entry
+const TestArchive = "testing/LinuxPATest.sfs";

-pub const FragEntry = packed struct {
-    block_start: u64,
-    size: BlockSize,
-    _: u32,
-};
+test "Basics" {
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var archive_file = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer archive_file.close(io);
+    var arc: Archive = try .init(alloc, io, archive_file);
+    defer arc.deinit(io);
+
+    var root_file = try arc.root(alloc, io);
+    defer root_file.deinit();
+}
+
+const TestFile = "Start.exe";
+const TestFileExtractLocation = "testing/Start.exe";
+
+test "SingleFileExtraction" {
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var archive_file = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer archive_file.close(io);
+    var arc: Archive = try .init(alloc, io, archive_file);
+    defer arc.deinit(io);
+
+    var ext_file = try arc.open(alloc, io, TestFile);
+    defer ext_file.deinit();
+
+    try ext_file.extract(alloc, io, TestFileExtractLocation, .default);
+}
+
+const TestFullExtractLocation = "testing/TestExtract";
+
+test "FullExtraction" {
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var archive_file = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer archive_file.close(io);
+    var arc: Archive = try .init(alloc, io, archive_file);
+    defer arc.deinit(io);
+
+    try arc.extract(alloc, io, TestFullExtractLocation, .default);
+}
@@ -1,10 +1,11 @@
 const std = @import("std");
 const Io = std.Io;
 const Writer = Io.Writer;
+const File = Io.File;
 const builtin = @import("builtin");

 const config = @import("config");
-const squashfs = @import("zig_squashfs");
+const squashfs = @import("squashfs");

 //TODO: Add more options
 const help_mgs =
@@ -43,7 +44,7 @@ pub fn main(init: std.process.Init) !void {
    const alloc = init.gpa;
    const io = init.io;

-    var stdout = std.Io.File.stdout();
+    var stdout = File.stdout();
    var out = stdout.writer(io, &[0]u8{});
    defer out.interface.flush() catch {};
    try handleArgs(init.minimal.args, &out.interface);
@@ -52,11 +53,11 @@ pub fn main(init: std.process.Init) !void {
        try out.interface.print(help_mgs, .{});
        return;
    }
-    var fil: Io.File = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
+    var fil: File = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
    defer fil.close(io);
-    var arc: squashfs.Archive = try .init(io, fil, offset); //TODO: Handle error gracefully.
+    var arc: squashfs.Archive = try .initAdvanced(alloc, io, fil, offset, 0); //TODO: Update when memory size matters. //TODO: Handle error gracefully.
+    defer arc.deinit(io);
    const options: squashfs.ExtractionOptions = .{
-        .threads = if (threads == 0) try std.Thread.getCpuCount() else threads,
        .verbose = verbose,
        .verbose_writer = if (verbose) &out.interface else null,
        .ignore_xattr = ignore_xattrs,
@@ -64,13 +65,13 @@ pub fn main(init: std.process.Init) !void {
    };
    if (force)
        try Io.Dir.cwd().deleteTree(io, extLoc);
-    try arc.extract(alloc, extLoc, options); //TODO: Handle error gracefully.
+    try arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
 }

 fn handleArgs(args: std.process.Args, out: *Writer) !void {
    var arg_iter = args.iterate();
    defer arg_iter.deinit();
-    _ = arg_iter.next(); // args[0] is the application launch command.
+    _ = arg_iter.skip(); // args[0] is the application launch command.
    while (arg_iter.next()) |arg| {
        if (std.mem.eql(u8, arg, "-o")) {
            const nxt = arg_iter.next();
@@ -1,5 +1,7 @@
-#include <zlib-ng.h>
-#include <lzo/minilzo.h>
+#include <zlib.h>
+#include <lzma.h>
 #include <lz4.h>
 #include <zstd.h>
-#include <lzma.h>
+#ifdef ALLOW_LZO
+#include <lzo/minilzo.h>
+#endif
@@ -0,0 +1,61 @@
+const std = @import("std");
+
+const c = @import("c");
+
+const Error = @import("decomp.zig").Error;
+
+pub fn zlibDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var strem: c.z_stream = .{
+        .next_in = in.ptr,
+        .avail_in = @truncate(in.len),
+        .next_out = out.ptr,
+        .avail_out = @truncate(out.len),
+    };
+    var res = c.inflateInit(&strem);
+    if (res != c.Z_OK) return Error.ReadFailed;
+    defer _ = c.inflateEnd(&strem);
+
+    res = c.inflate(&strem, c.Z_FULL_FLUSH);
+    if (res != c.Z_OK) return Error.ReadFailed;
+
+    return strem.total_out;
+}
+pub fn lzmaDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var strem: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+    };
+    var res = c.lzma_auto_decoder(&strem, out.len * 2, 0);
+    if (res != c.LZMA_OK) return Error.ReadFailed;
+    defer c.lzma_end(&strem);
+
+    while (res == c.LZMA_OK)
+        res = c.lzma_code(&strem, c.LZMA_RUN);
+    if (res != c.LZMA_FINISH) return Error.ReadFailed;
+
+    return strem.total_out;
+}
+pub fn lzoDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var out_len = out.len;
+    const res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &out_len, null);
+    if (res != c.LZO_E_OK) return Error.ReadFailed;
+    return out_len;
+}
+pub fn lz4Decompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const res = c.LZ4_decompress_safe(
+        in.ptr,
+        out.ptr,
+        @bitCast(@as(u32, @truncate(in.len))),
+        @bitCast(@as(u32, @truncate(out.len))),
+    );
+    if (res < 0) return Error.ReadFailed;
+    return @abs(res);
+}
+pub fn zstdDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
+    if (c.ZSTD_isError(res) != 0)
+        return Error.ReadFailed;
+    return res;
+}
@@ -0,0 +1,102 @@
+const std = @import("std");
+const Io = std.Io;
+
+const DecompCache = @import("../decomp_cache.zig");
+const DataBlock = @import("../inode.zig").DataBlock;
+
+const Extractor = @This();
+
+cache: *DecompCache,
+block_size: u32,
+
+start: u64,
+size: u64,
+blocks: []DataBlock,
+
+frag_data: ?[]u8 = null,
+frag_offset: u32 = 0,
+
+pub fn init(cache: *DecompCache, block_size: u32, size: u64, start: u64, blocks: []DataBlock) Extractor {
+    return .{
+        .cache = cache,
+        .block_size = block_size,
+
+        .start = start,
+        .size = size,
+        .blocks = blocks,
+    };
+}
+
+pub fn addFragment(self: *Extractor, data: []u8, offset: u32) void {
+    self.frag_data = data;
+    self.frag_offset = offset;
+}
+
+pub fn asyncExtract(self: Extractor, io: Io, fil: Io.File) Error!void {
+    try fil.writePositionalAll(io, &.{&.{0}}, self.size - 1);
+
+    var map = try fil.createMemoryMap(io, .{ .len = self.size, .protection = .{ .write = true } });
+    defer map.destroy(io);
+
+    var group: Io.Group = .init;
+    defer group.cancel(io);
+
+    var ret_err: ?Error = null;
+
+    var offset = self.start;
+    for (0..self.blocks.len) |i| {
+        group.async(io, blockThread, .{ self, io, map, offset, i, &ret_err });
+
+        offset += self.blocks[i].size;
+    }
+    if (self.frag_data != null)
+        group.async(io, fragThread, .{ self, map });
+
+    group.await(io) catch |err| return ret_err orelse err;
+
+    try map.write(io);
+}
+
+fn blockThread(self: Extractor, io: Io, map: Io.File.MemoryMap, read_offset: u64, idx: usize, ret_err: *?Error) error{Canceled}!void {
+    const write_pos = idx * self.block_size;
+    const size = if (self.frag_data == null and idx == self.block_size.len - 1)
+        self.size % self.block_size
+    else
+        self.block_size;
+    const block = self.blocks[idx];
+
+    if (block.size == 0) {
+        @memset(map.memory[write_pos..][0..size], 0);
+        return;
+    }
+    if (block.uncompressed) {
+        @memcpy(map[write_pos..][0..size], self.cache.map.memory[read_offset..][0..size]);
+        return;
+    }
+    const data = self.cache.get(io, read_offset, block.size, size) catch |err| switch (err) {
+        error.Canceled => {
+            io.recancel();
+            return error.Canceled;
+        },
+        else => |e| {
+            ret_err.* = e;
+            return error.Canceled;
+        },
+    };
+    defer self.cache.finished(io, read_offset);
+    if (data.len != size) {
+        std.debug.print("Size of decompression at {} is {} and should be {}\n", .{ read_offset, data.len, size });
+        return Error.BadDecompressionSize;
+    }
+    @memcpy(map[write_pos..][0..size], data);
+}
+fn fragThread(self: Extractor, map: Io.File.MemoryMap) error{Canceled}!void {
+    const write_pos = self.blocks.len * self.block_size;
+    const size = self.size % self.block_size;
+
+    @memcpy(map.memory[write_pos..][0..size], self.frag_data.?[self.frag_offset..][0..size]);
+}
+
+// Types
+
+pub const Error = error{BadDecompressionSize} || Io.File.WritePositionalError || Io.File.MemoryMap.CreateError;
@@ -0,0 +1,151 @@
+const std = @import("std");
+const Io = std.Io;
+
+const DecompCache = @import("../decomp_cache.zig");
+const DataBlock = @import("../inode.zig").DataBlock;
+
+const Reader = @This();
+
+io: Io,
+
+cache: *DecompCache,
+block_size: u32,
+
+size: u64,
+blocks: []DataBlock,
+
+frag_data: ?[]u8 = null,
+frag_offset: u32 = 0,
+
+cur_offset: u64 = 0,
+next_offset: u64,
+
+idx: u32 = 0,
+cur_block_sparse: bool = false,
+
+interface: Io.Reader = .{
+    .buffer = &[0]u8{},
+    .end = 0,
+    .seek = 0,
+    .vtable = &.{
+        .stream = stream,
+        .discard = discard,
+        .readVec = readVec,
+    },
+},
+
+pub fn init(io: Io, cache: *DecompCache, block_size: u32, size: u64, start: u64, blocks: []DataBlock) Reader {
+    return .{
+        .io = io,
+
+        .cache = cache,
+        .block_size = block_size,
+
+        .size = size,
+        .blocks = blocks,
+
+        .next_offset = start,
+    };
+}
+pub fn deinit(self: Reader) void {
+    self.cache.finished(self.io);
+}
+
+pub fn addFragment(self: *Reader, data: []u8, offset: u32) void {
+    self.frag_data = data;
+    self.frag_offset = offset;
+}
+
+fn advance(self: *Reader) Io.Reader.Error!void {
+    errdefer self.interface.end = 0;
+    self.interface.seek = 0;
+
+    if (self.idx > self.blocks.len) return error.EndOfStream;
+    defer self.idx += 1;
+    self.cache.finished(self.io, self.cur_offset);
+
+    if (self.idx == self.blocks.len) {
+        if (self.frag_data == null) return error.EndOfStream;
+        self.cur_offset = 0;
+
+        const size = self.size % self.block_size;
+        self.interface.buffer = self.frag_data.?[self.frag_offset..][0..size];
+        self.interface.end = size;
+        return;
+    }
+
+    const block = self.blocks[self.idx];
+
+    const size = if (self.idx == self.blocks.len - 1 and self.frag_data == null)
+        self.size % self.block_size
+    else
+        self.block_size;
+
+    if (block.size == 0) {
+        self.interface.buffer = &[0]u8{};
+        self.cur_block_sparse = true;
+        self.interface.end = size;
+        return;
+    } else {
+        self.cur_block_sparse = false;
+    }
+
+    self.cur_offset = self.next_offset;
+    self.next_offset = self.cur_offset + block.size;
+
+    if (block.uncompressed) {
+        self.interface.buffer = self.cache.map.memory[self.cur_offset..][0..size];
+        self.interface.end = size;
+        return;
+    }
+    const data = self.cache.get(self.io, self.cur_offset, block.size, size);
+    if (data.len != size) {
+        std.debug.print("Size of decompression at {} is {} and should be {}\n", .{ self.cur_offset, data.len, size });
+        return Io.Reader.Error.ReadFailed;
+    }
+    self.interface.buffer = data;
+    self.interface.end = size;
+}
+
+fn stream(r: *Io.Reader, w: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!usize {
+    const self: *Reader = @fieldParentPtr("interface", r);
+    if (r.seek >= r.end) {
+        try self.advance();
+    }
+    const to_write = @min(@intFromEnum(limit), r.end - r.seek);
+    const wrote = try if (self.cur_block_sparse)
+        w.splatByte(0, to_write)
+    else
+        w.write(r.buffer[r.seek..][0..to_write]);
+    r.seek += wrote;
+    return wrote;
+}
+fn discard(r: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
+    if (r.seek >= r.end) {
+        const self: *Reader = @fieldParentPtr("interface", r);
+        try self.advance();
+    }
+    const to_discard = @min(@intFromEnum(limit), r.end - r.seek);
+    r.seek += to_discard;
+    return to_discard;
+}
+fn readVec(r: *Io.Reader, vec: [][]u8) Io.Reader.Error!usize {
+    const self: *Reader = @fieldParentPtr("interface", r);
+    if (r.seek >= r.end) {
+        try self.advance();
+    }
+    var total: usize = 0;
+    for (vec) |v| {
+        const to_copy = @min(v.len, r.end - r.seek);
+        if (self.cur_block_sparse) {
+            @memset(v[0..to_copy], 0);
+        } else {
+            @memcpy(v[0..to_copy], r.buffer[r.seek..][0..to_copy]);
+        }
+        total += to_copy;
+        r.seek += to_copy;
+
+        if (r.seek >= r.end) break;
+    }
+    return total;
+}
@@ -1,31 +1,41 @@
 const std = @import("std");

-pub const StatelessDecomp = *const fn (std.mem.Allocator, in: []u8, out: []u8) Error!usize;
+const options = @import("options");

-pub const Error = error{
-    OutOfMemory,
-    EndOfStream,
-    ReadFailed,
-    WriteFailed,
+const c_decomp = @import("c_decomp.zig");
+const zig_decomp = @import("zig_decomp.zig");
+
+pub const Error = error{} || std.Io.Reader.UnlimitedAllocError;
+
+pub const Enum = enum(u16) {
+    zlib = 1,
+    lzma,
+    lzo,
+    xz,
+    lz4,
+    zstd,
 };

-const Decompressor = @This();
+pub const Fn = *const fn (std.mem.Allocator, in: []u8, out: []u8) Error!usize;

-alloc: std.mem.Allocator = std.heap.smp_allocator,
-vtable: *const struct {
-    decompress: *const fn (*const Decompressor, in: []u8, out: []u8) Error!usize = defaultDecompress,
-    stateless: StatelessDecomp,
-},
-
-/// Create a copy of the decompressor using it's stateless function and the new allocator.
-pub fn statelessCopy(self: Decompressor, alloc: std.mem.Allocator) Decompressor {
-    return &.{ .alloc = alloc, .vtable = &.{ .stateless = self.vtable.stateless } };
-}
-
-pub fn decompress(self: *const Decompressor, in: []u8, out: []u8) Error!usize {
-    return self.vtable.decompress(self, in, out);
-}
-
-fn defaultDecompress(self: *const Decompressor, in: []u8, out: []u8) Error!usize {
-    return self.vtable.stateless(self.alloc, in, out);
+pub fn DecompFn(comp: Enum) !Fn {
+    return if (options.use_zig_decomp)
+        switch (comp) {
+            .zlib => zig_decomp.zlibDecompress,
+            .lzma => zig_decomp.lzmaDecompress,
+            .xz => zig_decomp.xzDecompress,
+            .zstd => zig_decomp.zstdDecompress,
+            .lz4 => error.Lz4Unsupported,
+            .lzo => error.LzoUnsupported,
+        }
+    else switch (comp) {
+        .zlib => c_decomp.zlibDecompress,
+        .lzma, .xz => c_decomp.lzmaDecompress,
+        .zstd => c_decomp.zstdDecompress,
+        .lz4 => c_decomp.lz4Decompress,
+        .lzo => if (options.allow_lzo)
+            c_decomp.zstdDecompress
+        else
+            error.LzoUnsupported,
+    };
 }
@@ -1,12 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-const Decompressor = @import("../../decomp.zig");
-
-interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
-
-pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    const res = c.LZ4_decompress_safe(in.ptr, out.ptr, @intCast(in.len), @intCast(out.len));
-    if (res > 0) return @abs(res);
-    return Decompressor.Error.ReadFailed; // TOOD: Find out what errors can be returned.
-}
@@ -1,142 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-const Decompressor = @import("../../decomp.zig");
-
-const Lzma = @This();
-
-streams: std.AutoHashMap(std.Thread.Id, c.lzma_stream),
-
-interface: Decompressor,
-
-err: ?Error = null,
-
-pub fn init(alloc: std.mem.Allocator) !Lzma {
-    return .{
-        .streams = try .init(alloc),
-        .interface = &.{
-            .alloc = alloc,
-            .vtable = .{ .decompress = decompress, .stateless = stateless },
-        },
-    };
-}
-pub fn deinit(self: *Lzma) void {
-    var values = self.streams.valueIterator();
-    while (values.next()) |val| {
-        c.lzma_end(val);
-    }
-    self.streams.deinit();
-}
-
-fn getOrCreate(self: *Lzma) !*c.lzma_stream {
-    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
-    if (res.found_existing) return res.value_ptr;
-    res.value_ptr.* = .{
-        .alloc = .{
-            .alloc = lzmaAlloc,
-            .free = lzmaFree,
-            .@"opaque" = &self.interface.alloc,
-        },
-    };
-    return res.value_ptr;
-}
-
-fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
-    var self: *Lzma = @fieldParentPtr("interface", decomp);
-
-    const stream = try self.getOrCreate();
-    stream.next_in = in.ptr;
-    stream.avail_in = in.len;
-    stream.next_out = out.ptr;
-    stream.avail_out = out.len;
-    var res = c.lzma_alone_decoder(stream, out.len);
-    decodeResult(res) catch |err| {
-        self.err = err;
-        return lzmaErrorToDecompError(err);
-    };
-    while (true) {
-        res = c.lzma_code(&stream, c.LZMA_RUN);
-        if (res == c.LZMA_OK) continue;
-        if (res == c.LZMA_STREAM_END) break;
-        decodeResult(res) catch |err| {
-            self.err = err;
-            return lzmaErrorToDecompError(err);
-        };
-    }
-    return stream.total_out;
-}
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var stream: c.lzma_stream = .{
-        .next_in = in.ptr,
-        .avail_in = in.len,
-        .next_out = out.ptr,
-        .avail_out = out.len,
-        .allocator = &.{
-            .alloc = lzmaAlloc,
-            .free = lzmaFree,
-            .@"opaque" = @ptrCast(@constCast(&alloc)),
-        },
-    };
-    var res = c.lzma_alone_decoder(&stream, out.len);
-    decodeResult(res) catch |err| return lzmaErrorToDecompError(err);
-    while (true) {
-        res = c.lzma_code(&stream, c.LZMA_RUN);
-        if (res == c.LZMA_OK) continue;
-        if (res == c.LZMA_STREAM_END) break;
-        decodeResult(res) catch |err| return lzmaErrorToDecompError(err);
-    }
-    return stream.total_out;
-}
-
-inline fn decodeResult(res: c_uint) Error!void {
-    return switch (res) {
-        c.LZMA_OK => {},
-        c.LZMA_STREAM_END => {},
-        c.LZMA_NO_CHECK => {},
-        c.LZMA_UNSUPPORTED_CHECK => Error.UnsupportedCheck,
-        c.LZMA_MEM_ERROR => Error.OutOfMemory,
-        c.LZMA_MEMLIMIT_ERROR => Error.OutOfMemory,
-        c.LZMA_FORMAT_ERROR => Error.Format,
-        c.LZMA_OPTIONS_ERROR => Error.Options,
-        c.LZMA_DATA_ERROR => Error.Data,
-        c.LZMA_BUF_ERROR => Error.BufferExhausted,
-        c.LZMA_PROG_ERROR => Error.Programming,
-        c.LZMA_SEEK_NEEDED => Error.SeekNeeded,
-        else => Error.Unknown,
-    };
-}
-fn lzmaErrorToDecompError(err: Error) Decompressor.Error {
-    switch (err) {
-        Error.OutOfMemory => return Decompressor.Error.OutOfMemory,
-        Error.UnsupportedCheck => return Decompressor.Error.ReadFailed,
-        Error.Format => return Decompressor.Error.ReadFailed,
-        Error.Options => return Decompressor.Error.ReadFailed,
-        Error.Data => return Decompressor.Error.ReadFailed,
-        Error.BufferExhausted => return Decompressor.Error.WriteFailed,
-        Error.Programming => return Decompressor.Error.ReadFailed,
-        Error.SeekNeeded => return Decompressor.Error.ReadFailed,
-        Error.Unknown => return Decompressor.Error.ReadFailed,
-    }
-}
-
-fn lzmaAlloc(ptr: ?*anyopaque, _: usize, size: usize) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
-    return alloc.rawAlloc(size, .@"1", 0);
-}
-fn lzmaFree(ptr: ?*anyopaque, alloc_ptr: ?*anyopaque) callconv(.c) void {
-    if (alloc_ptr == null) return;
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
-    alloc.rawFree(@ptrCast(alloc_ptr), .@"1", 0);
-}
-
-pub const Error = error{
-    OutOfMemory,
-    UnsupportedCheck,
-    Format,
-    Options,
-    Data,
-    BufferExhausted,
-    Programming,
-    SeekNeeded,
-    Unknown,
-};
@@ -1,28 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-const Decompressor = @import("../../decomp.zig");
-
-interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
-
-pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var out_len = out.len;
-    const res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &out_len, null);
-    return switch (res) {
-        c.LZO_E_OK => out_len,
-        c.LZO_E_ERROR => Decompressor.Error.ReadFailed,
-        c.LZO_E_OUT_OF_MEMORY => Decompressor.Error.OutOfMemory,
-        c.LZO_E_NOT_COMPRESSIBLE => Decompressor.Error.ReadFailed,
-        c.LZO_E_INPUT_OVERRUN => Decompressor.Error.ReadFailed,
-        c.LZO_E_OUTPUT_OVERRUN => Decompressor.Error.WriteFailed,
-        c.LZO_E_LOOKBEHIND_OVERRUN => Decompressor.Error.ReadFailed,
-        c.LZO_E_EOF_NOT_FOUND => Decompressor.Error.ReadFailed,
-        c.LZO_E_INPUT_NOT_CONSUMED => Decompressor.Error.ReadFailed,
-        c.LZO_E_NOT_YET_IMPLEMENTED => Decompressor.Error.ReadFailed,
-        c.LZO_E_INVALID_ARGUMENT => Decompressor.Error.ReadFailed,
-        c.LZO_E_INVALID_ALIGNMENT => Decompressor.Error.ReadFailed,
-        c.LZO_E_OUTPUT_NOT_CONSUMED => Decompressor.Error.WriteFailed,
-        c.LZO_E_INTERNAL_ERROR => Decompressor.Error.ReadFailed,
-        else => Decompressor.Error.ReadFailed,
-    };
-}
@@ -1,142 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-const Decompressor = @import("../../decomp.zig");
-
-const Xz = @This();
-
-streams: std.AutoHashMap(std.Thread.Id, c.lzma_stream),
-
-interface: Decompressor,
-
-err: ?Error = null,
-
-pub fn init(alloc: std.mem.Allocator) !Xz {
-    return .{
-        .streams = try .init(alloc),
-        .interface = &.{
-            .alloc = alloc,
-            .vtable = .{ .decompress = decompress, .stateless = stateless },
-        },
-    };
-}
-pub fn deinit(self: *Xz) void {
-    var values = self.streams.valueIterator();
-    while (values.next()) |val| {
-        c.xz_end(val);
-    }
-    self.streams.deinit();
-}
-
-fn getOrCreate(self: *Xz) !*c.xz_stream {
-    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
-    if (res.found_existing) return res.value_ptr;
-    res.value_ptr.* = .{
-        .alloc = .{
-            .alloc = lzmaAlloc,
-            .free = lzmaFree,
-            .@"opaque" = &self.interface.alloc,
-        },
-    };
-    return res.value_ptr;
-}
-
-fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
-    var self: *Xz = @fieldParentPtr("interface", decomp);
-
-    const stream = try self.getOrCreate();
-    stream.next_in = in.ptr;
-    stream.avail_in = in.len;
-    stream.next_out = out.ptr;
-    stream.avail_out = out.len;
-    var res = c.lzma_alone_decoder(stream, out.len);
-    decodeResult(res) catch |err| {
-        self.err = err;
-        return xzErrorToDecompError(err);
-    };
-    while (true) {
-        res = c.lzma_code(&stream, c.LZMA_RUN);
-        if (res == c.LZMA_OK) continue;
-        if (res == c.LZMA_STREAM_END) break;
-        decodeResult(res) catch |err| {
-            self.err = err;
-            return xzErrorToDecompError(err);
-        };
-    }
-    return stream.total_out;
-}
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var stream: c.lzma_stream = .{
-        .next_in = in.ptr,
-        .avail_in = in.len,
-        .next_out = out.ptr,
-        .avail_out = out.len,
-        .allocator = &.{
-            .alloc = lzmaAlloc,
-            .free = lzmaFree,
-            .@"opaque" = @ptrCast(@constCast(&alloc)),
-        },
-    };
-    var res = c.lzma_alone_decoder(&stream, out.len);
-    decodeResult(res) catch |err| return xzErrorToDecompError(err);
-    while (true) {
-        res = c.lzma_code(&stream, c.LZMA_RUN);
-        if (res == c.LZMA_OK) continue;
-        if (res == c.LZMA_STREAM_END) break;
-        decodeResult(res) catch |err| return xzErrorToDecompError(err);
-    }
-    return stream.total_out;
-}
-
-inline fn decodeResult(res: c_uint) Error!void {
-    return switch (res) {
-        c.LZMA_OK => {},
-        c.LZMA_STREAM_END => {},
-        c.LZMA_NO_CHECK => {},
-        c.LZMA_UNSUPPORTED_CHECK => Error.UnsupportedCheck,
-        c.LZMA_MEM_ERROR => Error.OutOfMemory,
-        c.LZMA_MEMLIMIT_ERROR => Error.OutOfMemory,
-        c.LZMA_FORMAT_ERROR => Error.Format,
-        c.LZMA_OPTIONS_ERROR => Error.Options,
-        c.LZMA_DATA_ERROR => Error.Data,
-        c.LZMA_BUF_ERROR => Error.BufferExhausted,
-        c.LZMA_PROG_ERROR => Error.Programming,
-        c.LZMA_SEEK_NEEDED => Error.SeekNeeded,
-        else => Error.Unknown,
-    };
-}
-fn xzErrorToDecompError(err: Error) Decompressor.Error {
-    switch (err) {
-        Error.OutOfMemory => return Decompressor.Error.OutOfMemory,
-        Error.UnsupportedCheck => return Decompressor.Error.ReadFailed,
-        Error.Format => return Decompressor.Error.ReadFailed,
-        Error.Options => return Decompressor.Error.ReadFailed,
-        Error.Data => return Decompressor.Error.ReadFailed,
-        Error.BufferExhausted => return Decompressor.Error.WriteFailed,
-        Error.Programming => return Decompressor.Error.ReadFailed,
-        Error.SeekNeeded => return Decompressor.Error.ReadFailed,
-        Error.Unknown => return Decompressor.Error.ReadFailed,
-    }
-}
-
-fn lzmaAlloc(ptr: ?*anyopaque, _: usize, size: usize) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
-    return alloc.rawAlloc(size, .@"1", 0);
-}
-fn lzmaFree(ptr: ?*anyopaque, alloc_ptr: ?*anyopaque) callconv(.c) void {
-    if (alloc_ptr == null) return;
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
-    alloc.rawFree(@ptrCast(alloc_ptr), .@"1", 0);
-}
-
-pub const Error = error{
-    OutOfMemory,
-    UnsupportedCheck,
-    Format,
-    Options,
-    Data,
-    BufferExhausted,
-    Programming,
-    SeekNeeded,
-    Unknown,
-};
@@ -1,106 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-const Decompressor = @import("../../decomp.zig");
-
-const Zlib = @This();
-
-streams: std.AutoHashMap(std.Thread.Id, c.zng_stream),
-
-interface: Decompressor,
-
-err: ?Error = null,
-
-pub fn init(alloc: std.mem.Allocator) !Zlib {
-    return .{
-        .streams = try .init(alloc),
-        .interface = &.{
-            .alloc = alloc,
-            .vtable = .{ .decompress = decompress, .stateless = stateless },
-        },
-    };
-}
-pub fn deinit(self: *Zlib) void {
-    var values = self.streams.valueIterator();
-    while (values.next()) |val| {
-        _ = c.zng_deflateEnd(val);
-    }
-    self.streams.deinit();
-}
-
-fn getOrCreate(self: *Zlib) !*c.zng_stream {
-    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
-    if (res.found_existing) return res.value_ptr;
-    res.value_ptr.* = .{
-        .@"opaque" = self,
-        .zalloc = zalloc,
-        .zfree = zfree,
-    };
-    return res.value_ptr;
-}
-
-fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
-    var self: *Zlib = @fieldParentPtr("interface", decomp);
-
-    var stream = try self.getOrCreate();
-    stream.next_in = in.ptr;
-    stream.avail_in = in.len;
-    stream.next_out = out.ptr;
-    stream.avail_out = out.len;
-    var res = c.zng_inflateReset(stream);
-    decodeError(res) catch |err| {
-        self.err = err;
-        return Decompressor.Error.ReadFailed;
-    };
-    res = c.zng_inflate(stream, c.Z_FINISH);
-    decodeError(res) catch |err| {
-        self.err = err;
-        return switch (err) {
-            Error.OutOfMemory => err,
-            else => Decompressor.Error.ReadFailed,
-        };
-    };
-}
-
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    _ = alloc;
-    var out_len = out.len;
-    const res = c.zng_uncompress(out.ptr, &out_len, in.ptr, in.len);
-    return switch (res) {
-        c.Z_OK => out_len,
-        c.Z_MEM_ERROR => Decompressor.Error.OutOfMemory,
-        c.Z_BUF_ERROR => Decompressor.Error.WriteFailed,
-        else => Decompressor.Error.ReadFailed,
-    };
-}
-
-inline fn decodeError(res: i32) Error!void {
-    return switch (res) {
-        c.Z_OK => {},
-        c.Z_STREAM_ERROR => Error.Stream,
-        c.Z_BUF_ERROR => Error.Buffer,
-        c.Z_MEM_ERROR => Error.OutOfMemory,
-        c.Z_DATA_ERROR => Error.Data,
-        c.Z_VERSION_ERROR => Error.Version,
-        else => Error.Unknown,
-    };
-}
-
-fn zalloc(ptr: ?*anyopaque, items: c_uint, size: c_uint) callconv(.c) ?*anyopaque {
-    var self: *Zlib = @ptrCast(ptr);
-    return self.interface.alloc.rawAlloc(items * size, .@"1", 0);
-}
-
-fn zfree(ptr: ?*anyopaque, addr: ?*anyopaque) callconv(.c) void {
-    var self: *Zlib = @ptrCast(ptr);
-    self.interface.alloc.rawFree(@ptrCast(addr), .@"1", 0);
-}
-
-pub const Error = error{
-    OutOfMemory,
-    Stream,
-    Buffer,
-    Data,
-    Version,
-    Unknown,
-};
@@ -1,172 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-const Decompressor = @import("../../decomp.zig");
-
-const Zstd = @This();
-
-context: std.AutoHashMap(std.Thread.Id, ?*c.ZSTD_DCtx),
-
-interface: Decompressor,
-
-err: ?Error = null,
-
-pub fn init(alloc: std.mem.Allocator) !Zstd {
-    return .{
-        .streams = try .init(alloc),
-        .interface = &.{
-            .alloc = alloc,
-            .vtable = .{ .decompress = decompress, .stateless = stateless },
-        },
-    };
-}
-pub fn deinit(self: *Zstd) void {
-    var values = self.context.valueIterator();
-    while (values.next()) |val| {
-        _ = c.ZSTD_freeDCtx(val.*);
-    }
-    self.context.deinit();
-}
-
-fn getOrCreate(self: *Zstd) !*c.ZSTD_DCtx {
-    const res = try self.context.getOrPut(std.Thread.getCurrentId());
-    if (res.found_existing) return res.value_ptr;
-    res.value_ptr.* = c.ZSTD_createDCtx();
-    if (res.value_ptr.* == null) return Error.OutOfMemory;
-    return res.value_ptr;
-}
-
-fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
-    var self: *Zstd = @fieldParentPtr("interface", decomp);
-
-    const ctx = self.getOrCreate();
-    const res = c.ZSTD_decompressDCtx(ctx, out.ptr, out.len, in.ptr, in.len);
-    decodeError(res) catch |err| {
-        self.err = err;
-        return ZstdErrorToDecompError(err);
-    };
-    return res;
-}
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    _ = alloc;
-    const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
-    decodeError(res) catch |err| return ZstdErrorToDecompError(err);
-    return res;
-}
-
-inline fn decodeError(res: usize) Error!void {
-    if (c.ZSTD_isError(res) == 0) return;
-    return switch (c.ZSTD_getErrorCode(res)) {
-        c.ZSTD_error_prefix_unknown => Error.PrefixUnknown,
-        c.ZSTD_error_version_unsupported => Error.VersionUnsupported,
-        c.ZSTD_error_frameParameter_unsupported => Error.FrameParameterUnsupported,
-        c.ZSTD_error_frameParameter_windowTooLarge => Error.FrameParameterWindowTooLarge,
-        c.ZSTD_error_corruption_detected => Error.CorruptionDetected,
-        c.ZSTD_error_checksum_wrong => Error.ChecksumWrong,
-        c.ZSTD_error_literals_headerWrong => Error.LiteralsHeaderWrong,
-        c.ZSTD_error_dictionary_corrupted => Error.DictionaryCorrupted,
-        c.ZSTD_error_dictionary_wrong => Error.DictionaryWrong,
-        c.ZSTD_error_dictionaryCreation_failed => Error.DictionaryCreationFailed,
-        c.ZSTD_error_parameter_unsupported => Error.ParameterUnsupported,
-        c.ZSTD_error_parameter_combination_unsupported => Error.ParameterCombinationUnsupported,
-        c.ZSTD_error_parameter_outOfBound => Error.ParameterOutOfBound,
-        c.ZSTD_error_tableLog_tooLarge => Error.TableLogTooLarge,
-        c.ZSTD_error_maxSymbolValue_tooLarge => Error.MaxSymbolValueTooLarge,
-        c.ZSTD_error_maxSymbolValue_tooSmall => Error.MaxSymbolValueTooSmall,
-        c.ZSTD_error_cannotProduce_uncompressedBlock => Error.CannotProduceUncompressedBlock,
-        c.ZSTD_error_stabilityCondition_notRespected => Error.StabilityConditionNotRespected,
-        c.ZSTD_error_stage_wrong => Error.StageWrong,
-        c.ZSTD_error_init_missing => Error.InitMissing,
-        c.ZSTD_error_memory_allocation => Error.MemoryAllocation,
-        c.ZSTD_error_workSpace_tooSmall => Error.WorkSpaceTooSmall,
-        c.ZSTD_error_dstSize_tooSmall => Error.DstSizeTooSmall,
-        c.ZSTD_error_srcSize_wrong => Error.SrcSizeWrong,
-        c.ZSTD_error_dstBuffer_null => Error.DstBufferNull,
-        c.ZSTD_error_noForwardProgress_destFull => Error.NoForwardProgressDestFull,
-        c.ZSTD_error_noForwardProgress_inputEmpty => Error.NoForwardProgressInputEmpty,
-        c.ZSTD_error_frameIndex_tooLarge => Error.FrameIndexTooLarge,
-        c.ZSTD_error_seekableIO => Error.SeekableIo,
-        c.ZSTD_error_dstBuffer_wrong => Error.DstBufferWrong,
-        c.ZSTD_error_srcBuffer_wrong => Error.SrcBufferWrong,
-        c.ZSTD_error_sequenceProducer_failed => Error.SequenceProducerFailed,
-        c.ZSTD_error_externalSequences_invalid => Error.ExternalSequencesInvalid,
-        else => Error.Generic,
-    };
-}
-inline fn ZstdErrorToDecompError(err: Error) Decompressor.Error {
-    return switch (err) {
-        Error.OutOfMemory => Decompressor.Error.OutOfMemory,
-        Error.Generic => Decompressor.Error.ReadFailed,
-        Error.PrefixUnknown => Decompressor.Error.ReadFailed,
-        Error.VersionUnsupported => Decompressor.Error.ReadFailed,
-        Error.FrameParameterUnsupported => Decompressor.Error.ReadFailed,
-        Error.FrameParameterWindowTooLarge => Decompressor.Error.ReadFailed,
-        Error.CorruptionDetected => Decompressor.Error.ReadFailed,
-        Error.ChecksumWrong => Decompressor.Error.ReadFailed,
-        Error.LiteralsHeaderWrong => Decompressor.Error.ReadFailed,
-        Error.DictionaryCorrupted => Decompressor.Error.ReadFailed,
-        Error.DictionaryWrong => Decompressor.Error.ReadFailed,
-        Error.DictionaryCreationFailed => Decompressor.Error.ReadFailed,
-        Error.ParameterUnsupported => Decompressor.Error.ReadFailed,
-        Error.ParameterCombinationUnsupported => Decompressor.Error.ReadFailed,
-        Error.ParameterOutOfBound => Decompressor.Error.ReadFailed,
-        Error.TableLogTooLarge => Decompressor.Error.ReadFailed,
-        Error.MaxSymbolValueTooLarge => Decompressor.Error.ReadFailed,
-        Error.MaxSymbolValueTooSmall => Decompressor.Error.ReadFailed,
-        Error.CannotProduceUncompressedBlock => Decompressor.Error.ReadFailed,
-        Error.StabilityConditionNotRespected => Decompressor.Error.ReadFailed,
-        Error.StageWrong => Decompressor.Error.ReadFailed,
-        Error.InitMissing => Decompressor.Error.ReadFailed,
-        Error.MemoryAllocation => Decompressor.Error.OutOfMemory,
-        Error.WorkSpaceTooSmall => Decompressor.Error.WriteFailed,
-        Error.DstSizeTooSmall => Decompressor.Error.WriteFailed,
-        Error.SrcSizeWrong => Decompressor.Error.ReadFailed,
-        Error.DstBufferNull => Decompressor.Error.WriteFailed,
-        Error.NoForwardProgressDestFull => Decompressor.Error.WriteFailed,
-        Error.NoForwardProgressInputEmpty => Decompressor.Error.ReadFailed,
-        Error.FrameIndexTooLarge => Decompressor.Error.ReadFailed,
-        Error.SeekableIo => Decompressor.Error.ReadFailed,
-        Error.DstBufferWrong => Decompressor.Error.WriteFailed,
-        Error.SrcBufferWrong => Decompressor.Error.ReadFailed,
-        Error.SequenceProducerFailed => Decompressor.Error.ReadFailed,
-        Error.ExternalSequencesInvalid => Decompressor.Error.ReadFailed,
-    };
-}
-
-pub const Error = error{
-    OutOfMemory,
-    Generic,
-    PrefixUnknown,
-    VersionUnsupported,
-    FrameParameterUnsupported,
-    FrameParameterWindowTooLarge,
-    CorruptionDetected,
-    ChecksumWrong,
-    LiteralsHeaderWrong,
-    DictionaryCorrupted,
-    DictionaryWrong,
-    DictionaryCreationFailed,
-    ParameterUnsupported,
-    ParameterCombinationUnsupported,
-    ParameterOutOfBound,
-    TableLogTooLarge,
-    MaxSymbolValueTooLarge,
-    MaxSymbolValueTooSmall,
-    CannotProduceUncompressedBlock,
-    StabilityConditionNotRespected,
-    StageWrong,
-    InitMissing,
-    MemoryAllocation,
-    WorkSpaceTooSmall,
-    DstSizeTooSmall,
-    SrcSizeWrong,
-    DstBufferNull,
-    NoForwardProgressDestFull,
-    NoForwardProgressInputEmpty,
-    FrameIndexTooLarge,
-    SeekableIo,
-    DstBufferWrong,
-    SrcBufferWrong,
-    SequenceProducerFailed,
-    ExternalSequencesInvalid,
-};
@@ -1,64 +0,0 @@
-const config = @import("config");
-
-const Decompressor = @import("../decomp.zig");
-
-pub fn getStatelessFn(decomp: Enum) !Decompressor.StatelessDecomp {
-    if (config.use_zig_decomp) {
-        return switch (decomp) {
-            .gzip => @import("zig/zlib.zig").stateless,
-            .lzma => @import("zig/lzma.zig").stateless,
-            .xz => @import("zig/xz.zig").stateless,
-            .zstd => @import("zig/zstd.zig").stateless,
-            .lz4 => error.ZigLz4Unsupported,
-            .lzo => error.ZigLzoUnsupported,
-        };
-    }
-    return switch (decomp) {
-        .gzip => @import("c/zlib.zig").stateless,
-        .lzma => @import("c/lzma.zig").stateless,
-        .lzo => @import("c/lzo.zig").stateless,
-        .xz => @import("c/xz.zig").stateless,
-        .lz4 => @import("c/lz4.zig").stateless,
-        .zstd => @import("c/zstd.zig").stateless,
-    };
-}
-
-pub const Enum = enum(u16) {
-    gzip = 1, // Though officially named gzip, it actually uses zlib.
-    lzma,
-    lzo,
-    xz,
-    lz4,
-    zstd,
-};
-
-pub const Decomp = if (config.use_zig_decomp)
-    union(enum) {
-        gzip: @import("zig/zlib.zig"),
-        lzma: @import("zig/lzma.zig"),
-        xz: @import("zig/xz.zig"),
-        zstd: @import("zig/zstd.zig"),
-
-        pub fn deinit(_: *Decomp) void {
-            return;
-        }
-    }
-else
-    union(enum) {
-        gzip: @import("c/zlib.zig"),
-        lzma: @import("c/lzma.zig"),
-        lzo: @import("c/lzo.zig"),
-        xz: @import("c/xz.zig"),
-        lz4: @import("c/lz4.zig"),
-        zstd: @import("c/zstd.zig"),
-
-        pub fn deinit(self: *Decomp) void {
-            switch (self) {
-                .gzip => self.gzip.deinit(),
-                .lzma => self.lzma.deinit(),
-                .xz => self.xz.deinit(),
-                .zstd => self.zstd.deinit(),
-                else => {},
-            }
-        }
-    };
@@ -1,23 +0,0 @@
-const std = @import("std");
-const lzma = std.compress.lzma;
-const Reader = std.Io.Reader;
-
-const Decompressor = @import("../../decomp.zig");
-
-interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
-
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var rdr: Reader = .fixed(in);
-    const buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-
-    var decomp = lzma.Decompress.initOptions(&rdr, alloc, buf, .{}, out.len) catch |err|
-        return switch (err) {
-            error.Overflow => Decompressor.Error.ReadFailed,
-            error.CorruptInput => Decompressor.Error.ReadFailed,
-            error.InvalidRangeCode => Decompressor.Error.ReadFailed,
-            else => @errorCast(err),
-        };
-    defer decomp.deinit();
-    return decomp.reader.readSliceShort(out);
-}
@@ -1,22 +0,0 @@
-const std = @import("std");
-const xz = std.compress.xz;
-const Reader = std.Io.Reader;
-
-const Decompressor = @import("../../decomp.zig");
-
-interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
-
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var rdr: Reader = .fixed(in);
-    const buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-
-    var decomp = xz.Decompress.init(&rdr, alloc, buf) catch |err|
-        return switch (err) {
-            error.WrongChecksum => Decompressor.Error.ReadFailed,
-            error.NotXzStream => Decompressor.Error.ReadFailed,
-            else => @errorCast(err),
-        };
-    defer decomp.deinit();
-    return decomp.reader.readSliceShort(out);
-}
@@ -1,16 +0,0 @@
-const std = @import("std");
-const flate = std.compress.flate;
-const Reader = std.Io.Reader;
-
-const Decompressor = @import("../../decomp.zig");
-
-interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
-
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var rdr: Reader = .fixed(in);
-    const buf = try alloc.alloc(u8, out.len);
-    defer alloc.free(buf);
-
-    var decomp = flate.Decompress.init(&rdr, .zlib, buf);
-    return decomp.reader.readSliceShort(out);
-}
@@ -1,16 +0,0 @@
-const std = @import("std");
-const zstd = std.compress.zstd;
-const Reader = std.Io.Reader;
-
-const Decompressor = @import("../../decomp.zig");
-
-interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
-
-pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
-    var rdr: Reader = .fixed(in);
-    const buf = try alloc.alloc(u8, out.len * 2);
-    defer alloc.free(buf);
-
-    var decomp = zstd.Decompress.init(&rdr, buf, .{ .window_len = @truncate(out.len) });
-    return decomp.reader.readSliceShort(out);
-}
@@ -0,0 +1,116 @@
+const std = @import("std");
+const Io = std.Io;
+const File = Io.File;
+const MemoryMap = File.MemoryMap;
+const Atomic = std.atomic.Value;
+
+const Decomp = @import("decomp.zig");
+
+const DecompCache = @This();
+
+alloc: std.mem.Allocator,
+map: MemoryMap,
+decomp_fn: Decomp.Fn,
+
+cache: std.AutoHashMap(u64, Cache),
+mut: std.Io.RwLock = .init,
+cond: std.Io.Condition = .init,
+
+max_mem: u64,
+cur_mem: u64 = 0,
+
+pub fn init(alloc: std.mem.Allocator, map: MemoryMap, compression: Decomp.Enum, max_mem: u64) !DecompCache {
+    return .{
+        .alloc = alloc,
+        .map = map,
+        .decomp_fn = try Decomp.DecompFn(compression),
+
+        .cache = .init(alloc),
+
+        .max_mem = max_mem,
+    };
+}
+pub fn deinit(self: *DecompCache, io: Io) void {
+    self.mut.lockUncancelable(io);
+
+    var iter = self.cache.valueIterator();
+    while (iter.next()) |v|
+        self.alloc.free(v.data);
+    self.cache.deinit();
+}
+
+pub fn get(self: *DecompCache, io: Io, offset: u64, compressed_size: u32, max_size: u32) ![]u8 {
+    {
+        try self.mut.lockShared(io);
+        defer self.mut.unlockShared(io);
+
+        const cache = self.cache.getPtr(offset);
+        if (cache != null) {
+            _ = cache.?.usage.fetchAdd(1, .acquire);
+            return cache.?.data;
+        }
+    }
+    try self.mut.lock(io);
+    defer self.mut.unlock(io);
+
+    const cache = try self.cache.getOrPut(offset);
+    if (cache.found_existing) {
+        _ = cache.value_ptr.usage.fetchAdd(1, .acquire);
+        return cache.value_ptr.data;
+    }
+    errdefer self.cache.removeByPtr(cache.key_ptr);
+
+    try self.ensureSpace(io, max_size);
+
+    var out = try self.alloc.alloc(u8, max_size);
+    errdefer self.alloc.free(out);
+
+    const decomp_size = try self.decomp_fn(self.alloc, self.map.memory[offset..][0..compressed_size], out);
+    if (decomp_size != max_size) {
+        if (!self.alloc.resize(out, decomp_size)) {
+            const new_out = try self.alloc.alloc(u8, decomp_size);
+            @memcpy(new_out, out[0..decomp_size]);
+            out = new_out;
+        } else {
+            out.len = decomp_size;
+        }
+    }
+    self.cur_mem += decomp_size;
+
+    cache.value_ptr.data = out;
+    _ = cache.value_ptr.usage.fetchAdd(1, .acquire);
+    return out;
+}
+pub fn finished(self: *DecompCache, io: Io, offset: u64) void {
+    const cache = self.cache.getPtr(offset);
+    if (cache == null) {
+        std.debug.print("Finished using cache, but cache does not exist: {}\n", .{offset});
+        return;
+    }
+    const use = cache.?.usage.fetchSub(1, .acquire);
+    if (use == 0)
+        self.cond.broadcast(io);
+}
+
+fn ensureSpace(self: *DecompCache, io: Io, size: u64) !void {
+    while (self.cur_mem + size > self.max_mem) {
+        var iter = self.cache.valueIterator();
+        while (iter.next()) |cache| {
+            if (cache.usage.load(.unordered) == 0) {
+                self.alloc.free(cache.data);
+                self.cur_mem -= cache.data.len;
+
+                if (self.cur_mem + size <= self.max_mem) return;
+            }
+        }
+        if (self.cur_mem + size <= self.max_mem) return;
+        try self.cond.wait(io, &self.mut.mutex);
+    }
+}
+
+// Types
+
+const Cache = struct {
+    data: []u8,
+    usage: Atomic(u32),
+};
@@ -1,63 +1,83 @@
 const std = @import("std");
-const Reader = std.Io.Reader;
+const Io = std.Io;
+const Reader = Io.Reader;

-const InodeType = @import("inode.zig").Type;
+const Inode = @import("inode.zig");

-pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) []Entry {
-    var read: u32 = 3;
-    var hdr: Header = undefined;
-    var raw: RawEntry = undefined;
-    var out: std.ArrayList(Entry) = .initCapacity(alloc, 50);
+const Directory = @This();
+
+entries: []Entry,
+
+pub fn init(alloc: std.mem.Allocator, rdr: *Reader, size: u32) Error!Directory {
+    if (size <= 3) return .{ .entries = &[0]Entry{} };
+
+    var entries: std.ArrayList(Entry) = try .initCapacity(alloc, 50);
    errdefer {
-        for (out.items) |i|
-            alloc.free(i.name);
-        out.deinit(alloc);
+        for (entries.items) |ent|
+            ent.deinit(alloc);
+        entries.deinit(alloc);
    }
+
+    var read: u32 = 3;
    while (read < size) {
+        var hdr: Header = undefined;
        try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
-        try out.ensureUnusedCapacity(alloc, hdr.count + 1);
        read += @sizeOf(Header);
+
+        try entries.ensureUnusedCapacity(alloc, hdr.count + 1);
        for (0..hdr.count + 1) |_| {
+            var raw: RawEntry = undefined;
            try rdr.readSliceEndian(RawEntry, @ptrCast(&raw), .little);
-            read += @sizeOf(RawEntry) + raw.name_size + 1;
-            const new = out.addOneAssumeCapacity();
-            new.* = .{
+
+            const name = try alloc.alloc(u8, raw.name_size + 1);
+            errdefer alloc.free(name);
+            try rdr.readSliceEndian(u8, name, .little);
+
+            entries.appendAssumeCapacity(.{
+                .inode_num = if (raw.inode_num_offset > 0)
+                    hdr.inode_num + @abs(raw.inode_num_offset)
+                else
+                    hdr.inode_num - @abs(raw.inode_num_offset),
                .block_start = hdr.block_start,
                .block_offset = raw.block_offset,
-                .num = @abs(hdr.num + raw.num_offset),
-                .inode_type = raw.inode_type,
-                .name = try alloc.alloc(u8, raw.name_size + 1),
-            };
-            try rdr.readSliceEndian(u8, new.name, .little);
+                .type = raw.type,
+                .name = name,
+            });
        }
    }
-    return out.toOwnedSlice(alloc);
+
+    return .{ .entries = try entries.toOwnedSlice(alloc) };
+}
+pub fn deinit(self: Directory, alloc: std.mem.Allocator) void {
+    for (self.entries) |entry|
+        entry.deinit(alloc);
+    alloc.free(self.entries);
 }

 // Types

+pub const Error = Reader.Error || std.mem.Allocator.Error;
+
 pub const Entry = struct {
+    inode_num: u32,
    block_start: u32,
    block_offset: u16,
-    num: u32,
-    inode_type: InodeType,
-    name: []u8,
+    type: Inode.Enum,
+    name: []const u8,

    pub fn deinit(self: Entry, alloc: std.mem.Allocator) void {
        alloc.free(self.name);
    }
 };

-// extern instead of packed due to alignment issues (packed will read it as 16 bytes instead of 12).
 const Header = extern struct {
    count: u32,
    block_start: u32,
-    num: u32,
+    inode_num: u32,
 };
-
-const RawEntry = packed struct {
+const RawEntry = extern struct {
    block_offset: u16,
-    num_offset: i16,
-    inode_type: InodeType,
+    inode_num_offset: i16,
+    type: Inode.Enum,
    name_size: u16,
 };
@@ -0,0 +1,283 @@
+const std = @import("std");
+const Io = std.Io;
+
+const Atomic = std.atomic.Value;
+
+const DecompCache = @import("decomp_cache.zig");
+const ExtractionOptions = @import("options.zig");
+const Inode = @import("inode.zig");
+const Superblock = @import("archive.zig").Superblock;
+const Directory = @import("directory.zig");
+const DataExtractor = @import("data/extractor.zig");
+const DataReader = @import("data/reader.zig");
+const Lookup = @import("lookup.zig");
+
+pub fn extract(alloc: std.mem.Allocator, io: Io, inode: Inode, cache: *DecompCache, super: Superblock, ext_loc: []const u8, options: ExtractionOptions) !void {
+    const path = std.mem.trim(u8, ext_loc, "/");
+
+    var buf: [50]ReturnUnion = undefined;
+    var sel: Io.Select(ReturnUnion) = .init(io, &buf);
+
+    defer {
+        while (sel.cancel()) |ret| {
+            switch (ret) {
+                .dir_ret => |d| {
+                    const res = d catch continue;
+                    alloc.free(res.path);
+                },
+                .file_ret => |f| {
+                    const res = f catch continue;
+                    alloc.free(res.path);
+                },
+                else => {},
+            }
+        }
+    }
+
+    var frag_table: Lookup.Table(Lookup.FragmentEntry) = .init(alloc, cache, super.frag_start, super.frag_count);
+    defer frag_table.deinit();
+
+    var ret_loop = io.async(returnLoop, .{ alloc, &sel, options });
+
+    try extractReal(alloc, io, cache, super, &sel, &frag_table, path, inode, null, false);
+
+    ret_loop.await(io) catch |err| {
+        // TODO: Drain sel
+        return err;
+    };
+}
+
+fn extractReal(
+    alloc: std.mem.Allocator,
+    io: Io,
+    cache: *DecompCache,
+    super: Superblock,
+    sel: *Io.Select(ReturnUnion),
+    frag_table: *Lookup.Table(Lookup.FragmentEntry),
+    path: []const u8,
+    inode: Inode,
+    parent: ?*Atomic(usize),
+    origin: bool,
+) Error!void {
+    try io.checkCancel();
+
+    switch (inode.data) {
+        .dir, .ext_dir => sel.async(
+            .dir_ret,
+            extractDir,
+            .{ alloc, io, cache, super, sel, frag_table, path, inode, parent, origin },
+        ),
+        .file, .ext_file => sel.async(
+            .file_ret,
+            extractFile,
+            .{ alloc, io, cache, super.block_size, frag_table, path, inode, parent, origin },
+        ),
+        else => return error.Canceled,
+    }
+}
+
+fn extractDir(
+    alloc: std.mem.Allocator,
+    io: Io,
+    cache: *DecompCache,
+    super: Superblock,
+    sel: *Io.Select(ReturnUnion),
+    frag_table: *Lookup.Table(Lookup.FragmentEntry),
+    path: []const u8,
+    inode: Inode,
+    parent: ?*Atomic(usize),
+    origin: bool,
+) Error!DirReturn {
+    defer {
+        if (parent != null)
+            _ = parent.?.fetchSub(1, .acquire);
+        if (!origin) inode.deinit(alloc);
+    }
+    errdefer if (!origin) alloc.free(path);
+
+    const dir = inode.directory(alloc, io, cache, super.dir_start) catch |err| switch (err) {
+        error.NotDirectory => unreachable,
+        else => |e| return e,
+    };
+    defer dir.deinit(alloc);
+
+    const sub_files = try alloc.create(Atomic(usize));
+    sub_files.* = .init(dir.entries.len);
+
+    const ret: DirReturn = .{
+        .path = path,
+        .sub_files = sub_files,
+        .origin = origin,
+
+        .uid_idx = inode.hdr.uid_idx,
+        .gid_idx = inode.hdr.gid_idx,
+        .mod_time = inode.hdr.mod_time,
+        .permissions = inode.hdr.permission,
+
+        .xattr_idx = switch (inode.data) {
+            .ext_dir => |d| if (d.xattr_idx != 0xFFFFFFFF) d.xattr_idx else null,
+            else => null,
+        },
+    };
+
+    for (dir.entries) |entry| {
+        const new_inode: Inode = try .initDirEntry(alloc, io, cache, super.inode_start, super.block_size, entry);
+        errdefer new_inode.deinit(alloc);
+
+        const new_path = try std.mem.concat(alloc, u8, &.{ path, "/", entry.name });
+
+        try extractReal(
+            alloc,
+            io,
+            cache,
+            super,
+            sel,
+            frag_table,
+            new_path,
+            new_inode,
+            sub_files,
+            false,
+        );
+    }
+    return ret;
+}
+fn extractFile(
+    alloc: std.mem.Allocator,
+    io: Io,
+    cache: *DecompCache,
+    block_size: u32,
+    frag_table: *Lookup.Table(Lookup.FragmentEntry),
+    path: []const u8,
+    inode: Inode,
+    parent: ?*Atomic(usize),
+    origin: bool,
+) Error!FileReturn {
+    defer {
+        if (parent != null)
+            _ = parent.?.fetchSub(1, .acquire);
+        if (!origin) inode.deinit(alloc);
+    }
+    errdefer if (!origin) alloc.free(path);
+
+    var atomic = try Io.Dir.cwd().createFileAtomic(io, path, .{});
+    defer atomic.deinit(io);
+
+    var ret: FileReturn = .{
+        .path = path,
+        .origin = origin,
+
+        .uid_idx = inode.hdr.uid_idx,
+        .gid_idx = inode.hdr.gid_idx,
+        .permissions = inode.hdr.permission,
+        .mod_time = inode.hdr.mod_time,
+    };
+
+    const data: DataExtractor = switch (inode.data) {
+        .file => |f| blk: {
+            var data: DataExtractor = .init(cache, block_size, f.size, f.data_start, f.blocks);
+            if (f.frag_idx != 0xFFFFFFFF) {
+                const entry: Lookup.FragmentEntry = try frag_table.get(io, f.frag_idx);
+                if (entry.size.uncompressed) {
+                    data.addFragment(cache.map.memory[entry.start..][0..entry.size.size], f.frag_offset);
+                } else {
+                    const block = try cache.get(io, entry.start, entry.size.size, block_size);
+                    data.addFragment(block, f.frag_offset);
+                }
+            }
+            break :blk data;
+        },
+        .ext_file => |f| blk: {
+            var data: DataExtractor = .init(cache, block_size, f.size, f.data_start, f.blocks);
+            if (f.frag_idx != 0xFFFFFFFF) {
+                const entry: Lookup.FragmentEntry = try frag_table.get(io, f.frag_idx);
+                if (entry.size.uncompressed) {
+                    data.addFragment(cache.map.memory[entry.start..][0..entry.size.size], f.frag_offset);
+                } else {
+                    const block = try cache.get(io, entry.start, entry.size.size, block_size);
+                    data.addFragment(block, f.frag_offset);
+                }
+            }
+            if (f.xattr_idx != 0xFFFFFFFF)
+                ret.xattr_idx = f.xattr_idx;
+            break :blk data;
+        },
+        else => unreachable,
+    };
+    try data.asyncExtract(io, atomic.file);
+
+    try atomic.link(io);
+
+    return ret;
+}
+
+// Loop
+
+fn returnLoop(alloc: std.mem.Allocator, sel: *Io.Select(ReturnUnion), options: ExtractionOptions) !void {
+    while (true) {
+        const finished = try sel.await();
+
+        switch (finished) {
+            .dir_ret => |d| {
+                const ret = try d;
+                if (ret.sub_files.load(.unordered) != 0) {
+                    sel.queue.putOne(sel.io, .{ .dir_ret = ret }) catch |err| {
+                        if (!ret.origin) alloc.free(ret.path);
+                        return err;
+                    };
+                    continue;
+                }
+                if (!ret.origin) alloc.free(ret.path);
+                alloc.destroy(ret.sub_files);
+
+                if (!options.ignore_permissions and !options.ignore_xattr) {
+                    // TODO: set permissions & xattr.
+                }
+            },
+            .file_ret => |f| {
+                const ret = try f;
+                if (!ret.origin) alloc.free(ret.path);
+
+                if (!options.ignore_permissions and !options.ignore_xattr) {
+                    // TODO: set permissions & xattr.
+                }
+            },
+            .void_ret => |v| try v,
+        }
+
+        if (sel.group.token.load(.unordered) == null) break;
+    }
+}
+
+// Utility types
+
+const ReturnUnion = union(enum) {
+    file_ret: Error!FileReturn,
+    dir_ret: Error!DirReturn,
+    void_ret: Error!void,
+};
+
+const Error = error{Canceled} || Directory.Error || Io.Dir.CreateFileAtomicError || Io.File.Atomic.LinkError || DataExtractor.Error;
+
+const FileReturn = struct {
+    path: []const u8,
+    origin: bool,
+
+    uid_idx: u32,
+    gid_idx: u32,
+    mod_time: u32,
+    permissions: u16,
+
+    xattr_idx: ?u32 = null,
+};
+const DirReturn = struct {
+    path: []const u8,
+    sub_files: *Atomic(usize),
+    origin: bool,
+
+    uid_idx: u32,
+    gid_idx: u32,
+    mod_time: u32,
+    permissions: u16,
+
+    xattr_idx: ?u32 = null,
+};
@@ -2,117 +2,101 @@ const std = @import("std");
 const Io = std.Io;

 const Archive = @import("archive.zig");
-const Decompressor = @import("decomp.zig");
 const Directory = @import("directory.zig");
 const ExtractionOptions = @import("options.zig");
 const Inode = @import("inode.zig");
-const DataReader = @import("util/data_reader.zig");
-const FileIter = @import("util/iter.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-const Utils = @import("util/utils.zig");

-pub const Error = error{
-    NotDirectory,
-    NotRegularFile,
-};
+const SfsFile = @This();

-const File = @This();
+alloc: std.mem.Allocator,
+archive: *Archive,

-file: OffsetFile,
-super: Archive.MinimalSuperblock,
-decomp: Decompressor,
-
-name: []const u8,
 inode: Inode,
+name: []const u8,

-pub fn init(alloc: std.mem.Allocator, archive: Archive, entry: Directory.Entry) !File {
-    const new_name = try alloc.alloc(u8, entry.name.len);
-    errdefer alloc.free(new_name);
-    @memcpy(new_name, entry.name);
-    return .{
-        .file = archive.file,
-        .super = archive.super,
-        .decomp = archive.stateless_decomp.statelessCopy(alloc),
-        .name = new_name,
-        .inode = try Utils.readInode(
-            alloc,
-            &archive.decomp,
-            archive.file,
-            archive.super.inode_start,
-            archive.super.block_size,
-            entry.block_start,
-            entry.block_offset,
-        ),
-    };
-}
-pub fn deinit(self: File) void {
-    self.decomp.alloc.free(self.name);
-    self.inode.deinit(self.decomp.alloc);
-}
-
-// Directory functions
-
-pub fn isDir(self: File) bool {
-    return switch (self.inode.hdr.inode_type) {
-        .dir, .ext_dir => true,
-        else => false,
-    };
-}
-/// Opens a sub-file. If the given path is "" or "." (after trimming /) a copy of the File is returned.
-pub fn open(self: File, alloc: std.mem.Allocator, filepath: []const u8) !File {
-    var res = try self.inode.findInode(
-        alloc,
-        &self.decomp,
-        self.file,
-        self.super.dir_start,
-        self.super.inode_start,
-        self.super.block_size,
-        filepath,
-    );
-    if (res.name.len == 0) {
-        res.name = try alloc.alloc(u8, self.name.len);
-        @memcpy(res.name, self.name);
-    }
-    return .{
-        .file = self.file,
-        .super = self.super,
-        .decomp = self.decomp.statelessCopy(alloc),
-        .name = res.name,
-        .inode = res.inode,
-    };
-}
-pub fn iter(self: File, alloc: std.mem.Allocator) !FileIter {
+/// The given allocator must have been used to create the Inode and name.
+pub fn init(alloc: std.mem.Allocator, archive: *Archive, inode: Inode, name: []const u8) SfsFile {
    return .{
        .alloc = alloc,
-        .entries = try self.inode.readDirectory(alloc, &self.decomp, self.file, self.super.dir_start),
+        .archive = archive,
+
+        .inode = inode,
+        .name = name,
    };
 }
+pub fn initDirEntry(alloc: std.mem.Allocator, io: Io, archive: *Archive, entry: Directory.Entry) !SfsFile {
+    const new_name = try alloc.alloc(u8, entry.name.len);
+    defer alloc.free(new_name);
+    @memcpy(new_name, entry.name);

-// Regular file functions
+    return .{
+        .alloc = alloc,
+        .archive = archive,

-pub fn isRegularFile(self: File) bool {
-    return switch (self.inode.hdr.inode_type) {
-        .file, .ext_file => true,
-        else => false,
+        .inode = try .initDirEntry(
+            alloc,
+            io,
+            &archive.cache,
+            archive.super.inode_start,
+            archive.super.block_size,
+            entry,
+        ),
+        .name = new_name,
    };
 }
-// a std.Io.Reader compatible reader that reads a regular file's data.
-pub fn dataReader(self: File, alloc: std.mem.Allocator) !DataReader {
-    return self.inode.dataReader(
-        &self.decomp.statelessCopy(alloc),
-        self.file,
-        self.super.frag_start,
-        self.super.block_size,
-    );
+/// Creates a new copy of the given SfsFile using the given allocator
+pub fn copy(self: SfsFile, alloc: std.mem.Allocator) !SfsFile {
+    const new_name = try alloc(u8, self.name.len);
+    errdefer alloc.free(new_name);
+
+    return .{
+        .alloc = alloc,
+        .archive = self.archive,
+
+        .inode = try self.inode.copy(alloc),
+        .name = new_name,
+    };
+}
+pub fn deinit(self: SfsFile) void {
+    self.inode.deinit(self.alloc);
+    self.alloc.free(self.name);
 }

-// Universal functions
+/// Attempts to open the filepath if the SfsFile is a directory.
+/// If the given path refers to itself (such as "" or "."), a copied SfsFile is returned.
+pub fn open(self: SfsFile, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !SfsFile {
+    const path = std.mem.trim(u8, filepath, "/");

-pub fn extract(self: File, alloc: std.mem.Allocator, path: []const u8, options: ExtractionOptions) !void {
+    const first_element: []const u8 = std.mem.sliceTo(path, '/');
+
+    const dir: Directory = try self.inode.directory(alloc, io, &self.archive.cache, self.archive.super.dir_start);
+    defer dir.deinit(alloc);
+
+    var cur_slice = dir.entries;
+    var idx: usize = undefined;
+    while (cur_slice.len > 0) {
+        idx = cur_slice.len / 2;
+        switch (std.mem.order(u8, first_element, cur_slice[idx].name)) {
+            .eq => break,
+            .lt => cur_slice = cur_slice[0..idx],
+            .gt => cur_slice = cur_slice[idx..],
+        }
+    } else {
+        return error.NotFound;
+    }
+    if (first_element.len == path.len) return .initDirEntry(alloc, io, self.archive, cur_slice[idx]);
+    if (cur_slice[idx].type != .dir) return error.NotFound;
+    const tmp_file: SfsFile = try .initDirEntry(alloc, io, self.archive, cur_slice[idx]);
+    defer tmp_file.deinit();
+
+    return tmp_file.open(alloc, io, path[first_element.len..]);
+}
+
+pub fn extract(self: SfsFile, alloc: std.mem.Allocator, io: Io, ext_dir: []const u8, options: ExtractionOptions) !void {
    _ = self;
    _ = alloc;
-    _ = path;
+    _ = io;
+    _ = ext_dir;
    _ = options;
    return error.TODO;
 }
@@ -1,157 +1,136 @@
-//! This is the raw squashfs representation of a file/directory.
-//! Most of the time using File is a better experience and using Inodes directory
-//! is only required for more technical use cases.
-
 const std = @import("std");
-const Reader = std.Io.Reader;
+const Io = std.Io;
+const Reader = Io.Reader;

-const Decompressor = @import("decomp.zig");
+const DecompCache = @import("decomp_cache.zig");
 const Directory = @import("directory.zig");
-const FragEntry = @import("archive.zig").FragEntry;
-const Dir = @import("inode/dir.zig");
-const File = @import("inode/file.zig");
-const Misc = @import("inode/misc.zig");
-const Sym = @import("inode/sym.zig");
-const LookupTable = @import("lookup_table.zig");
-const MinimalSuperblock = @import("archive.zig").MinimalSuperblock;
-const DataReader = @import("util/data_reader.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
+const MetadataReader = @import("meta_rdr.zig");

 const Inode = @This();

 hdr: Header,
 data: Data,

-pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
+/// Read an inode given an inode Ref.
+pub fn initRef(alloc: std.mem.Allocator, io: Io, cache: *DecompCache, inode_start: u64, block_size: u32, ref: Ref) !Inode {
+    var meta: MetadataReader = .init(io, cache, inode_start + ref.block_start);
+    defer meta.deinit(io);
+    try meta.interface.discardAll(ref.block_offset);
+
+    return .init(alloc, &meta.interface, block_size);
+}
+pub fn initDirEntry(alloc: std.mem.Allocator, io: Io, cache: *DecompCache, inode_start: u64, block_size: u32, entry: Directory.Entry) !Inode {
+    var meta: MetadataReader = .init(io, cache, inode_start + entry.block_start);
+    defer meta.deinit(io);
+    try meta.interface.discardAll(entry.block_offset);
+
+    return .init(alloc, &meta.interface, block_size);
+}
+/// Read the inode from the given Reader.
+pub fn init(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
    var hdr: Header = undefined;
    try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
+    const data: Data = switch (hdr.type) {
+        .dir => .{ .dir = try .init(rdr) },
+        .file => .{ .file = try .init(alloc, rdr, block_size) },
+        .symlink => .{ .symlink = try .init(alloc, rdr) },
+        .block_dev => .{ .block_dev = try .init(rdr) },
+        .char_dev => .{ .char_dev = try .init(rdr) },
+        .fifo => .{ .fifo = try .init(rdr) },
+        .socket => .{ .socket = try .init(rdr) },
+        .ext_dir => .{ .ext_dir = try .init(rdr) },
+        .ext_file => .{ .ext_file = try .init(alloc, rdr, block_size) },
+        .ext_symlink => .{ .ext_symlink = try .init(alloc, rdr) },
+        .ext_block_dev => .{ .ext_block_dev = try .init(rdr) },
+        .ext_char_dev => .{ .ext_char_dev = try .init(rdr) },
+        .ext_fifo => .{ .ext_fifo = try .init(rdr) },
+        .ext_socket => .{ .ext_socket = try .init(rdr) },
+    };
    return .{
        .hdr = hdr,
-        .data = switch (hdr.inode_type) {
-            .dir => .{ .dir = .read(rdr) },
-            .file => .{ .file = .read(alloc, rdr, block_size) },
-            .symlink => .{ .symlink = .read(alloc, rdr) },
-            .block => .{ .block = .read(rdr) },
-            .char => .{ .char = .read(rdr) },
-            .fifo => .{ .fifo = .read(rdr) },
-            .sock => .{ .sock = .read(rdr) },
-            .ext_dir => .{ .ext_dir = .read(rdr) },
-            .ext_file => .{ .ext_file = .read(alloc, rdr, block_size) },
-            .ext_symlink => .{ .ext_symlink = .read(alloc, rdr) },
-            .ext_block => .{ .ext_block = .read(rdr) },
-            .ext_char => .{ .ext_char = .read(rdr) },
-            .ext_fifo => .{ .ext_fifo = .read(rdr) },
-            .ext_sock => .{ .ext_sock = .read(rdr) },
-        },
+        .data = data,
    };
 }
+pub fn copy(self: Inode, alloc: std.mem.Allocator) !Inode {
+    var new_inode = self;
+    switch (new_inode.data) {
+        .file => |*f| {
+            if (f.blocks.len > 0) {
+                f.blocks = try alloc.alloc(DataBlock, f.blocks.len);
+                @memcpy(f.blocks, self.data.file.blocks);
+            }
+        },
+        .ext_file => |*f| {
+            if (f.blocks.len > 0) {
+                f.blocks = try alloc.alloc(DataBlock, f.blocks.len);
+                @memcpy(f.blocks, self.data.ext_file.blocks);
+            }
+        },
+        .symlink => |*s| {
+            s.target = try alloc.alloc(u8, s.target.len);
+            @memcpy(s.target, self.data.symlink.target);
+        },
+        .ext_symlink => |*s| {
+            s.target = try alloc.alloc(u8, s.target.len);
+            @memcpy(s.target, self.data.ext_symlink.target);
+        },
+    }
+    return new_inode;
+}
 pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
    switch (self.data) {
-        .file => |f| alloc.free(f.block_sizes),
-        .ext_file => |f| alloc.free(f.block_sizes),
-        .symlink => |s| alloc.free(s.target),
-        .ext_symlink => |s| alloc.free(s.target),
+        .file => |f| f.deinit(alloc),
+        .ext_file => |f| f.deinit(alloc),
+        .symlink => |s| s.deinit(alloc),
+        .ext_symlink => |s| s.deinit(alloc),
        else => {},
    }
 }
-pub fn copy(self: Inode, alloc: std.mem.Allocator) !Inode {
-    switch (self.data) {
-        .dir,
-        .ext_dir,
-        .block,
-        .ext_block,
-        .char,
-        .ext_char,
-        .fifo,
-        .ext_fifo,
-        .sock,
-        .ext_sock,
-        => return self,
-        .file => |f| {
-            const new_sizes = try alloc.alloc(File.BlockSize, f.block_sizes.len);
-            @memcpy(new_sizes, f.block_sizes);
-            return .{
-                .hdr = self.hdr,
-                .data = .{ .file = .{
-                    .block_start = f.block_start,
-                    .frag_idx = f.frag_idx,
-                    .block_offset = f.block_offset,
-                    .size = f.size,
-                    .block_sizes = new_sizes,
-                } },
-            };
-        },
-        .ext_file => |f| {
-            const new_sizes = try alloc.alloc(File.BlockSize, f.block_sizes.len);
-            @memcpy(new_sizes, f.block_sizes);
-            return .{
-                .hdr = self.hdr,
-                .data = .{ .ext_file = .{
-                    .block_start = self.block_start,
-                    .size = self.size,
-                    .sparse = self.sparse,
-                    .hard_links = self.hard_links,
-                    .frag_idx = self.frag_idx,
-                    .block_offset = self.block_offset,
-                    .xattr_idx = self.xattr_idx,
-                    .block_sizes = new_sizes,
-                } },
-            };
-        },
-        .symlink => |s| {
-            const new_target = try alloc.alloc(u8, s.target.len);
-            @memcpy(new_target, s.target);
-            return .{
-                .hdr = self.hdr,
-                .data = .{ .symlink = .{
-                    .hard_links = s.hard_links,
-                    .target = new_target,
-                } },
-            };
-        },
-        .ext_symlink => |s| {
-            const new_target = try alloc.alloc(u8, s.target.len);
-            @memcpy(new_target, s.target);
-            return .{
-                .hdr = self.hdr,
-                .data = .{ .ext_symlink = .{
-                    .hard_links = s.hard_links,
-                    .xattr_idx = s.xattr_idx,
-                    .target = new_target,
-                } },
-            };
-        },
-    }
+
+// Utility functions
+
+pub fn directory(self: Inode, alloc: std.mem.Allocator, io: Io, cache: *DecompCache, dir_start: u64) !Directory {
+    return switch (self.data) {
+        .dir => |d| readDirectory(alloc, io, cache, dir_start, d),
+        .ext_dir => |d| readDirectory(alloc, io, cache, dir_start, d),
+        else => error.NotDirectory,
+    };
+}
+fn readDirectory(alloc: std.mem.Allocator, io: Io, cache: *DecompCache, dir_start: u64, d: anytype) !Directory {
+    var meta: MetadataReader = .init(io, cache, dir_start + d.block_start);
+    defer meta.deinit(io);
+    try meta.interface.discardAll(d.block_offset);
+
+    return .init(alloc, &meta.interface, d.size);
 }

 // Types

-pub const Ref = packed struct {
+pub const Ref = packed struct(u64) {
    block_offset: u16,
    block_start: u32,
    _: u16,
 };

-pub const Type = enum(u16) {
+pub const Enum = enum(u16) {
    dir = 1,
    file,
    symlink,
-    block,
-    char,
+    block_dev,
+    char_dev,
    fifo,
-    sock,
+    socket,
    ext_dir,
    ext_file,
    ext_symlink,
-    ext_block,
-    ext_char,
+    ext_block_dev,
+    ext_char_dev,
    ext_fifo,
-    ext_sock,
+    ext_socket,
 };

-const Header = packed struct {
-    inode_type: Type,
+pub const Header = extern struct {
+    type: Enum,
    permission: u16,
    uid_idx: u16,
    gid_idx: u16,
@@ -159,197 +138,261 @@ const Header = packed struct {
    num: u32,
 };

-pub const Data = union(Type) {
-    dir: Dir.Dir,
-    file: File.File,
-    symlink: Sym.Symlink,
-    block: Misc.Device,
-    char: Misc.Device,
-    fifo: Misc.Ipc,
-    sock: Misc.Ipc,
-    ext_dir: Dir.ExtDir,
-    ext_file: File.ExtFile,
-    ext_symlink: Sym.ExtSymlink,
-    ext_block: Misc.ExtDevice,
-    ext_char: Misc.ExtDevice,
-    ext_fifo: Misc.ExtIpc,
-    ext_sock: Misc.ExtIpc,
+pub const Data = union(Enum) {
+    dir: Dir,
+    file: File,
+    symlink: Symlink,
+    block_dev: Device,
+    char_dev: Device,
+    fifo: IPC,
+    socket: IPC,
+    ext_dir: ExtDir,
+    ext_file: ExtFile,
+    ext_symlink: ExtSymlink,
+    ext_block_dev: ExtDevice,
+    ext_char_dev: ExtDevice,
+    ext_fifo: ExtIPC,
+    ext_socket: ExtIPC,
 };

-// Errors
-
-pub const Error = error{
-    NotDirectory,
-    NotFound,
-    NotRegularFile,
+pub const DataBlock = packed struct(u32) {
+    size: u24,
+    uncompressed: bool,
+    _: u7,
 };

-// Utils functions
+const Dir = extern struct {
+    block_start: u32,
+    hard_links: u32,
+    size: u16,
+    block_offset: u16,
+    parent: u32,

-// Universal
+    const Self = @This();

-pub fn uid(self: Inode, decomp: *const Decompressor, fil: OffsetFile, id_start: u64) !u16 {
-    return LookupTable.stateless(u16, fil, decomp, id_start, self.hdr.uid_idx);
-}
-pub fn uidCached(self: Inode, table: LookupTable.CachedTable(u16)) !u16 {
-    return table.get(self.hdr.uid_idx);
-}
-pub fn gid(self: Inode, decomp: *const Decompressor, fil: OffsetFile, id_start: u64) !u16 {
-    return LookupTable.stateless(u16, fil, decomp, id_start, self.hdr.gid_idx);
-}
-pub fn gidCached(self: Inode, table: LookupTable.CachedTable(u16)) !u16 {
-    return table.get(self.hdr.gid_idx);
-}
-pub fn xattr(self: Inode, alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, xattr_start: u64) !?LookupTable.XattrValues {
-    if (@intFromEnum(self.hdr.inode_type) < 8) return null;
-    const idx: u32 = switch (self.data) {
-        .ext_dir => |d| d.xattr_idx,
-        .ext_file => |f| f.xattr_idx,
-        .ext_symlink => |s| s.xattr_idx,
-        .ext_block, .ext_char => |d| d.xattr_idx,
-        .ext_fifo, .ext_sock => |d| d.xattr_idx,
-        else => unreachable,
-    };
-    if (idx == 0xFFFFFFFF) return null;
-    return LookupTable.statelessXattr(alloc, fil, decomp, xattr_start, idx);
-}
-
-// Dir inodes
-
-/// For directory inodes, tries to find the inode at the given path. Returns both the inode, and it's file name.
-/// If the path is empty or "." then a copy of this inode is returned with no name ("").
-pub fn findInode(
-    inode: Inode,
-    alloc: std.mem.Allocator,
-    decomp: *const Decompressor,
-    fil: OffsetFile,
-    dir_start: u64,
-    inode_start: u64,
-    block_size: u32,
-    filepath: []const u8,
-) !struct { inode: Inode, name: []const u8 } {
-    switch (inode.data) {
-        .dir => |d| {
-            const path: []const u8 = std.mem.trim(u8, filepath, "/");
-            if (path.len == 0 or (path.len == 1 and path[0] == '.'))
-                return .{ .inode = inode.copy(alloc), .name = "" };
-            return findInodeRaw(
-                alloc,
-                decomp,
-                fil,
-                dir_start,
-                inode_start,
-                block_size,
-                path,
-                d,
-            );
-        },
-        .ext_dir => |d| {
-            const path: []const u8 = std.mem.trim(u8, filepath, "/");
-            if (path.len == 0 or (path.len == 1 and path[0] == '.'))
-                return .{ .inode = inode.copy(alloc), .name = "" };
-            return findInodeRaw(
-                alloc,
-                decomp,
-                fil,
-                dir_start,
-                inode_start,
-                block_size,
-                path,
-                d,
-            );
-        },
-        else => return Error.NotDirectory,
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
    }
-}
-inline fn findInodeRaw(
-    inode: Inode,
-    alloc: std.mem.Allocator,
-    decomp: *const Decompressor,
-    fil: OffsetFile,
-    dir_start: u64,
-    inode_start: u64,
-    block_size: u32,
-    path: []const u8,
-    dat: anytype,
-) !struct { inode: Inode, name: []const u8 } {
-    const first_element: []const u8 = std.mem.sliceTo(path, '/');
+};
+const ExtDir = extern struct {
+    hard_links: u32,
+    size: u32,
+    block_start: u32,
+    parent: u32,
+    idx_count: u16,
+    block_offset: u16,
+    xattr_idx: u32,
+    // []DirIndex

-    const dirs = try readDirRaw(alloc, decomp, fil, dir_start, dat);
-    defer {
-        for (dirs) |dir|
-            dir.deinit(alloc);
-        alloc.free(dirs);
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+
+const File = struct {
+    data_start: u32,
+    frag_idx: u32,
+    frag_offset: u32,
+    size: u32,
+    blocks: []DataBlock,
+
+    const Raw = extern struct {
+        data_start: u32,
+        frag_idx: u32,
+        frag_offset: u32,
+        size: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        var blocks_num = raw.size / block_size;
+        if (raw.frag_idx == 0xFFFFFFFF and raw.size % block_size > 0)
+            blocks_num += 1;
+
+        const blocks: []DataBlock = try alloc.alloc(DataBlock, blocks_num);
+        errdefer alloc.free(blocks);
+
+        try rdr.readSliceEndian(DataBlock, blocks, .little);
+        return .{
+            .data_start = raw.data_start,
+            .frag_idx = raw.frag_idx,
+            .frag_offset = raw.frag_offset,
+            .size = raw.size,
+            .blocks = blocks,
+        };
+    }
+    pub fn deinit(self: File, alloc: std.mem.Allocator) void {
+        alloc.free(self.blocks);
+    }
+};
+const ExtFile = struct {
+    data_start: u64,
+    size: u64,
+    sparse: u64,
+    hard_links: u32,
+    frag_idx: u32,
+    frag_offset: u32,
+    xattr_idx: u32,
+    blocks: []DataBlock,
+
+    const Raw = extern struct {
+        data_start: u64,
+        size: u64,
+        sparse: u64,
+        hard_links: u32,
+        frag_idx: u32,
+        frag_offset: u32,
+        xattr_idx: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        var blocks_num = raw.size / block_size;
+        if (raw.frag_idx == 0xFFFFFFFF and raw.size % block_size > 0)
+            blocks_num += 1;
+
+        const blocks: []DataBlock = try alloc.alloc(DataBlock, blocks_num);
+        errdefer alloc.free(blocks);
+
+        try rdr.readSliceEndian(DataBlock, blocks, .little);
+        return .{
+            .data_start = raw.data_start,
+            .size = raw.size,
+            .sparse = raw.sparse,
+            .hard_links = raw.hard_links,
+            .frag_idx = raw.frag_idx,
+            .frag_offset = raw.frag_offset,
+            .xattr_idx = raw.xattr_idx,
+            .blocks = blocks,
+        };
+    }
+    pub fn deinit(self: ExtFile, alloc: std.mem.Allocator) void {
+        alloc.free(self.blocks);
+    }
+};
+
+const Symlink = struct {
+    hard_links: u32,
+    target: []const u8,
+
+    const Raw = extern struct {
+        hard_links: u32,
+        target_size: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        const target = try alloc.alloc(u8, raw.target_size);
+        try rdr.readSliceEndian(u8, target, .little);
+
+        return .{
+            .hard_links = raw.hard_links,
+            .target = target,
+        };
+    }
+    pub fn deinit(self: Symlink, alloc: std.mem.Allocator) void {
+        alloc.free(self.target);
+    }
+};
+const ExtSymlink = struct {
+    hard_links: u32,
+    xattr_idx: u32,
+    target: []const u8,
+
+    const Raw = extern struct {
+        hard_links: u32,
+        target_size: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        const target = try alloc.alloc(u8, raw.target_size);
+        errdefer alloc.free(target);
+        try rdr.readSliceEndian(u8, target, .little);
+
+        var xattr_idx: u32 = undefined;
+        try rdr.readSliceEndian(u32, @ptrCast(&xattr_idx), .little);
+
+        return .{
+            .hard_links = raw.hard_links,
+            .target = target,
+            .xattr_idx = xattr_idx,
+        };
    }

-    // Directories are stored ASCIIbetically, so we can use binary search.
-    var cur_slice = dirs;
-    var idx: usize = 0;
-    while (cur_slice.len > 0) {
-        idx = cur_slice.len / 2;
-        const mid_name = cur_slice[idx].name;
-        switch (std.mem.order(u8, first_element, mid_name)) {
-            .gt => {
-                cur_slice = cur_slice[idx + 1 ..];
-                continue;
-            },
-            .lt => {
-                cur_slice = cur_slice[0..idx];
-                continue;
-            },
-            .eq => break,
-        }
-    } else return Error.NotFound;
-    const entry = cur_slice[idx];
-    var rdr = try fil.readerAt(inode_start + entry.block_start, &[0]u8{});
-    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
-    try meta_rdr.interface.discardAll(entry.block_offset);
-    const ret_inode: Inode = try .read(alloc, &meta_rdr.interface, block_size);
-    if (first_element.len == path.len) {
-        const name_copy = try alloc.alloc(u8, entry.name.len);
-        @memcpy(name_copy, entry.name.len);
-        return .{ .inode = ret_inode, .name = name_copy };
+    pub fn deinit(self: ExtSymlink, alloc: std.mem.Allocator) void {
+        alloc.free(self.target);
    }
-    return inode.findInode(alloc, decomp, fil, dir_start, inode_start, block_size, path[first_element.len..]);
-}
+};

-/// Get the directory entries for a directory inode.
-pub fn readDirectory(inode: Inode, alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, dir_start: u64) ![]Directory.Entry {
-    return switch (inode.data) {
-        .dir => |d| readDirRaw(alloc, decomp, fil, dir_start, d),
-        .ext_dir => |d| readDirRaw(alloc, decomp, fil, dir_start, d),
-        else => Error.NotDirectory,
-    };
-}
-inline fn readDirRaw(alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, dir_start: u64, dat: anytype) ![]Directory.Entry {
-    var rdr = try fil.readerAt(dir_start + dat.block_start, &[0]u8{});
-    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
-    try meta_rdr.interface.discardAll(dat.block_offset);
-    return Directory.readDirectory(alloc, meta_rdr, dat.size);
-}
+const Device = extern struct {
+    hard_links: u32,
+    device: u32,

-// file inodes
+    const Self = @This();

-/// Gets the data reader for a file inode.
-pub fn dataReader(inode: Inode, decomp: *const Decompressor, fil: OffsetFile, frag_start: u64, block_size: u32) !DataReader {
-    return switch (inode.data) {
-        .file => |f| dataReaderRaw(decomp, fil, frag_start, block_size, f),
-        .ext_file => |f| dataReaderRaw(decomp, fil, frag_start, block_size, f),
-        else => Error.NotRegularFile,
-    };
-}
-inline fn dataReaderRaw(decomp: *const Decompressor, fil: OffsetFile, frag_start: u64, block_size: u32, dat: anytype) !DataReader {
-    return .init(
-        decomp,
-        fil,
-        block_size,
-        dat.block_sizes,
-        dat.size,
-        dat.block_start,
-        if (dat.frag_idx != 0xFFFFFFFF)
-            try LookupTable.stateless(FragEntry, fil, decomp, frag_start, dat.frag_idx)
-        else
-            null,
-        dat.frag_offset,
-    );
-}
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+const ExtDevice = extern struct {
+    hard_links: u32,
+    device: u32,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+
+const IPC = extern struct {
+    hard_links: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+const ExtIPC = extern struct {
+    hard_links: u32,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
@@ -1,35 +0,0 @@
-const Reader = @import("std").Io.Reader;
-
-pub const Dir = packed struct {
-    block_start: u32,
-    hard_links: u32,
-    size: u16,
-    block_offset: u16,
-    parent_num: u32,
-
-    const Self = @This();
-
-    pub fn read(rdr: *Reader) !Self {
-        var new: Self = undefined;
-        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
-        return new;
-    }
-};
-
-pub const ExtDir = packed struct {
-    hard_links: u32,
-    size: u32,
-    block_start: u32,
-    parent_num: u32,
-    idx_count: u16,
-    block_offset: u16,
-    xattr_idx: u32,
-
-    const Self = @This();
-
-    pub fn read(rdr: *Reader) !Self {
-        var new: Self = undefined;
-        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
-        return new;
-    }
-};
@@ -1,69 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-
-pub const BlockSize = packed struct {
-    size: u31,
-    uncompressed: bool,
-};
-
-pub const File = struct {
-    block_start: u32,
-    frag_idx: u32,
-    frag_offset: u32,
-    size: u32,
-    block_sizes: []BlockSize,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
-        var buf: [16]u8 = undefined;
-        try rdr.readSliceAll(&buf);
-        const frag_idx = std.mem.readVarInt(u32, buf[4..8], .little);
-        const size = std.mem.readVarInt(u32, buf[12..], .little);
-        const sizes_len = size / block_size;
-        if (frag_idx != 0xFFFFFFFF and size % block_size > 0)
-            sizes_len += 1;
-        const sizes = try alloc.alloc(BlockSize, sizes_len);
-        errdefer alloc.free(sizes);
-        try rdr.readSliceEndian(BlockSize, sizes, .little);
-        return .{
-            .block_start = std.mem.readVarInt(u32, buf[0..4], .little),
-            .frag_idx = frag_idx,
-            .frag_offset = std.mem.readVarInt(u32, buf[8..12], .little),
-            .size = size,
-            .block_sizes = sizes,
-        };
-    }
-};
-
-pub const ExtFile = struct {
-    block_start: u64,
-    size: u64,
-    sparse: u64,
-    hard_links: u32,
-    frag_idx: u32,
-    frag_offset: u32,
-    xattr_idx: u32,
-    block_sizes: []BlockSize,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
-        var buf: [40]u8 = undefined;
-        try rdr.readSliceAll(&buf);
-        const frag_idx = std.mem.readVarInt(u32, buf[28..32], .little);
-        const size = std.mem.readVarInt(u64, buf[8..16], .little);
-        const sizes_len = size / block_size;
-        if (frag_idx != 0xFFFFFFFF and size % block_size > 0)
-            sizes_len += 1;
-        const sizes = try alloc.alloc(BlockSize, sizes_len);
-        errdefer alloc.free(sizes);
-        try rdr.readSliceEndian(BlockSize, sizes, .little);
-        return .{
-            .block_start = std.mem.readVarInt(u64, buf[0..8], .little),
-            .size = size,
-            .sparse = std.mem.readVarInt(u64, buf[16..24], .little),
-            .hard_links = std.mem.readVarInt(u32, buf[24..28], .little),
-            .frag_idx = frag_idx,
-            .frag_offset = std.mem.readVarInt(u32, buf[32..36], .little),
-            .xattr_idx = std.mem.readVarInt(u32, buf[36..40], .little),
-            .block_sizes = sizes,
-        };
-    }
-};
@@ -1,53 +0,0 @@
-const Reader = @import("std").Io.Reader;
-
-pub const Device = packed struct {
-    hard_links: u32,
-    device: u32,
-
-    const Self = @This();
-
-    pub fn read(rdr: *Reader) !Self {
-        var new: Self = undefined;
-        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
-        return new;
-    }
-};
-
-pub const ExtDevice = packed struct {
-    hard_links: u32,
-    device: u32,
-    xattr_idx: u32,
-
-    const Self = @This();
-
-    pub fn read(rdr: *Reader) !Self {
-        var new: Self = undefined;
-        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
-        return new;
-    }
-};
-
-pub const Ipc = packed struct {
-    hard_links: u32,
-
-    const Self = @This();
-
-    pub fn read(rdr: *Reader) !Self {
-        var new: Self = undefined;
-        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
-        return new;
-    }
-};
-
-pub const ExtIpc = packed struct {
-    hard_links: u32,
-    xattr_idx: u32,
-
-    const Self = @This();
-
-    pub fn read(rdr: *Reader) !Self {
-        var new: Self = undefined;
-        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
-        return new;
-    }
-};
@@ -1,42 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-
-pub const Symlink = struct {
-    hard_links: u32,
-    target: []const u8,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !Symlink {
-        var buf: [8]u8 = undefined;
-        try rdr.readSliceAll(&buf);
-        const size = std.mem.readVarInt(u32, buf[4..], .little);
-        const target = try alloc.alloc(u8, size);
-        errdefer alloc.free(target);
-        try rdr.readSliceEndian(u8, target, .little);
-        return .{
-            .hard_links = std.mem.readVarInt(u32, buf[0..4], .little),
-            .target = target,
-        };
-    }
-};
-
-pub const ExtSymlink = struct {
-    hard_links: u32,
-    xattr_idx: u32,
-    target: []const u8,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !ExtSymlink {
-        var buf: [8]u8 = undefined;
-        try rdr.readSliceAll(&buf);
-        const size = std.mem.readVarInt(u32, buf[4..], .little);
-        const target = try alloc.alloc(u8, size);
-        errdefer alloc.free(target);
-        try rdr.readSliceEndian(u8, target, .little);
-        var xattr_idx: u32 = undefined;
-        try rdr.readSliceEndian(u32, @ptrCast(&xattr_idx), .little);
-        return .{
-            .hard_links = std.mem.readVarInt(u32, buf[0..4], .little),
-            .target = target,
-            .xattr_idx = xattr_idx,
-        };
-    }
-};
@@ -0,0 +1,114 @@
+const std = @import("std");
+const Io = std.Io;
+
+const DataBlock = @import("inode.zig").DataBlock;
+const InodeRef = @import("inode.zig").Ref;
+const DecompCache = @import("decomp_cache.zig");
+const MetadataReader = @import("meta_rdr.zig");
+
+pub fn stateless(comptime T: anytype, io: Io, cache: *DecompCache, table_start: u64, idx: u32) !T {
+    const PER_BLOCK = 8192 / @sizeOf(T);
+
+    const block = idx / PER_BLOCK;
+    const block_idx = idx % PER_BLOCK;
+
+    const offset_offset = table_start + (block * 8);
+    const offset: u64 = std.mem.readInt(u64, cache.map.memory[offset_offset..][0..2], .little);
+
+    var meta: MetadataReader = .init(io, cache, offset);
+    defer meta.deinit(io);
+    try meta.discardAll(block_idx * @sizeOf(T));
+
+    var new: T = undefined;
+    try meta.interface.readSliceEndian(T, @ptrCast(&new), .little);
+    return new;
+}
+
+pub fn Table(comptime T: anytype) type {
+    return struct {
+        const PER_BLOCK = 8192 / @sizeOf(T);
+
+        const LookupTable = @This();
+
+        alloc: std.mem.Allocator,
+
+        cache: *DecompCache,
+        table_start: u64,
+
+        num: u32,
+        values: std.AutoHashMap(u32, []T),
+        mut: Io.RwLock = .init,
+
+        pub fn init(alloc: std.mem.Allocator, cache: *DecompCache, table_start: u64, num_values: u32) LookupTable {
+            return .{
+                .alloc = alloc,
+
+                .cache = cache,
+                .table_start = table_start,
+
+                .num = num_values,
+                .values = .init(alloc),
+            };
+        }
+        pub fn deinit(self: *LookupTable) void {
+            var iter = self.values.valueIterator();
+            while (iter.next()) |v|
+                self.alloc.free(v);
+            self.values.deinit();
+        }
+
+        pub fn get(self: *LookupTable, io: Io, idx: u32) Error!T {
+            const block = idx / PER_BLOCK;
+            const block_idx = idx % PER_BLOCK;
+            {
+                try self.mut.lockShared(io);
+                defer self.mut.unlockShared(io);
+
+                const val = self.values.get(block);
+                if (val != null) return val.*[block_idx];
+            }
+            try self.mut.lock(io);
+            defer self.mut.unlock(io);
+
+            const val = try self.values.getOrPut(block);
+            if (val.found_existing)
+                return val.value_ptr.*[block_idx];
+            errdefer self.values.removeByPtr(val.key_ptr);
+
+            const offset_offset = self.table_start + (block * 8);
+            const offset: u64 = std.mem.readInt(u64, self.cache.map.memory[offset_offset..][0..2], .little);
+
+            var meta: MetadataReader = .init(io, self.cache, offset);
+            defer meta.deinit(io);
+
+            const size = if (block == ((self.num - 1) / PER_BLOCK))
+                self.num % PER_BLOCK
+            else
+                PER_BLOCK;
+
+            const new_block = try self.alloc.alloc(T, size);
+            errdefer self.alloc.free(new_block);
+            try meta.interface.readSliceEndian(T, new_block, .little);
+
+            val.value_ptr.* = new_block;
+
+            return new_block[block_idx];
+        }
+    };
+}
+
+// Types
+
+pub const Error = error{} || std.mem.Allocator.Error;
+
+pub const FragmentEntry = extern struct {
+    start: u64,
+    size: DataBlock,
+    _: u32,
+};
+
+pub const XattrEntry = extern struct {
+    ref: InodeRef,
+    count: u32,
+    size: u32,
+};
@@ -1,168 +0,0 @@
-const std = @import("std");
-
-const Decompressor = @import("decomp.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-
-pub fn stateless(comptime T: anytype, fil: OffsetFile, decomp: *const Decompressor, table_start: u64, idx: u32) !T {
-    const VALS_PER_BLOCK = 8192 / @sizeOf(T);
-    const block = idx / VALS_PER_BLOCK;
-    const block_idx = idx % VALS_PER_BLOCK;
-
-    const offset = try fil.valueAt(u64, table_start + (8 * block));
-    var buf: [8192]u8 = undefined;
-    var rdr = try fil.readerAt(offset, &buf);
-    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
-    try meta_rdr.interface.discardAll(@sizeOf(T) * block_idx);
-
-    var out: T = undefined;
-    try meta_rdr.interface.readSliceEndian(T, @ptrCast(&out), .little);
-    return out;
-}
-
-const InodeRef = @import("inode.zig").Ref;
-
-const XattrLookup = packed struct {
-    // This isn't actuall an inode ref, but is stored that exact same way.
-    ref: InodeRef,
-    kv_count: u32,
-    size: u32,
-};
-
-const XattrKey = packed struct {
-    type: enum(u2) {
-        user,
-        trusted,
-        security,
-    },
-    out_of_line: bool,
-    _: u13,
-    name_size: u16,
-};
-
-pub const XattrValues = std.AutoHashMap([:0]u8, []u8);
-
-pub fn statelessXattr(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, table_start: u64, idx: u32) !XattrValues {
-    const xattr_start = try fil.valueAt(u64, table_start);
-    const block = idx / 512;
-    const block_idx = idx % 512;
-
-    const block_start = try fil.valueAt(u64, table_start + 8 + (block * 8));
-    var rdr = try fil.readerAt(block_start, &[0]u8{});
-    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
-    try meta_rdr.interface.discardAll(16 * block_idx);
-
-    var lookup: XattrLookup = undefined;
-    try meta_rdr.interface.readSliceEndian(XattrLookup, @ptrCast(&lookup), .little);
-
-    rdr = try fil.readerAt(xattr_start + lookup.ref.block_start, &[0]u8{});
-    meta_rdr = .init(&rdr.interface, decomp);
-    try meta_rdr.interface.discardAll(lookup.ref.block_offset);
-
-    var out: XattrValues = try .init(alloc);
-    for (0..lookup.kv_count) |_| {
-        var key: XattrKey = undefined;
-        try meta_rdr.interface.readSliceEndian(XattrKey, @ptrCast(&key), .little);
-        const prefix_size = switch (key.type) {
-            .user => 4,
-            .trusted => 7,
-            .security => 8,
-        };
-        const name: [:0]u8 = try alloc.alloc(u8, prefix_size + key.name_size + 1);
-        name[prefix_size + key.name_size] = 0;
-        try meta_rdr.interface.readSliceEndian(u8, name[prefix_size .. prefix_size + key.name_size], .little);
-        switch (key.type) {
-            .user => @memcpy(name[0..4], "user"),
-            .trusted => @memcpy(name[0..7], "trusted"),
-            .security => @memcpy(name[0..8], "security"),
-        }
-        if (key.out_of_line) {
-            try meta_rdr.interface.discardAll(4);
-            var value_offset: InodeRef = undefined;
-            try meta_rdr.interface.readSliceEndian(InodeRef, @ptrCast(&value_offset), .little);
-
-            var value_rdr = try fil.readerAt(xattr_start + value_offset.block_start, &[0]u8{});
-            var value_meta: MetadataReader = .init(&value_rdr.interface, decomp);
-            try value_meta.interface.discardAll(value_offset.block_offset);
-
-            var val_size: u32 = undefined;
-            try value_meta.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
-            const value = try alloc.alloc(u8, val_size);
-            try value_meta.interface.readSliceEndian(u8, value, .little);
-            try out.put(name, value);
-        } else {
-            var val_size: u32 = undefined;
-            try meta_rdr.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
-            const value = try alloc.alloc(u8, val_size);
-            try meta_rdr.interface.readSliceEndian(u8, value, .little);
-            try out.put(name, value);
-        }
-    }
-    return out;
-}
-
-pub fn CachedTable(comptime T: anytype) type {
-    return struct {
-        const Self = @This();
-
-        const VALS_PER_BLOCK = 8192 / @sizeOf(T);
-
-        alloc: std.mem.Allocator,
-        decomp: *const Decompressor,
-
-        fil: OffsetFile,
-        table_start: u64,
-        num: u32,
-
-        cache: std.AutoHashMap(u32, []T),
-        cache_mut: std.Thread.Mutex = .{},
-
-        pub fn init(alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, table_offset: u64, num: u32) !Self {
-            return .{
-                .alloc = alloc,
-                .decomp = decomp,
-
-                .fil = fil,
-                .table_start = table_offset,
-                .num = num,
-
-                .cache = .init(alloc),
-            };
-        }
-        pub fn deinit(self: *Self) void {
-            var values = self.cache.valueIterator();
-            while (values.next()) |val|
-                self.alloc.free(val);
-            self.cache.deinit();
-        }
-
-        pub fn get(self: *Self, idx: u32) !T {
-            const block = idx / VALS_PER_BLOCK;
-            const block_idx = idx % VALS_PER_BLOCK;
-
-            if (self.cache.get(block)) |val|
-                return val[block_idx];
-
-            self.cache_mut.lock();
-            defer self.cache_mut.unlock();
-
-            // Double check in case another thread was doing your work.
-            if (self.cache.get(block)) |val|
-                return val[block_idx];
-
-            const offset = try self.fil.valueAt(u64, self.table_start + (8 * block));
-            var buf: [8192]u8 = undefined;
-            var rdr = try self.fil.readerAt(offset, &buf);
-            var meta_rdr: MetadataReader = .init(&rdr.interface, self.decomp);
-            const block_size = if (block == (self.num - 1) / VALS_PER_BLOCK)
-                self.num % VALS_PER_BLOCK
-            else
-                VALS_PER_BLOCK;
-            const new_block = try self.alloc.alloc(T, block_size);
-            errdefer self.alloc.free(new_block);
-            try meta_rdr.interface.readSliceEndian(T, new_block, .little);
-            try self.cache.put(block, new_block);
-            return new_block[block_idx];
-        }
-    };
-}
@@ -0,0 +1,109 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = Io.Reader;
+const Writer = Io.Writer;
+const Limit = Io.Limit;
+
+const DecompCache = @import("decomp_cache.zig");
+
+const MetadataReader = @This();
+
+io: Io,
+cache: *DecompCache,
+
+cur_offset: u64 = 0,
+next_offset: u64,
+
+interface: Reader = .{
+    .buffer = &[0]u8{},
+    .end = 0,
+    .seek = 0,
+    .vtable = &.{
+        .stream = stream,
+        .discard = discard,
+        .readVec = readVec,
+    },
+},
+
+pub fn init(io: Io, cache: *DecompCache, start: u64) MetadataReader {
+    return .{
+        .io = io,
+        .cache = cache,
+
+        .next_offset = start,
+    };
+}
+pub fn deinit(self: *MetadataReader, io: Io) void {
+    self.cache.finished(io, self.cur_offset);
+}
+
+fn advance(self: *MetadataReader) !void {
+    self.cache.finished(self.io, self.cur_offset);
+
+    self.interface.seek = 0;
+    errdefer self.interface.end = 0;
+
+    const hdr: Header = @bitCast(std.mem.readInt(u16, self.cache.map.memory[self.next_offset..][0..2], .little));
+    self.cur_offset = self.next_offset + 2;
+    self.next_offset = self.cur_offset + hdr.size;
+
+    if (hdr.uncompressed) {
+        self.interface.buffer = self.cache.map.memory[self.cur_offset..][0..hdr.size];
+        self.interface.end = hdr.size;
+        return;
+    }
+    self.interface.buffer = try self.cache.get(self.io, self.cur_offset, hdr.size, 8192);
+    self.interface.end = self.interface.buffer.len;
+}
+
+fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize {
+    if (r.seek >= r.end) {
+        const self: *MetadataReader = @fieldParentPtr("interface", r);
+        self.advance() catch |err| {
+            std.debug.print("error advancing metadata reader: {}\n", .{err});
+            return Reader.Error.ReadFailed;
+        };
+    }
+    const to_write = @min(r.end - r.seek, @intFromEnum(limit));
+    const wrote = try w.write(r.buffer[r.seek..][0..to_write]);
+    r.seek += wrote;
+    return wrote;
+}
+fn discard(r: *Reader, limit: Limit) Reader.Error!usize {
+    if (r.seek >= r.end) {
+        const self: *MetadataReader = @fieldParentPtr("interface", r);
+        self.advance() catch |err| {
+            std.debug.print("error advancing metadata reader: {}\n", .{err});
+            return Reader.Error.ReadFailed;
+        };
+    }
+    const to_discard = @min(r.end - r.seek, @intFromEnum(limit));
+    r.seek += to_discard;
+    return to_discard;
+}
+fn readVec(r: *Reader, vec: [][]u8) Reader.Error!usize {
+    if (r.seek >= r.end) {
+        const self: *MetadataReader = @fieldParentPtr("interface", r);
+        self.advance() catch |err| {
+            std.debug.print("error advancing metadata reader: {}\n", .{err});
+            return Reader.Error.ReadFailed;
+        };
+    }
+    var total: usize = 0;
+    for (vec) |v| {
+        const to_copy = @min(r.end - r.seek, v.len);
+        @memcpy(v[0..to_copy], r.buffer[r.seek..][0..to_copy]);
+        r.seek += to_copy;
+        total += to_copy;
+        if (r.seek >= r.end)
+            break;
+    }
+    return total;
+}
+
+// Types
+
+const Header = packed struct(u16) {
+    size: u15,
+    uncompressed: bool,
+};
@@ -5,8 +5,6 @@ const Writer = std.Io.Writer;

 const ExtractionOptions = @This();

-/// The number of threads used for extraction. 0 implies single threaded.
-threads: usize = 1,
 /// Don't set the file's owner & permissions after extraction
 ignore_permissions: bool = false,
 /// Don't set xattr values. Currently xattrs are never set anyway.
@@ -18,16 +16,10 @@ verbose: bool = false,
 /// Where to print verbose log.
 verbose_writer: ?*Writer = null,

-pub const SingleThreadedDefault: ExtractionOptions = .{};
-pub fn Default() !ExtractionOptions {
-    return .{
-        .threads = try std.Thread.getCpuCount(),
-    };
-}
+pub const default: ExtractionOptions = .{};
 pub fn VerboseDefault(wrt: *Writer) !ExtractionOptions {
    return .{
        .verbose = true,
        .verbose_writer = wrt,
-        .threads = try std.Thread.getCpuCount(),
    };
 }
@@ -1,3 +1,8 @@
 pub const Archive = @import("archive.zig");
+pub const ExtractionOptions = @import("options.zig");

-pub const ExtractionOptions = @import("options.zig");
+test {
+    const std = @import("std");
+
+    std.testing.refAllDecls(Archive);
+}
@@ -0,0 +1,84 @@
+const std = @import("std");
+const stuff = @import("builtin");
+
+const Archive = @import("archive.zig");
+const Superblock = @import("super.zig").Superblock;
+
+const TestArchive = "testing/LinuxPATest.sfs";
+
+test "Basics" {
+    var fil = try std.fs.cwd().openFile(TestArchive, .{});
+    defer fil.close();
+    var sfs: Archive = try .init(std.testing.allocator, fil);
+    defer sfs.deinit();
+    if (sfs.super != LinuxPATestCorrectSuperblock) {
+        std.debug.print("Superblock wrong\nShould be: {}\n\nis: {}\n", .{ LinuxPATestCorrectSuperblock, sfs.super });
+        return error.BadSuperblock;
+    }
+}
+
+const TestFile = "Start.exe";
+const TestFileExtractLocation = "testing/Start.exe";
+
+test "ExtractSingleFile" {
+    std.fs.cwd().deleteFile(TestFileExtractLocation) catch {};
+    var fil = try std.fs.cwd().openFile(TestArchive, .{});
+    defer fil.close();
+    var sfs: Archive = try .init(std.testing.allocator, fil);
+    defer sfs.deinit();
+    var test_fil = try sfs.open(TestFile);
+    defer test_fil.deinit();
+    try test_fil.extract(TestFileExtractLocation, .Default);
+    //TODO: validate extracted file.
+}
+
+const TestFullExtractLocation = "testing/TestExtract";
+
+test "ExtractCompleteArchive" {
+    std.fs.cwd().deleteTree(TestFullExtractLocation) catch {};
+    var fil = try std.fs.cwd().openFile(TestArchive, .{});
+    defer fil.close();
+    var sfs: Archive = try .init(std.testing.allocator, fil);
+    defer sfs.deinit();
+    try sfs.extract(TestFullExtractLocation, .Default);
+}
+
+const LinuxPATestCorrectSuperblock: Superblock = .{
+    .magic = std.mem.readInt(u32, "hsqs", .little),
+    .inode_count = 2974,
+    .mod_time = 1632696724,
+    .block_size = 131072,
+    .frag_count = 264,
+    .compression = .zstd,
+    .block_log = 17,
+    .flags = .{
+        .inode_uncompressed = false,
+        .data_uncompressed = false,
+        .check = false,
+        .frag_uncompressed = false,
+        .fragment_never = false,
+        .fragment_always = false,
+        .duplicates = true,
+        .exportable = true,
+        .xattr_uncompressed = false,
+        .xattr_never = false,
+        .compression_options = false,
+        .ids_uncompressed = false,
+        ._ = 0,
+    },
+    .id_count = 1,
+    .ver_maj = 4,
+    .ver_min = 0,
+    .root_ref = .{
+        .block_offset = 1363,
+        .block_start = 29237,
+        ._ = 0,
+    },
+    .size = 106841744,
+    .id_start = 106841632,
+    .xattr_start = 106841720,
+    .inode_start = 106778274,
+    .dir_start = 106807998,
+    .frag_start = 106837747,
+    .export_start = 106841602,
+};
@@ -1,138 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const Writer = std.Io.Writer;
-const Limit = std.Io.Limit;
-
-const FragEntry = @import("../archive.zig").FragEntry;
-const Decompressor = @import("../decomp.zig");
-const BlockSize = @import("../inode/file.zig").BlockSize;
-const OffsetFile = @import("offset_file.zig");
-
-const DataReader = @This();
-
-decomp: *const Decompressor,
-file: OffsetFile,
-block_size: u32,
-blocks: []BlockSize,
-size: u64,
-frag: ?FragEntry,
-frag_offset: u32,
-
-offset: u64,
-idx: usize = 0,
-sparse: bool = false,
-
-interface: Reader,
-
-pub fn init(decomp: *const Decompressor, file: OffsetFile, block_size: u32, blocks: []BlockSize, size: u64, init_offset: u64, frag: ?FragEntry, frag_offset: u32) DataReader {
-    return .{
-        .decomp = decomp,
-        .file = file,
-        .block_size = block_size,
-        .blocks = blocks,
-        .size = size,
-        .frag = frag,
-        .frag_offset = frag_offset,
-
-        .offset = init_offset,
-
-        .interface = .{
-            .buffer = &[1]u8{undefined} ** (1024 * 1024),
-            .end = 0,
-            .seek = 0,
-            .vtable = &.{ .stream = stream, .discard = discard, .readVec = readVec },
-        },
-    };
-}
-
-fn numBlocks(self: *DataReader) usize {
-    return if (self.frag == null)
-        self.blocks.len
-    else
-        self.blocks.len + 1;
-}
-fn advanceBuffer(self: *DataReader) Reader.Error!void {
-    if (self.idx >= self.numBlocks()) return Reader.Error.EndOfStream;
-    defer self.idx += 1;
-    self.sparse = false;
-    self.interface.end = 0; // If we error out and the error is ignored, we'll stil end up back here to error again.
-    self.interface.seek = 0;
-    if (self.idx == self.blocks.len) { // Fragment
-        var rdr = self.file.readerAt(self.frag.?.block_start, &[0]u8{}) catch return Reader.Error.ReadFailed;
-        const size = self.size % self.block_size;
-        if (self.frag.?.size.uncompressed) {
-            try rdr.interface.discardAll(self.frag_offset);
-            try rdr.interface.readSliceAll(self.interface.buffer[0..size]);
-            self.interface.end = size;
-            return;
-        }
-        const raw_loc = self.interface.buffer.len - self.frag.?.size.size;
-        try rdr.interface.readSliceAll(self.interface.buffer[raw_loc..]);
-        _ = self.decomp.decompress(self.interface.buffer[raw_loc..], self.interface.buffer) catch
-            return Reader.Error.ReadFailed;
-        @memmove(self.interface.buffer[0..size], self.interface.buffer[self.frag_offset .. self.frag_offset + size]);
-        self.interface.end = size;
-        return;
-    }
-    const block = self.blocks[self.idx];
-    if (block.size == 0) {
-        self.interface.end = if (self.idx == self.numBlocks() - 1)
-            self.size % self.block_size
-        else
-            self.block_size;
-        self.sparse = true;
-        return;
-    }
-    defer self.offset += block.size;
-    var rdr = try self.file.readerAt(self.offset, &[0]u8{});
-    if (block.uncompressed) {
-        try rdr.interface.readSliceAll(self.interface.buffer[0..block.size]);
-        self.interface.end = block.size;
-        return;
-    }
-    const raw_loc = self.interface.buffer.len - block.size;
-    try rdr.interface.readSliceAll(self.interface.buffer[raw_loc..]);
-    self.interface.end = self.decomp.decompress(self.interface.buffer[raw_loc..], self.interface.buffer) catch
-        return Reader.Error.ReadFailed;
-}
-
-fn stream(r: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
-    var self: *DataReader = @fieldParentPtr("interface", r);
-    if (r.seek == r.end) try self.advanceBuffer();
-    if (limit == .nothing) return 0;
-
-    const to_write = @min(r.end - r.seek, @intFromEnum(limit));
-    const wrote = if (self.sparse)
-        try wrt.splatByte(0, to_write)
-    else
-        try wrt.write(r.buffer[r.seek .. r.seek + to_write]);
-    r.seek += wrote;
-    return wrote;
-}
-fn discard(r: *Reader, limit: Limit) Reader.Error!usize {
-    var self: *DataReader = @fieldParentPtr("interface", r);
-    if (r.seek == r.end) try self.advanceBuffer();
-    if (limit == .nothing) return 0;
-
-    const adv = @min(r.end - r.seek, @intFromEnum(limit));
-    r.seek += adv;
-    return adv;
-}
-fn readVec(r: *Reader, vec: [][]u8) Reader.Error!usize {
-    var self: *DataReader = @fieldParentPtr("interface", r);
-    if (r.seek == r.end) try self.advanceBuffer();
-
-    var wrote: usize = 0;
-    for (vec) |slice| {
-        if (r.seek == r.end) break;
-        const to_copy = @min(r.end - r.seek, slice.len);
-        if (self.sparse) {
-            @memset(slice[0..to_copy], 0);
-        } else {
-            @memcpy(slice[0..to_copy], r.buffer[r.seek .. r.seek + to_copy]);
-        }
-        r.seek += to_copy;
-        wrote += to_copy;
-    }
-    return wrote;
-}
@@ -1,54 +0,0 @@
-const std = @import("std");
-
-const MinimalSuperblock = @import("../archive.zig").MinimalSuperblock;
-const Decompressor = @import("../decomp.zig");
-const DirEntry = @import("../directory.zig").Entry;
-const File = @import("../file.zig");
-const Inode = @import("../inode.zig");
-const MetadataReader = @import("metadata.zig");
-const OffsetFile = @import("offset_file.zig");
-const Utils = @import("utils.zig");
-
-const Iter = @This();
-
-file: OffsetFile,
-super: MinimalSuperblock,
-decomp: Decompressor,
-
-entries: []DirEntry,
-idx: usize = 0,
-
-pub fn deinit(self: Iter) void {
-    for (self.entries) |ent|
-        ent.deinit(self.decomp.alloc);
-    self.decomp.alloc.free(self.entries);
-}
-
-pub fn next(self: *Iter) !?File {
-    if (self.idx >= self.entries.len) return null;
-    defer self.idx += 1;
-
-    const entry = self.entries[self.idx];
-
-    const new_name = try self.decomp.alloc.alloc(u8, entry.name.len);
-    @memcpy(new_name, entry.name);
-    return .{
-        .file = self.file,
-        .super = self.super,
-        .decomp = self.decomp,
-
-        .name = new_name,
-        .inode = Utils.readInode(
-            self.decomp.alloc,
-            &self.decomp,
-            self.file,
-            self.super.inode_start,
-            self.super.block_size,
-            entry.block_start,
-            entry.block_offset,
-        ),
-    };
-}
-pub fn reset(self: *Iter) void {
-    self.idx = 0;
-}
@@ -1,77 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const Writer = std.Io.Writer;
-const Limit = std.Io.Limit;
-
-const Decompressor = @import("../decomp.zig");
-
-const Header = packed struct {
-    size: u15,
-    uncompressed: bool,
-};
-
-const MetadataReader = @This();
-
-rdr: *Reader,
-decomp: *const Decompressor,
-
-read_buf: [8192]u8 = undefined,
-interface: Reader = .{
-    .buffer = &([1]u8{undefined} ** 8192),
-    .end = 0,
-    .seek = 0,
-    .vtable = &.{
-        .stream = stream,
-        .discard = discard,
-        .readVec = readVec,
-    },
-},
-
-pub fn init(rdr: *Reader, decomp: *const Decompressor) MetadataReader {
-    return .{ .rdr = rdr, .decomp = decomp };
-}
-fn advanceBuffer(self: *MetadataReader) Reader.Error!void {
-    self.interface.seek = 0;
-    var hdr: Header = undefined;
-    try self.rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
-    try self.rdr.readSliceAll(self.read_buf[0..hdr.size]);
-    if (hdr.uncompressed) {
-        @memcpy(self.interface.buffer[0..hdr.size], self.read_buf[0..hdr.size]);
-        self.interface.end = hdr.size;
-        return;
-    }
-    self.interface.end = self.decomp.decompress(self.read_buf[0..hdr.size], self.interface.buffer) catch |err|
-        return switch (err) {
-            error.OutOfMemory => error.ReadFailed,
-            else => err,
-        };
-}
-
-fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
-    var self: *MetadataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.seek == rdr.end) try self.advanceBuffer();
-    const to_write = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-    const wrote = try wrt.write(rdr.buffer[rdr.seek .. rdr.seek + to_write]);
-    rdr.seek += wrote;
-    return wrote;
-}
-fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
-    var self: *MetadataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.seek == rdr.end) try self.advanceBuffer();
-    const to_adv = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-    rdr.seek += to_adv;
-    return to_adv;
-}
-fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
-    var self: *MetadataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.seek == rdr.end) try self.advanceBuffer();
-    var wrote = 0;
-    for (vec) |v| {
-        if (rdr.seek == rdr.end) break;
-        const to_write = @min(v.len, rdr.end - rdr.seek);
-        @memcpy(v[0..to_write], rdr.buffer[rdr.seek .. rdr.seek + to_write]);
-        wrote += to_write;
-        rdr.seek += to_write;
-    }
-    return wrote;
-}
@@ -1,21 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const FileReader = Io.File.Reader;
-
-const OffsetFile = @This();
-
-fil: Io.File,
-offset: u64 = 0,
-
-pub fn readerAt(self: OffsetFile, io: Io, offset: u64, buf: []u8) !FileReader {
-    var rdr = self.fil.reader(io, buf);
-    try rdr.seekTo(self.offset + offset);
-    return rdr;
-}
-pub fn valueAt(self: OffsetFile, comptime T: type, io: Io, offset: u64) !T {
-    var rdr = self.fil.reader(io, &[0]u8{});
-    try rdr.seekTo(self.offset + offset);
-    var new: T = undefined;
-    try rdr.interface.readSliceEndian(T, @ptrCast(&new), .little);
-    return new;
-}
@@ -1,25 +0,0 @@
-const std = @import("std");
-
-const Decompressor = @import("../decomp.zig");
-const DirEntry = @import("../directory.zig").Entry;
-const Inode = @import("../inode.zig");
-const MetadataReader = @import("metadata.zig");
-const OffsetFile = @import("offset_file.zig");
-
-pub fn pathIsSelf(path: []const u8) bool {
-    if (path.len == 0) return true;
-    if (path.len == 1) {
-        return switch (path[0]) {
-            '.', '/' => true,
-            else => false,
-        };
-    }
-    return std.mem.eql(u8, path, "./");
-}
-
-pub fn readInode(alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, inode_start: u64, block_size: u32, block_start: u32, block_offset: u16) !Inode {
-    var rdr = try fil.readerAt(inode_start + block_start, &[0]u8{});
-    var meta: MetadataReader = .init(&rdr.interface, decomp);
-    try meta.interface.discardAll(block_offset);
-    return .read(alloc, &meta.interface, block_size);
-}
@@ -0,0 +1,40 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+const flate = std.compress.flate;
+const zstd = std.compress.zstd;
+const xz = std.compress.xz;
+const lzma = std.compress.lzma;
+
+const Error = @import("decomp.zig").Error;
+
+pub fn zlibDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var buf: [flate.max_window_len]u8 = undefined;
+
+    var rdr: Reader = .fixed(in);
+    var decomp: flate.Decompress = .init(&rdr, .zlib, &buf);
+
+    return decomp.reader.readSliceShort(out);
+}
+pub fn zstdDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const buf = try alloc.alloc(u8, in.len + zstd.block_size_max);
+    defer alloc.free(buf);
+
+    var rdr: Reader = .fixed(in);
+    var decomp: zstd.Decompress = .init(&rdr, buf, .{ .window_len = in.len });
+
+    return decomp.reader.readSliceShort(out);
+}
+pub fn lzmaDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var rdr: Reader = .fixed(in);
+    var decomp: lzma.Decompress = .initOptions(&rdr, alloc, &[0]u8{}, .{}, 2 * out.len);
+    defer decomp.deinit();
+
+    return decomp.reader.readSliceShort(out);
+}
+pub fn xzDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var rdr: Reader = .fixed(in);
+    var decomp: xz.Decompress = .init(&rdr, alloc, &[0]u8{});
+    defer decomp.deinit();
+
+    return decomp.reader.readSliceShort(out);
+}
Author	SHA1	Message	Date
Caleb Gardner	c52fb15609	Finished (theoretically) file extraction.	2026-05-30 17:29:50 -05:00
Caleb Gardner	578911ba67	Work on extraction Created DataExtractor & DataReader Created Lookup tables	2026-05-30 06:22:26 -05:00
Caleb Gardner	56ad79ba94	Updated unsquashfs for zig 0.16.0 Fixed a couple bugs Added scaffold for extraction	2026-05-29 18:50:45 -05:00
Caleb Gardner	2cb0863cc1	A BUNCH OF STUFF Metadata reading Directory reading Decompile cache Actual SfsFile implementation Finished Inode implementation Actually build unsquashfs	2026-05-29 06:20:06 -05:00
Caleb Gardner	2c47c7492e	Reset for 0.16 (redux) Starting from scratch	2026-05-28 06:13:00 -05:00
Caleb J. Gardner	4b2b7021c7	Moved & organized decompression Fully implemented Decompressor vtable	2026-04-02 06:27:34 -05:00