roxify 1.13.8 → 1.14.0

package/native/image_utils.rs

@@ -1,82 +0,0 @@
-use image::{ImageFormat, DynamicImage, ImageReader};
-use std::io::Cursor;
-
-fn load_no_limits(input: &[u8]) -> Result<DynamicImage, String> {
-    let mut reader = ImageReader::new(Cursor::new(input))
-        .with_guessed_format()
-        .map_err(|e| format!("Failed to guess format: {}", e))?;
-    reader.no_limits();
-    reader.decode().map_err(|e| format!("Failed to load image: {}", e))
-}
-
-pub fn sharp_resize(
-    input: &[u8],
-    width: u32,
-    height: u32,
-    kernel: &str,
-) -> Result<Vec<u8>, String> {
-    let img = load_no_limits(input)?;
-
-    let filter = match kernel {
-        "nearest" => image::imageops::FilterType::Nearest,
-        "bilinear" | "linear" => image::imageops::FilterType::Triangle,
-        "cubic" | "bicubic" => image::imageops::FilterType::CatmullRom,
-        "lanczos" | "lanczos3" => image::imageops::FilterType::Lanczos3,
-        _ => image::imageops::FilterType::Nearest,
-    };
-
-    let resized = img.resize_exact(width, height, filter);
-
-    let mut output = Vec::new();
-    resized.write_to(&mut Cursor::new(&mut output), ImageFormat::Png)
-        .map_err(|e| format!("Failed to encode PNG: {}", e))?;
-
-    Ok(output)
-}
-
-pub fn sharp_raw_pixels(input: &[u8]) -> Result<(Vec<u8>, u32, u32), String> {
-    let img = load_no_limits(input)?;
-
-    let rgb = img.to_rgb8();
-    let width = rgb.width();
-    let height = rgb.height();
-    let raw = rgb.into_raw();
-
-    Ok((raw, width, height))
-}
-
-pub fn sharp_metadata(input: &[u8]) -> Result<(u32, u32, String), String> {
-    let img = load_no_limits(input)?;
-
-    let width = img.width();
-    let height = img.height();
-    let format = match img {
-        DynamicImage::ImageLuma8(_) => "gray",
-        DynamicImage::ImageRgb8(_) => "rgb",
-        DynamicImage::ImageRgba8(_) => "rgba",
-        _ => "unknown",
-    };
-
-    Ok((width, height, format.to_string()))
-}
-
-pub fn rgb_to_png(rgb: &[u8], width: u32, height: u32) -> Result<Vec<u8>, String> {
-    use image::codecs::png::{PngEncoder, CompressionType, FilterType};
-    use image::ImageEncoder;
-
-    let mut output = Vec::new();
-    // Data is already zstd-compressed, so PNG deflate adds overhead.
-    // Use Uncompressed (stored blocks) to avoid wasting CPU on incompressible data.
-    let encoder = PngEncoder::new_with_quality(
-        &mut output,
-        CompressionType::Uncompressed,
-        FilterType::NoFilter,
-    );
-    encoder.write_image(rgb, width, height, image::ExtendedColorType::Rgb8)
-        .map_err(|e| format!("Failed to encode PNG: {}", e))?;
-    Ok(output)
-}
-
-pub fn png_to_rgb(png: &[u8]) -> Result<(Vec<u8>, u32, u32), String> {
-    sharp_raw_pixels(png)
-}

package/native/io_advice.rs

