chore: Replace custom native packer with a standard zip file

FalsePattern · FalsePattern · commit 965f13be833e · 2025-10-27T17:27:39.000+01:00
CurseForge moderation doesn't like the packer
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -1,5 +1,4 @@
 import com.falsepattern.zanama.tasks.ZanamaTranslate
-import com.falsepattern.zigbuild.options.ZigBuildOptions
 import com.falsepattern.zigbuild.tasks.ZigBuildTask
 import com.falsepattern.zigbuild.toolchain.ZigVersion
 
@@ -127,15 +126,22 @@ tasks.named<JavaCompile>(panamaNatives.compileJavaTaskName) {
 
 panamaNatives.java.srcDirs(translateJavaSourcesCpuID, translateJavaSourcesFalseTweaks)
 
-tasks.processResources.configure {
+val packNatives = tasks.register<Zip>("packNatives") {
+    this.archiveFileName = "natives.zip"
+    from(zigPrefix.map { it.dir("lib") }) {
+        include("*.so", "*.dll", "*.dylib")
+    }
+    this.entryCompression = ZipEntryCompression.STORED
     dependsOn(zigBuildTask)
+}
+
+tasks.processResources.configure {
+    dependsOn(zigBuildTask, packNatives)
     into("META-INF/falsepatternlib_repo/mega/megatraceservice/1.2.0/") {
         from(configurations.compileClasspath.map { it.filter { file -> file.name.contains("megatraceservice") } })
     }
     into(minecraft_fp.mod.rootPkg.map { "/assets/falsetweaks" } ) {
-        from(zigPrefix.map { it.dir("lib") }) {
-            include("*.pak")
-        }
+        from(packNatives.map { it.outputs.files })
     }
 }
 
diff --git a/build.zig b/build.zig
@@ -31,7 +31,6 @@ const base_targets = [_]std.Target.Query{
 };
 
 pub fn build(b: *std.Build) void {
-    const packer = createPackerTask(b);
     const targets = getTargets(b);
 
     //JNI stubs
@@ -56,11 +55,16 @@ pub fn build(b: *std.Build) void {
             .name = name,
             .root_module = libjni_mod,
         });
-        packer.addArg(name);
-        packer.addFileArg(libjni.getEmittedBin());
+        const inst = b.addInstallArtifact(libjni, .{
+            .dest_dir = .{ .override = .lib },
+            .h_dir = .disabled,
+            .implib_dir = .disabled,
+            .pdb_dir = .disabled,
+        });
+        b.getInstallStep().dependOn(&inst.step);
     }
 
-    const zanamaBuilder = ZanamaLibBuilder.init(b, packer);
+    const zanamaBuilder = ZanamaLibBuilder.init(b);
 
     zanamaBuilder.addZanamaLibs(
         "cpuid",
@@ -83,22 +87,6 @@ pub fn build(b: *std.Build) void {
     );
 }
 
-fn createPackerTask(b: *std.Build) *std.Build.Step.Run {
-    const packer = b.addExecutable(.{
-        .name = "packer",
-        .root_module = b.addModule("packer", .{
-            .root_source_file = b.path("zig-util/packer.zig"),
-            .target = b.graph.host,
-        }),
-    });
-    const run_packer = b.addRunArtifact(packer);
-    const natives_file = "natives.pak";
-    const output_natives_file = run_packer.addOutputFileArg(natives_file);
-    const install_pack = b.addInstallLibFile(output_natives_file, natives_file);
-    b.getInstallStep().dependOn(&install_pack.step);
-    return run_packer;
-}
-
 fn getTargets(b: *std.Build) struct { baseline: []std.Build.ResolvedTarget, all: []std.Build.ResolvedTarget } {
     var baseline_targets: [base_targets.len]std.Build.ResolvedTarget = undefined;
     var targets = std.ArrayList(std.Build.ResolvedTarget).empty;
@@ -125,18 +113,16 @@ fn getTargets(b: *std.Build) struct { baseline: []std.Build.ResolvedTarget, all:
 
 const ZanamaLibBuilder = struct {
     b: *std.Build,
-    packer: *std.Build.Step.Run,
     zanama_dep: *std.Build.Dependency,
     zanama_api: *std.Build.Module,
     zb: zanama.Build,
 
-    pub fn init(b: *std.Build, packer: *std.Build.Step.Run) ZanamaLibBuilder {
+    pub fn init(b: *std.Build) ZanamaLibBuilder {
         const zanama_dep = b.dependency("zanama", .{});
         const zanama_api = zanama_dep.module("api");
         const zb = zanama.Build.init(b, .ReleaseFast, zanama_dep);
         return .{
             .b = b,
-            .packer = packer,
             .zanama_dep = zanama_dep,
             .zanama_api = zanama_api,
             .zb = zb,
@@ -146,12 +132,18 @@ const ZanamaLibBuilder = struct {
     fn addZanamaLibs(self: *const ZanamaLibBuilder, name: []const u8, module: *std.Build.Module, targets: []std.Build.ResolvedTarget) void {
         module.addImport("zanama", self.zanama_api);
         const libs = self.zb.createZanamaLibsResolved(name, module, targets);
+        const install_step = self.b.getInstallStep();
         for (libs.artifacts) |artifact| {
-            self.packer.addArg(artifact.name);
-            self.packer.addFileArg(artifact.getEmittedBin());
+            const inst = self.b.addInstallArtifact(artifact, .{
+                .dest_dir = .{ .override = .lib },
+                .h_dir = .disabled,
+                .implib_dir = .disabled,
+                .pdb_dir = .disabled,
+            });
+            install_step.dependOn(&inst.step);
         }
-        const install_json = self.b.addInstallFile(libs.json, std.mem.concat(self.b.allocator, u8, &.{name, ".json"}) catch @panic("OOM"));
+        const install_json = self.b.addInstallFile(libs.json, std.mem.concat(self.b.allocator, u8, &.{ name, ".json" }) catch @panic("OOM"));
         install_json.step.dependOn(libs.json_step);
-        self.b.getInstallStep().dependOn(&install_json.step);
+        install_step.dependOn(&install_json.step);
     }
 };
diff --git a/src/main/java/com/falsepattern/falsetweaks/modules/natives/NativeLoader.java b/src/main/java/com/falsepattern/falsetweaks/modules/natives/NativeLoader.java
@@ -62,7 +62,7 @@ public NativeLoader(Class<?> root) throws UnsupportedPlatformException {
         val os = OS.getCurrent();
         val libc = os.libc();
         currentTriple = new Triple(arch, os, libc);
-        val res = root.getResource("/assets/falsetweaks/natives.pak");
+        val res = root.getResource("/assets/falsetweaks/natives.zip");
         if (res == null) {
             throw new UnsupportedPlatformException("No resource package found!");
         }
@@ -80,7 +80,7 @@ public String unpackNative(String libName, String cpu) throws UnsupportedPlatfor
         val libNameArchive = libName + "-" + currentTriple.toName() + "-" + cpu;
         val libFile = nativesDir.resolve(libNameSys);
         try {
-            unpacker.unpack(libNameArchive, libFile);
+            unpacker.unpack(libNameSys, libFile);
         } catch (IOException e) {
             throw new UnsupportedPlatformException(e);
         }
@@ -91,10 +91,9 @@ public String unpackNative(String libName, String cpu) throws UnsupportedPlatfor
     public String loadNative(String libName, String cpu) throws UnsupportedPlatformException {
         val libNameSys = currentTriple.toLibName(libName, cpu);
         cpu = cpu == null ? currentTriple.arch.baselineModel : cpu;
-        val libNameArchive = libName + "-" + currentTriple.toName() + "-" + cpu;
         val libFile = nativesDir.resolve(libNameSys);
         try {
-            unpacker.unpack(libNameArchive, libFile);
+            unpacker.unpack(libNameSys, libFile);
         } catch (IOException e) {
             throw new UnsupportedPlatformException(e);
         }
diff --git a/src/main/java/com/falsepattern/falsetweaks/modules/natives/Unpacker.java b/src/main/java/com/falsepattern/falsetweaks/modules/natives/Unpacker.java
@@ -26,14 +26,16 @@
 import lombok.val;
 
 import java.io.BufferedOutputStream;
-import java.io.DataInputStream;
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
 
 public class Unpacker {
     private final URL data;
@@ -43,46 +45,34 @@ public Unpacker(URL data) {
 
     public String[] names() throws IOException {
         @Cleanup val in = data.openStream();
-        @Cleanup val dIn = new DataInputStream(in);
-        val count = dIn.readInt();
-        val result = new String[count];
-        for (int i = 0; i < count; i++) {
-            val nameLength = dIn.readUnsignedByte();
-            val nameBuf = new byte[nameLength];
-            dIn.readFully(nameBuf);
-            val name = new String(nameBuf);
-            result[i] = name;
-            val length = dIn.readInt();
-            dIn.skipBytes(length);
+        @Cleanup val zipIn = new ZipInputStream(in);
+        ZipEntry entry;
+        val result = new ArrayList<String>();
+        while ((entry = zipIn.getNextEntry()) != null) {
+            result.add(entry.getName());
         }
-        return result;
+        return result.toArray(new String[0]);
     }
 
     public void unpack(String blobName, Path into) throws IOException {
         @Cleanup val in = data.openStream();
-        @Cleanup val dIn = new DataInputStream(in);
-        val count = dIn.readInt();
-        for (int i = 0; i < count; i++) {
-            val nameLength = dIn.readUnsignedByte();
-            val nameBuf = new byte[nameLength];
-            dIn.readFully(nameBuf);
-            val name = new String(nameBuf);
-            val length = dIn.readInt();
-            if (!blobName.equals(name)) {
-                dIn.skipBytes(length);
-                continue;
+        @Cleanup val zipIn = new ZipInputStream(in);
+        ZipEntry entry;
+        while ((entry = zipIn.getNextEntry()) != null) {
+            if (entry.getName().equals(blobName)) {
+                val size = entry.getSize();
+                @Cleanup val output = new BufferedOutputStream(Files.newOutputStream(into));
+                copy(zipIn, output, size);
+                return;
             }
-            @Cleanup val output = new BufferedOutputStream(Files.newOutputStream(into));
-            copy(dIn, output, length);
-            return;
         }
         throw new IOException("Blob " + blobName + " not found in pak file!");
     }
 
-    private void copy(InputStream input, OutputStream output, int bytes) throws IOException {
-        val buf = new byte[Math.min(bytes, 4096)];
+    private void copy(InputStream input, OutputStream output, long bytes) throws IOException {
+        val buf = new byte[(int) Math.min(bytes, 4096)];
         while (bytes > 0) {
-            val toRead = Math.min(buf.length, bytes);
+            val toRead = (int)Math.min(buf.length, bytes);
             val read = input.read(buf, 0, toRead);
             if (read < 0) {
                 throw new EOFException();
diff --git a/zig-util/packer.zig b/zig-util/packer.zig
