diff --git a/src/main/kotlin/app/revanced/cli/patcher/Patcher.kt b/src/main/kotlin/app/revanced/cli/patcher/Patcher.kt
index 1ab0da4..f99bfee 100644
--- a/src/main/kotlin/app/revanced/cli/patcher/Patcher.kt
+++ b/src/main/kotlin/app/revanced/cli/patcher/Patcher.kt
@@ -23,16 +23,20 @@ internal object Patcher {
         if (output.exists()) Files.delete(output.toPath())
         args.inputFile.copyTo(output)
 
-        ZipFileSystemUtils(output).use { fileSystem ->
+        val result = patcher.save()
+        val inputFile = if (!args.disableResourcePatching && result.resourceFile != null) {
+            result.resourceFile
+        } else null
+        ZipFileSystemUtils(inputFile, output).use { fileSystem ->
             // replace all dex files
-            val result = patcher.save()
             result.dexFiles.forEach {
                 fileSystem.write(it.name, it.memoryDataStore.data)
             }
 
-            // write resources
-            if (!args.disableResourcePatching) {
-                fileSystem.writePathRecursively(File(args.cacheDirectory).resolve("build").toPath())
+            // inputFile being null implies resource patching being disabled
+            if (inputFile != null) {
+                // write resources
+                fileSystem.writeInput()
                 fileSystem.uncompress(*result.doNotCompress!!.toTypedArray())
             }
         }
diff --git a/src/main/kotlin/app/revanced/utils/filesystem/ZipFileSystemUtils.kt b/src/main/kotlin/app/revanced/utils/filesystem/ZipFileSystemUtils.kt
index b2206a3..e33381b 100644
--- a/src/main/kotlin/app/revanced/utils/filesystem/ZipFileSystemUtils.kt
+++ b/src/main/kotlin/app/revanced/utils/filesystem/ZipFileSystemUtils.kt
@@ -7,14 +7,15 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.util.zip.ZipEntry
 
-internal class ZipFileSystemUtils(
-    file: File
-) : Closeable {
-    private var zipFileSystem = FileSystems.newFileSystem(file.toPath(), mapOf("noCompression" to true))
+internal class ZipFileSystemUtils(input: File?, output: File) : Closeable {
+    private val inFileSystem = if (input != null) {
+        FileSystems.newFileSystem(input.toPath())
+    } else null
+    private val outFileSystem = FileSystems.newFileSystem(output.toPath(), mapOf("noCompression" to true))
 
     private fun Path.deleteRecursively() {
         if (!Files.exists(this)) {
-            throw IllegalStateException("File exists in real folder but not in zip file system")
+            throw IllegalStateException("File exists in input but not in output, cannot delete")
         }
 
         if (Files.isDirectory(this)) {
@@ -26,21 +27,25 @@ internal class ZipFileSystemUtils(
         Files.delete(this)
     }
 
-    internal fun writePathRecursively(path: Path) {
-        Files.list(path).let { fileStream ->
+    internal fun writeInput() {
+        if (inFileSystem == null) {
+            throw IllegalArgumentException("Input file not set")
+        }
+        val root = inFileSystem.getPath(inFileSystem.separator)
+
+        Files.list(root).close()
+
+        Files.list(root).also { fileStream ->
             fileStream.forEach { filePath ->
-                val fileSystemPath = filePath.getRelativePath(path)
+                val fileSystemPath = filePath.getRelativePath(root)
                 fileSystemPath.deleteRecursively()
             }
-
-            fileStream
         }.close()
 
-        Files.walk(path).let { fileStream ->
-            // don't include build directory
-            // by skipping the root node.
+        Files.walk(root).also { fileStream ->
+            // don't include build directory by skipping the root node.
             fileStream.skip(1).forEach { filePath ->
-                val relativePath = filePath.getRelativePath(path)
+                val relativePath = filePath.getRelativePath(root)
 
                 if (Files.isDirectory(filePath)) {
                     Files.createDirectory(relativePath)
@@ -49,17 +54,18 @@ internal class ZipFileSystemUtils(
 
                 Files.copy(filePath, relativePath)
             }
-
-            fileStream
         }.close()
     }
 
-    internal fun write(path: String, content: ByteArray) = Files.write(zipFileSystem.getPath(path), content)
+    internal fun write(path: String, content: ByteArray) = Files.write(outFileSystem.getPath(path), content)
 
-    private fun Path.getRelativePath(path: Path): Path = zipFileSystem.getPath(path.relativize(this).toString())
+    private fun Path.getRelativePath(path: Path): Path = outFileSystem.getPath(path.relativize(this).toString())
 
     internal fun uncompress(vararg paths: String) =
-        paths.forEach { Files.setAttribute(zipFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
+        paths.forEach { Files.setAttribute(outFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
 
-    override fun close() = zipFileSystem.close()
+    override fun close() {
+        inFileSystem?.close()
+        outFileSystem.close()
+    }
 }
\ No newline at end of file