roxify 1.13.4 → 1.13.6

package/dist/utils/rust-cli-wrapper.js

@@ -233,7 +233,7 @@ function spawnRustCLI(args, options) {
         runSpawn(cliPath);
     });
 }
-export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name, onProgress) {
+export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name, ramBudgetMb, onProgress) {
     const cliPath = findRustBinary();
     if (!cliPath)
         throw new Error('Rust CLI binary not found');
@@ -250,10 +250,13 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         args.push('--passphrase', passphrase);
         args.push('--encrypt', encryptType);
     }
+    if (typeof ramBudgetMb === 'number' && Number.isFinite(ramBudgetMb)) {
+        args.push('--ram-budget-mb', String(Math.max(1, Math.floor(ramBudgetMb))));
+    }
     args.push(inputPath, outputPath);
     await spawnRustCLI(args, { onProgress });
 }
-export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, dict, onProgress) {
+export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, dict, ramBudgetMb, onProgress) {
     const args = ['decompress', inputPath, outputPath];
     if (passphrase)
         args.push('--passphrase', passphrase);
@@ -261,6 +264,9 @@ export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files
         args.push('--files', JSON.stringify(files));
     if (dict)
         args.push('--dict', dict);
+    if (typeof ramBudgetMb === 'number' && Number.isFinite(ramBudgetMb)) {
+        args.push('--ram-budget-mb', String(Math.max(1, Math.floor(ramBudgetMb))));
+    }
     await spawnRustCLI(args, { onProgress });
 }
 export async function listWithRustCLI(inputPath) {

package/native/encoder.rs

@@ -1,8 +1,11 @@
 use anyhow::Result;
 
+use crate::png_chunk_writer::{write_chunked_idat_bytes, write_png_chunk};
+
 const MAGIC: &[u8] = b"ROX1";
 const PIXEL_MAGIC: &[u8] = b"PXL1";
 const PNG_HEADER: &[u8] = &[137, 80, 78, 71, 13, 10, 26, 10];
+const HEADER_VERSION_V2: u8 = 2;
 
 const MARKER_START: [(u8, u8, u8); 3] = [(255, 0, 0), (0, 255, 0), (0, 0, 255)];
 const MARKER_END: [(u8, u8, u8); 3] = [(0, 0, 255), (0, 255, 0), (255, 0, 0)];
@@ -204,12 +207,12 @@ fn build_flat_pixel_buffer(
 }
 
 fn build_meta_pixel_with_name_and_filelist(payload: &[u8], name: Option<&str>, file_list: Option<&str>) -> Result<Vec<u8>> {
-    let version = 1u8;
+    let version = HEADER_VERSION_V2;
     let name_bytes = name.map(|n| n.as_bytes()).unwrap_or(&[]);
     let name_len = name_bytes.len().min(255) as u8;
-    let payload_len_bytes = (payload.len() as u32).to_be_bytes();
+    let payload_len_bytes = (payload.len() as u64).to_be_bytes();
 
-    let mut result = Vec::with_capacity(1 + 1 + name_len as usize + 4 + payload.len() + 256);
+    let mut result = Vec::with_capacity(1 + 1 + name_len as usize + 8 + payload.len() + 256);
     result.push(version);
     result.push(name_len);
 
@@ -245,33 +248,18 @@ fn build_png(width: usize, height: usize, idat_data: &[u8], file_list: Option<&s
     ihdr_data[11] = 0;
     ihdr_data[12] = 0;
 
-    write_chunk(&mut png, b"IHDR", &ihdr_data)?;
-    write_chunk(&mut png, b"IDAT", idat_data)?;
+    write_png_chunk(&mut png, b"IHDR", &ihdr_data)?;
+    write_chunked_idat_bytes(&mut png, idat_data)?;
 
     if let Some(file_list_json) = file_list {
-        write_chunk(&mut png, b"rXFL", file_list_json.as_bytes())?;
+        write_png_chunk(&mut png, b"rXFL", file_list_json.as_bytes())?;
     }
 
-    write_chunk(&mut png, b"IEND", &[])?;
+    write_png_chunk(&mut png, b"IEND", &[])?;
 
     Ok(png)
 }
 
-fn write_chunk(out: &mut Vec<u8>, chunk_type: &[u8; 4], data: &[u8]) -> Result<()> {
-    let len = data.len() as u32;
-    out.extend_from_slice(&len.to_be_bytes());
-    out.extend_from_slice(chunk_type);
-    out.extend_from_slice(data);
-
-    let mut hasher = crc32fast::Hasher::new();
-    hasher.update(chunk_type);
-    hasher.update(data);
-    let crc = hasher.finalize();
-
-    out.extend_from_slice(&crc.to_be_bytes());
-    Ok(())
-}
-
 fn create_raw_deflate_from_rows(flat: &[u8], row_bytes: usize, height: usize) -> Vec<u8> {
     let stride = row_bytes + 1;
     let scanlines_total = height * stride;

package/native/io_advice.rs

@@ -0,0 +1,43 @@
+use std::fs::File;
+#[cfg(target_os = "linux")]
+use std::os::fd::AsRawFd;
+
+pub const INPUT_DROP_GRANULARITY: u64 = 8 * 1024 * 1024;
+
+pub fn advise_file_sequential(file: &File) {
+    #[cfg(target_os = "linux")]
+    unsafe {
+        let _ = libc::posix_fadvise(file.as_raw_fd(), 0, 0, libc::POSIX_FADV_SEQUENTIAL);
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    let _ = file;
+}
+
+pub fn advise_drop(file: &File, offset: u64, len: u64) {
+    if len == 0 {
+        return;
+    }
+
+    #[cfg(target_os = "linux")]
+    unsafe {
+        let _ = libc::posix_fadvise(
+            file.as_raw_fd(),
+            offset as libc::off_t,
+            len as libc::off_t,
+            libc::POSIX_FADV_DONTNEED,
+        );
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    let _ = (file, offset, len);
+}
+
+pub fn sync_and_drop(file: &File, len: u64) {
+    if len < INPUT_DROP_GRANULARITY {
+        return;
+    }
+
+    let _ = file.sync_data();
+    advise_drop(file, 0, len);
+}

package/native/io_ntfs_optimized.rs

@@ -0,0 +1,99 @@
+use std::fs::{File, OpenOptions};
+use std::io::{BufWriter, Write};
+use std::path::Path;
+
+/// Buffer size optimized for NTFS (larger = fewer syscalls)
+#[cfg(windows)]
+const NTFS_WRITE_BUFFER: usize = 4 * 1024 * 1024; // 4MB for Windows/NTFS
+#[cfg(not(windows))]
+const NTFS_WRITE_BUFFER: usize = 64 * 1024; // 64KB for Unix
+
+/// Optimized file writer with large buffer for NTFS
+pub struct OptimizedFileWriter {
+    writer: BufWriter<File>,
+}
+
+impl OptimizedFileWriter {
+    pub fn create(path: &Path) -> std::io::Result<Self> {
+        let file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(path)?;
+        
+        Ok(Self {
+            writer: BufWriter::with_capacity(NTFS_WRITE_BUFFER, file),
+        })
+    }
+    
+    pub fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
+        self.writer.write_all(buf)
+    }
+    
+    pub fn flush(&mut self) -> std::io::Result<()> {
+        self.writer.flush()
+    }
+}
+
+/// Write file with optimized buffering for target filesystem
+pub fn write_file_optimized(path: &Path, content: &[u8]) -> std::io::Result<()> {
+    let mut writer = OptimizedFileWriter::create(path)?;
+    writer.write_all(content)?;
+    writer.flush()?;
+    Ok(())
+}
+
+/// Batch write multiple files - keeps files open for better NTFS performance
+pub fn write_files_batch(
+    base_dir: &Path,
+    files: &[(String, &[u8])],
+) -> Result<Vec<String>, String> {
+    let mut written = Vec::with_capacity(files.len());
+    
+    for (rel_path, content) in files {
+        let safe_path = sanitize_path(rel_path);
+        let dest = base_dir.join(&safe_path);
+        
+        if let Some(parent) = dest.parent() {
+            std::fs::create_dir_all(parent)
+                .map_err(|e| format!("Cannot create parent dir {:?}: {}", parent, e))?;
+        }
+        
+        write_file_optimized(&dest, content)
+            .map_err(|e| format!("Cannot write {:?}: {}", dest, e))?;
+        
+        written.push(safe_path.to_string_lossy().to_string());
+    }
+    
+    Ok(written)
+}
+
+fn sanitize_path(path: &str) -> std::path::PathBuf {
+    let mut safe = std::path::PathBuf::new();
+    for comp in std::path::Path::new(path).components() {
+        if let std::path::Component::Normal(osstr) = comp {
+            safe.push(osstr);
+        }
+    }
+    safe
+}
+
+/// Pre-allocate file space on NTFS to reduce fragmentation
+#[cfg(windows)]
+pub fn preallocate_file(path: &Path, size: u64) -> std::io::Result<()> {
+    use std::os::windows::fs::FileExt;
+    
+    let file = OpenOptions::new()
+        .write(true)
+        .create(true)
+        .open(path)?;
+    
+    // Pre-allocate space
+    file.set_len(size)?;
+    Ok(())
+}
+
+#[cfg(not(windows))]
+pub fn preallocate_file(_path: &Path, _size: u64) -> std::io::Result<()> {
+    Ok(())
+}

package/native/lib.rs

@@ -17,6 +17,8 @@ mod encoder;
 mod packer;
 mod crypto;
 mod png_utils;
+mod png_chunk_writer;
+mod io_advice;
 mod image_utils;
 mod audio;
 mod progress;