@@ -1,43 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,480 +0,0 @@
-#![allow(dead_code, unused_imports)]
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-mod core;
-mod rans;
-mod rans_byte;
-mod bwt;
-mod mtf;
-mod context_mixing;
-mod pool;
-mod hybrid;
-mod encoder;
-mod packer;
-mod crypto;
-mod png_utils;
-mod png_chunk_writer;
-mod io_advice;
-mod image_utils;
-mod audio;
-mod progress;
-mod reconstitution;
-mod archive;
-mod streaming;
-
-pub use core::*;
-pub use rans::*;
-pub use bwt::*;
-pub use context_mixing::*;
-pub use pool::*;
-pub use hybrid::*;
-
-#[napi(object)]
-pub struct ScanResult {
-    pub marker_positions: Vec<u32>,
-    pub magic_positions: Vec<u32>,
-}
-
-#[napi(object)]
-pub struct CompressionReport {
-    pub original_size: f64,
-    pub compressed_size: f64,
-    pub ratio: f64,
-    pub entropy_bits: f64,
-    pub blocks_count: u32,
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn scan_pixels(buffer: Buffer, channels: u32, marker_bytes: Option<Buffer>) -> Result<ScanResult> {
-    let slice: &[u8] = &buffer;
-    let markers_slice: Option<&[u8]> = marker_bytes.as_ref().map(|b| &**b);
-    let res = core::scan_pixels_bytes(slice, channels as usize, markers_slice);
-    Ok(ScanResult { marker_positions: res.marker_positions, magic_positions: res.magic_positions })
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_crc32(buffer: Buffer) -> u32 {
-    core::crc32_bytes(&buffer)
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_adler32(buffer: Buffer) -> u32 {
-    core::adler32_bytes(&buffer)
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_delta_encode(buffer: Buffer) -> Buffer {
-    core::delta_encode_bytes(&buffer).into()
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_delta_decode(buffer: Buffer) -> Buffer {
-    core::delta_decode_bytes(&buffer).into()
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_zstd_compress(buffer: Buffer, level: i32) -> Result<Buffer> {
-    core::zstd_compress_bytes(&buffer, level, None).map(Buffer::from).map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_zstd_compress_with_dict(buffer: Buffer, level: i32, dict: Buffer) -> Result<Buffer> {
-    let dict_slice: &[u8] = &dict;
-    core::zstd_compress_bytes(&buffer, level, Some(dict_slice)).map(Buffer::from).map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_zstd_decompress(buffer: Buffer) -> Result<Buffer> {
-    core::zstd_decompress_bytes(&buffer, None).map(Buffer::from).map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_zstd_decompress_with_dict(buffer: Buffer, dict: Buffer) -> Result<Buffer> {
-    let dict_slice: &[u8] = &dict;
-    core::zstd_decompress_bytes(&buffer, Some(dict_slice)).map(Buffer::from).map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn bwt_transform(buffer: Buffer) -> Result<Buffer> {
-    match bwt::bwt_encode(&buffer) {
-        Ok(result) => {
-            let mut output = Vec::with_capacity(4 + result.transformed.len());
-            output.extend_from_slice(&result.primary_index.to_le_bytes());
-            output.extend_from_slice(&result.transformed);
-            Ok(output.into())
-        }
-        Err(e) => Err(Error::from_reason(e.to_string())),
-    }
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn entropy_estimate(buffer: Buffer) -> f32 {
-    context_mixing::analyze_entropy(&buffer)
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn hybrid_compress(buffer: Buffer) -> Result<Buffer> {
-    match hybrid::compress_high_performance(&buffer) {
-        Ok((compressed, _stats)) => Ok(Buffer::from(compressed)),
-        Err(e) => Err(Error::from_reason(e.to_string())),
-    }
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn hybrid_decompress(buffer: Buffer) -> Result<Buffer> {
-    hybrid::decompress_high_performance(&buffer)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn get_compression_stats(buffer: Buffer) -> CompressionReport {
-    match hybrid::compress_high_performance(&buffer) {
-        Ok((_compressed, stats)) => CompressionReport {
-            original_size: stats.original_size as f64,
-            compressed_size: stats.compressed_size as f64,
-            ratio: stats.ratio,
-            entropy_bits: stats.entropy_bits as f64,
-            blocks_count: stats.blocks_count as u32,
-        },
-        Err(_) => CompressionReport {
-            original_size: buffer.len() as f64,
-            compressed_size: 0.0,
-            ratio: 0.0,
-            entropy_bits: 0.0,
-            blocks_count: 0,
-        },
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_scan_magic() {
-        let data = b"xxxxROX1yyyyROX1".to_vec();
-        let res = core::scan_pixels_bytes(&data, 3, None);
-        assert_eq!(res.magic_positions.len(), 2);
-    }
-
-    #[test]
-    fn test_bwt() {
-        let data = b"banana".to_vec();
-        let enc = bwt::bwt_encode(&data).unwrap();
-        assert!(!enc.transformed.is_empty());
-    }
-
-    #[test]
-    fn test_entropy() {
-        let data = b"aaaaabbbcc";
-        let entropy = context_mixing::analyze_entropy(data);
-        assert!(entropy > 0.0 && entropy < 8.0);
-    }
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_png(buffer: Buffer, compression_level: i32) -> Result<Buffer> {
-    encoder::encode_to_png(&buffer, compression_level)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_png_raw(buffer: Buffer, compression_level: i32) -> Result<Buffer> {
-    encoder::encode_to_png_raw(&buffer, compression_level)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_png_with_name_and_filelist(
-    buffer: Buffer,
-    compression_level: i32,
-    name: Option<String>,
-    file_list_json: Option<String>,
-) -> Result<Buffer> {
-    encoder::encode_to_png_with_name_and_filelist(
-        &buffer,
-        compression_level,
-        name.as_deref(),
-        file_list_json.as_deref(),
-    )
-    .map(Buffer::from)
-    .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_png_with_encryption_name_and_filelist(
-    buffer: Buffer,
-    compression_level: i32,
-    passphrase: Option<String>,
-    encrypt_type: Option<String>,
-    name: Option<String>,
-    file_list_json: Option<String>,
-) -> Result<Buffer> {
-    encoder::encode_to_png_with_encryption_name_and_filelist(
-        &buffer,
-        compression_level,
-        passphrase.as_deref(),
-        encrypt_type.as_deref(),
-        name.as_deref(),
-        file_list_json.as_deref(),
-    )
-    .map(Buffer::from)
-    .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[napi(object)]
-pub struct PngChunkData {
-    pub name: String,
-    pub data: Buffer,
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn extract_png_chunks(png_buffer: Buffer) -> Result<Vec<PngChunkData>> {
-    let chunks = png_utils::extract_png_chunks(&png_buffer)
-        .map_err(|e| Error::from_reason(e))?;
-
-    Ok(chunks.into_iter().map(|c| PngChunkData {
-        name: c.name,
-        data: c.data.into(),
-    }).collect())
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn encode_png_chunks(chunks: Vec<PngChunkData>) -> Result<Buffer> {
-    let native_chunks: Vec<png_utils::PngChunk> = chunks.into_iter()
-        .map(|c| png_utils::PngChunk {
-            name: c.name,
-            data: c.data.to_vec(),
-        })
-        .collect();
-
-    png_utils::encode_png_chunks(&native_chunks)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[napi(object)]
-pub struct PngMetadata {
-    pub width: u32,
-    pub height: u32,
-    pub bit_depth: u32,
-    pub color_type: u32,
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn get_png_metadata(png_buffer: Buffer) -> Result<PngMetadata> {
-    let (width, height, bit_depth, color_type) = png_utils::get_png_metadata(&png_buffer)
-        .map_err(|e| Error::from_reason(e))?;
-
-    Ok(PngMetadata {
-        width,
-        height,
-        bit_depth: bit_depth as u32,
-        color_type: color_type as u32,
-    })
-}
-
-#[napi(object)]
-pub struct SharpMetadata {
-    pub width: u32,
-    pub height: u32,
-    pub format: String,
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn sharp_resize_image(
-    input_buffer: Buffer,
-    width: u32,
-    height: u32,
-    kernel: String,
-) -> Result<Buffer> {
-    image_utils::sharp_resize(&input_buffer, width, height, &kernel)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn sharp_raw_pixels(input_buffer: Buffer) -> Result<Buffer> {
-    let (pixels, _w, _h) = image_utils::sharp_raw_pixels(&input_buffer)
-        .map_err(|e| Error::from_reason(e))?;
-    Ok(pixels.into())
-}
-
-#[napi(object)]
-pub struct RawPixelsWithDimensions {
-    pub pixels: Buffer,
-    pub width: u32,
-    pub height: u32,
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn sharp_to_raw(input_buffer: Buffer) -> Result<RawPixelsWithDimensions> {
-    let (pixels, width, height) = image_utils::sharp_raw_pixels(&input_buffer)
-        .map_err(|e| Error::from_reason(e))?;
-    Ok(RawPixelsWithDimensions { pixels: pixels.into(), width, height })
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn sharp_metadata(input_buffer: Buffer) -> Result<SharpMetadata> {
-    let (width, height, format) = image_utils::sharp_metadata(&input_buffer)
-        .map_err(|e| Error::from_reason(e))?;
-    Ok(SharpMetadata { width, height, format })
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn rgb_to_png(rgb_buffer: Buffer, width: u32, height: u32) -> Result<Buffer> {
-    image_utils::rgb_to_png(&rgb_buffer, width, height)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn png_to_rgb(png_buffer: Buffer) -> Result<RawPixelsWithDimensions> {
-    let (pixels, width, height) = image_utils::png_to_rgb(&png_buffer)
-        .map_err(|e| Error::from_reason(e))?;
-    Ok(RawPixelsWithDimensions { pixels: pixels.into(), width, height })
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn crop_and_reconstitute(png_buffer: Buffer) -> Result<Buffer> {
-    reconstitution::crop_and_reconstitute(&png_buffer)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn unstretch_nn(png_buffer: Buffer) -> Result<Buffer> {
-    reconstitution::unstretch_nn(&png_buffer)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn extract_payload_from_png(png_buffer: Buffer) -> Result<Buffer> {
-    png_utils::extract_payload_from_png(&png_buffer)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn extract_file_list_from_pixels(png_buffer: Buffer) -> Result<String> {
-    png_utils::extract_file_list_from_pixels(&png_buffer)
-        .map_err(|e| Error::from_reason(e))
-}
-
-// ─── WAV container NAPI exports ──────────────────────────────────────────────
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_wav(buffer: Buffer, compression_level: i32) -> Result<Buffer> {
-    encoder::encode_to_wav(&buffer, compression_level)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_wav_with_name_and_filelist(
-    buffer: Buffer,
-    compression_level: i32,
-    name: Option<String>,
-    file_list_json: Option<String>,
-) -> Result<Buffer> {
-    encoder::encode_to_wav_with_name_and_filelist(
-        &buffer,
-        compression_level,
-        name.as_deref(),
-        file_list_json.as_deref(),
-    )
-    .map(Buffer::from)
-    .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_encode_wav_with_encryption_name_and_filelist(
-    buffer: Buffer,
-    compression_level: i32,
-    passphrase: Option<String>,
-    encrypt_type: Option<String>,
-    name: Option<String>,
-    file_list_json: Option<String>,
-) -> Result<Buffer> {
-    encoder::encode_to_wav_with_encryption_name_and_filelist(
-        &buffer,
-        compression_level,
-        passphrase.as_deref(),
-        encrypt_type.as_deref(),
-        name.as_deref(),
-        file_list_json.as_deref(),
-    )
-    .map(Buffer::from)
-    .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_decode_wav_payload(wav_buffer: Buffer) -> Result<Buffer> {
-    encoder::decode_wav_payload(&wav_buffer)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e.to_string()))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_bytes_to_wav(buffer: Buffer) -> Buffer {
-    audio::bytes_to_wav(&buffer).into()
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_wav_to_bytes(wav_buffer: Buffer) -> Result<Buffer> {
-    audio::wav_to_bytes(&wav_buffer)
-        .map(Buffer::from)
-        .map_err(|e| Error::from_reason(e))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn native_is_wav(buffer: Buffer) -> bool {
-    audio::is_wav(&buffer)
-}
-