roxify 1.13.8 → 1.14.0

package/native/main.rs

@@ -1,842 +0,0 @@
-#![allow(dead_code)]
-use clap::{Parser, Subcommand};
-use std::fs::File;
-use std::io::{Read, Write};
-
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-mod core;
-mod encoder;
-mod packer;
-mod crypto;
-mod png_utils;
-mod png_chunk_writer;
-mod io_advice;
-mod audio;
-mod reconstitution;
-mod archive;
-mod streaming;
-mod streaming_decode;
-mod streaming_encode;
-mod progress;
-
-use crate::encoder::ImageFormat;
-use std::path::PathBuf;
-
-const MB_U64: u64 = 1024 * 1024;
-const GB_U64: u64 = 1024 * MB_U64;
-
-// Adaptive RAM Budget Configuration
-const MIN_RAM_BUDGET_MB: u64 = 512;
-const DEFAULT_RAM_BUDGET_MB: u64 = 2048;
-const RESERVED_RAM_MB: u64 = 1024;
-const MIN_WRITE_BUFFER_BYTES: usize = 16 * 1024 * 1024;
-const MAX_WRITE_BUFFER_BYTES: usize = 256 * 1024 * 1024;
-
-// Performance Targets (under 10 seconds)
-const TARGET_ENCODE_TIME_SECS: u64 = 10;
-const TARGET_DECODE_TIME_SECS: u64 = 10;
-const FAST_COMPRESSION_THRESHOLD_MB: u64 = 100;
-const STREAMING_THRESHOLD_MB: u64 = 500;
-
-// Adaptive Compression Levels
-const COMPRESSION_ULTRA_FAST: i32 = 1;    // < 100MB files, lots of RAM
-const COMPRESSION_FAST: i32 = 2;          // < 500MB files
-const COMPRESSION_BALANCED: i32 = 3;      // Default, 500MB-2GB
-const COMPRESSION_SMALL_FILES: i32 = 5;   // Many small files
-
-// RAM Usage Tiers
-const RAM_TIER_ULTRA: u64 = 16384;        // 16GB+ - Aggressive optimization
-const RAM_TIER_HIGH: u64 = 8192;          // 8GB+ - Fast mode
-const RAM_TIER_MEDIUM: u64 = 4096;        // 4GB+ - Balanced
-const RAM_TIER_LOW: u64 = 2048;           // 2GB+ - Conservative
-
-#[derive(Parser)]
-#[command(author, version)]
-struct Cli {
-    #[command(subcommand)]
-    command: Commands,
-}
-
-#[derive(Subcommand)]
-enum Commands {
-    Encode {
-        input: PathBuf,
-        output: PathBuf,
-        #[arg(short, long, default_value_t = 3)]
-        level: i32,
-        #[arg(short, long)]
-        passphrase: Option<String>,
-        #[arg(short, long, default_value = "aes")]
-        encrypt: String,
-        #[arg(short, long)]
-        name: Option<String>,
-        /// optional zstd dictionary file for payload compression
-        #[arg(long, value_name = "FILE")]
-        dict: Option<PathBuf>,
-        #[arg(long, value_name = "MB")]
-        ram_budget_mb: Option<u64>,
-    },
-
-    List {
-        input: PathBuf,
-    },
-    Havepassphrase {
-        input: PathBuf,
-    },
-    Scan {
-        input: PathBuf,
-        #[arg(short, long, value_name = "FILE")]
-        #[arg(short, long, default_value_t = 4)]
-        channels: usize,
-        #[arg(short, long, value_delimiter = ',')]
-        markers: Vec<String>,
-    },
-    DeltaEncode {
-        input: PathBuf,
-        output: Option<PathBuf>,
-    },
-    DeltaDecode {
-        input: PathBuf,
-        output: Option<PathBuf>,
-    },
-    Compress {
-        input: PathBuf,
-        output: Option<PathBuf>,
-        #[arg(short, long, default_value_t = 19)]
-        level: i32,
-        /// optional zstd dictionary file to use for compression
-        #[arg(long, value_name = "FILE")]
-        dict: Option<PathBuf>,
-    },
-    TrainDict {
-        /// sample files used to train the dictionary
-        #[arg(short, long, value_name = "FILE", required = true)]
-        samples: Vec<PathBuf>,
-        /// desired dictionary size in bytes
-        #[arg(short, long, default_value_t = 112640)]
-        size: usize,
-        /// output dictionary file
-        output: PathBuf,
-    },
-    Decompress {
-        input: PathBuf,
-        output: Option<PathBuf>,
-        #[arg(long)]
-        files: Option<String>,
-        #[arg(short, long)]
-        passphrase: Option<String>,
-        /// optional dictionary file used during decompression
-        #[arg(long, value_name = "FILE")]
-        dict: Option<PathBuf>,
-        #[arg(long, value_name = "MB")]
-        ram_budget_mb: Option<u64>,
-    },
-    Crc32 {
-        input: PathBuf,
-    },
-    Adler32 {
-        input: PathBuf,
-    },
-}
-
-fn read_all(path: &PathBuf) -> anyhow::Result<Vec<u8>> {
-    let metadata = std::fs::metadata(path)?;
-    let size = metadata.len() as usize;
-    let mut f = File::open(path)?;
-    let mut buf = Vec::with_capacity(size);
-    f.read_to_end(&mut buf)?;
-    Ok(buf)
-}
-
-pub fn parse_linux_mem_available_mb() -> Option<u64> {
-    let meminfo = std::fs::read_to_string("/proc/meminfo").ok()?;
-    let line = meminfo.lines().find(|l| l.starts_with("MemAvailable:"))?;
-    let kb = line
-        .split_whitespace()
-        .nth(1)
-        .and_then(|v| v.parse::<u64>().ok())?;
-    Some(kb / 1024)
-}
-
-fn parse_total_ram_mb() -> Option<u64> {
-    let meminfo = std::fs::read_to_string("/proc/meminfo").ok()?;
-    let line = meminfo.lines().find(|l| l.starts_with("MemTotal:"))?;
-    let kb = line
-        .split_whitespace()
-        .nth(1)
-        .and_then(|v| v.parse::<u64>().ok())?;
-    Some(kb / 1024)
-}
-
-fn get_cpu_cores() -> usize {
-    std::thread::available_parallelism()
-        .map(|p| p.get())
-        .unwrap_or(4)
-}
-
-/// Determine RAM tier based on available memory
-fn get_ram_tier(available_mb: u64) -> &'static str {
-    match available_mb {
-        x if x >= RAM_TIER_ULTRA => "ultra",
-        x if x >= RAM_TIER_HIGH => "high",
-        x if x >= RAM_TIER_MEDIUM => "medium",
-        _ => "low",
-    }
-}
-
-/// Calculate adaptive RAM budget with aggressive optimization for Pyxelze
-fn auto_ram_budget_mb() -> u64 {
-    let total_mb = parse_total_ram_mb().unwrap_or(4096);
-    let available_mb = parse_linux_mem_available_mb().unwrap_or(total_mb / 2);
-    let cpu_cores = get_cpu_cores();
-    
-    // Base calculation: use up to 85% of available RAM for ultra-fast mode
-    let base_budget = available_mb.saturating_mul(85) / 100;
-    
-    // Adjust based on RAM tier and CPU cores
-    let tier_multiplier = match get_ram_tier(total_mb) {
-        "ultra" if cpu_cores >= 8 => 90,      // 16GB+ with 8+ cores: 90%
-        "ultra" => 85,                        // 16GB+ with fewer cores
-        "high" if cpu_cores >= 6 => 80,       // 8GB+ with 6+ cores
-        "high" => 75,                         // 8GB+
-        "medium" => 70,                       // 4GB+
-        _ => 65,                              // 2GB+
-    };
-    
-    let budget = available_mb.saturating_mul(tier_multiplier) / 100;
-    let budget = budget.max(MIN_RAM_BUDGET_MB);
-    
-    // Cap at reasonable maximum to prevent OOM
-    let max_budget = (total_mb / 2).max(8192);
-    budget.min(max_budget)
-}
-
-/// Auto-select optimal compression level based on file size and available RAM
-fn auto_compression_level(file_size_mb: u64, ram_budget_mb: u64) -> i32 {
-    // Ultra-fast for small files with lots of RAM
-    if file_size_mb < FAST_COMPRESSION_THRESHOLD_MB && ram_budget_mb >= RAM_TIER_HIGH {
-        return COMPRESSION_ULTRA_FAST;
-    }
-    
-    // Fast mode for medium files
-    if file_size_mb < STREAMING_THRESHOLD_MB {
-        return COMPRESSION_FAST;
-    }
-    
-    // Balanced for large files
-    if ram_budget_mb >= RAM_TIER_MEDIUM {
-        return COMPRESSION_BALANCED;
-    }
-    
-    // Conservative for low RAM
-    COMPRESSION_SMALL_FILES
-}
-
-/// Determine if streaming mode should be used
-fn should_use_streaming(file_size_mb: u64, ram_budget_mb: u64) -> bool {
-    // Force streaming for very large files
-    if file_size_mb >= 2048 { // 2GB+
-        return true;
-    }
-    
-    // Use streaming when file is larger than 60% of RAM budget
-    let threshold = ram_budget_mb.saturating_mul(60) / 100;
-    file_size_mb >= threshold
-}
-
-/// Get optimal thread count for zstd based on RAM and CPU
-fn optimal_zstd_threads(file_size_mb: u64, ram_budget_mb: u64) -> i32 {
-    let cpu_cores = get_cpu_cores();
-    let ram_tier = get_ram_tier(parse_total_ram_mb().unwrap_or(4096));
-    
-    match ram_tier {
-        "ultra" => cpu_cores.min(16) as i32,
-        "high" => cpu_cores.min(8) as i32,
-        _ if file_size_mb > 1000 => cpu_cores.min(4) as i32,
-        _ => cpu_cores.min(2) as i32,
-    }
-}
-
-fn resolve_ram_budget_mb(cli_value: Option<u64>) -> u64 {
-    if let Some(v) = cli_value {
-        return v.max(MIN_RAM_BUDGET_MB);
-    }
-
-    if let Ok(v) = std::env::var("ROX_RAM_BUDGET_MB") {
-        if let Ok(parsed) = v.trim().parse::<u64>() {
-            return parsed.max(MIN_RAM_BUDGET_MB);
-        }
-    }
-
-    auto_ram_budget_mb()
-}
-
-fn effective_ram_budget_mb() -> u64 {
-    if let Ok(v) = std::env::var("ROX_RAM_BUDGET_MB_EFFECTIVE") {
-        if let Ok(parsed) = v.trim().parse::<u64>() {
-            return parsed.max(MIN_RAM_BUDGET_MB);
-        }
-    }
-    resolve_ram_budget_mb(None)
-}
-
-fn ram_budget_bytes(ram_budget_mb: u64) -> u64 {
-    ram_budget_mb.saturating_mul(MB_U64)
-}
-
-fn streaming_preference_threshold_bytes(ram_budget_mb: u64) -> u64 {
-    ram_budget_bytes(ram_budget_mb)
-        .saturating_mul(60)
-        .saturating_div(100)
-        .max(64 * MB_U64)
-}
-
-fn normalize_png_archive_bytes(png_data: &[u8], passphrase: Option<&str>) -> anyhow::Result<Vec<u8>> {
-    let payload = png_utils::extract_payload_from_png(png_data).map_err(|e| anyhow::anyhow!(e))?;
-    if payload.is_empty() {
-        return Err(anyhow::anyhow!("Empty payload"));
-    }
-
-    if payload[0] == 0x00u8 {
-        Ok(payload[1..].to_vec())
-    } else {
-        let decrypted = crate::crypto::try_decrypt(&payload, passphrase)
-            .map_err(|e| anyhow::anyhow!("Encrypted payload: {}", e))?;
-        Ok(decrypted)
-    }
-}
-
-fn unpack_archive_bytes(
-    normalized: Vec<u8>,
-    out_dir: &std::path::Path,
-    files_slice: Option<&[String]>,
-    progress: Option<&(dyn Fn(u64, u64, &str) + Send)>,
-) -> anyhow::Result<Vec<String>> {
-    let mut reader: Box<dyn std::io::Read> = if normalized.starts_with(b"ROX1") {
-        Box::new(std::io::Cursor::new(normalized[4..].to_vec()))
-    } else {
-        let mut dec = zstd::stream::Decoder::new(std::io::Cursor::new(normalized))
-            .map_err(|e| anyhow::anyhow!("zstd decoder init: {}", e))?;
-        dec.window_log_max(31)
-            .map_err(|e| anyhow::anyhow!("zstd window_log_max: {}", e))?;
-        Box::new(dec)
-    };
-
-    std::fs::create_dir_all(out_dir)
-        .map_err(|e| anyhow::anyhow!("Cannot create output directory {:?}: {}", out_dir, e))?;
-    packer::unpack_stream_to_dir(&mut reader, out_dir, files_slice, progress, 0)
-        .map_err(|e| anyhow::anyhow!(e))
-}
-
-fn write_all(path: &PathBuf, data: &[u8]) -> anyhow::Result<()> {
-    let f = File::create(path)?;
-    let budget_bytes = ram_budget_bytes(effective_ram_budget_mb());
-    let dynamic_cap = (budget_bytes / 24)
-        .clamp(MIN_WRITE_BUFFER_BYTES as u64, MAX_WRITE_BUFFER_BYTES as u64) as usize;
-    let buf_size = dynamic_cap.min(data.len().max(8192));
-    let mut writer = std::io::BufWriter::with_capacity(buf_size, f);
-    writer.write_all(data)?;
-    writer.flush()?;
-    Ok(())
-}
-
-fn parse_markers(v: &[String]) -> Option<Vec<u8>> {
-    if v.is_empty() {
-        return None;
-    }
-    let mut out = Vec::new();
-    for s in v {
-        let parts: Vec<&str> = s.split(|c| c == ':' || c == ',' ).collect();
-        if parts.len() >= 3 {
-            if let (Ok(r), Ok(g), Ok(b)) = (parts[0].parse::<u8>(), parts[1].parse::<u8>(), parts[2].parse::<u8>()) {
-                out.push(r); out.push(g); out.push(b);
-            }
-        }
-    }
-    if out.is_empty() { None } else { Some(out) }
-}
-
-fn main() -> anyhow::Result<()> {
-    let cli = Cli::parse();
-
-fn parse_requested_files(files: &str) -> anyhow::Result<Vec<String>> {
-    if files.trim_start().starts_with('[') {
-        serde_json::from_str::<Vec<String>>(files)
-            .map_err(|e| anyhow::anyhow!("Invalid JSON for --files: {}", e))
-    } else {
-        Ok(files
-            .split(',')
-            .map(|file| file.trim().to_string())
-            .filter(|file| !file.is_empty())
-            .collect())
-    }
-}
-    match cli.command {
-        Commands::TrainDict { samples, size, output } => {
-            let dict = core::train_zstd_dictionary(&samples, size)?;
-            write_all(&output, &dict)?;
-            println!("wrote {} bytes dictionary to {:?}", dict.len(), output);
-            return Ok(());
-        }
-        Commands::Encode { input, output, level, passphrase, encrypt, name, dict, ram_budget_mb } => {
-            let ram_budget_mb = resolve_ram_budget_mb(ram_budget_mb);
-            std::env::set_var("ROX_RAM_BUDGET_MB_EFFECTIVE", ram_budget_mb.to_string());
-            let is_dir = input.is_dir();
-
-            let file_name = name.as_deref()
-                .or_else(|| input.file_name().and_then(|n| n.to_str()));
-
-            if is_dir && dict.is_none() {
-                streaming_encode::encode_dir_to_png_encrypted_with_progress(
-                    &input,
-                    &output,
-                    level,
-                    file_name,
-                    passphrase.as_deref(),
-                    Some(&encrypt),
-                    Some(Box::new(|current, total, step| {
-                        eprintln!("PROGRESS:{}:{}:{}", current, total, step);
-                    })),
-                )?;
-                println!("(directory payload, rXFL chunk embedded)");
-                return Ok(());
-            }
-
-            let (payload, file_list_json) = if is_dir {
-                let result = archive::tar_pack_directory_with_list(&input)
-                    .map_err(|e| anyhow::anyhow!(e))?;
-                let json_list: Vec<serde_json::Value> = result.file_list.iter()
-                    .map(|(name, size)| serde_json::json!({"name": name, "size": size}))
-                    .collect();
-                (result.data, Some(serde_json::to_string(&json_list)?))
-            } else {
-                let pack_result = packer::pack_path_with_metadata(&input)?;
-                (pack_result.data, pack_result.file_list_json)
-            };
-
-            let dict_bytes: Option<Vec<u8>> = match dict {
-                Some(path) => Some(read_all(&path)?),
-                None => None,
-            };
-
-            let use_streaming = (payload.len() as u64) > streaming_preference_threshold_bytes(ram_budget_mb);
-            eprintln!("PROGRESS:50:100:encoding");
-
-            if use_streaming {
-                streaming::encode_to_png_file(
-                    &payload,
-                    &output,
-                    level,
-                    passphrase.as_deref(),
-                    Some(&encrypt),
-                    file_name,
-                    file_list_json.as_deref(),
-                    dict_bytes.as_deref(),
-                )?;
-            } else {
-                let png = if let Some(ref pass) = passphrase {
-                    encoder::encode_to_png_with_encryption_name_and_format_and_filelist(
-                        &payload,
-                        level,
-                        Some(pass),
-                        Some(&encrypt),
-                        ImageFormat::Png,
-                        file_name,
-                        file_list_json.as_deref(),
-                        dict_bytes.as_deref(),
-                    )?
-                } else {
-                    encoder::encode_to_png_with_encryption_name_and_format_and_filelist(
-                        &payload,
-                        level,
-                        None,
-                        None,
-                        ImageFormat::Png,
-                        file_name,
-                        file_list_json.as_deref(),
-                        dict_bytes.as_deref(),
-                    )?
-                };
-                write_all(&output, &png)?;
-            }
-
-            if file_list_json.is_some() {
-                eprintln!("PROGRESS:100:100:done");
-                if is_dir {
-                    println!("(directory payload, rXFL chunk embedded)");
-                } else {
-                    println!("(rXFL chunk embedded)");
-                }
-            }
-        }
-        Commands::List { input } => {
-            let mut file = File::open(&input)?;
-            let mut chunk_scan_error: Option<anyhow::Error> = None;
-
-            match png_utils::extract_png_chunks_streaming(&mut file) {
-                Ok(chunks) => {
-                    if let Some(rxfl_chunk) = chunks.iter().find(|c| c.name == "rXFL") {
-                        println!("{}", String::from_utf8_lossy(&rxfl_chunk.data));
-                        return Ok(());
-                    }
-
-                    if let Some(meta_chunk) = chunks.iter().find(|c| c.name == "rOXm") {
-                        if let Some(pos) = meta_chunk.data.windows(4).position(|w| w == b"rXFL") {
-                            if pos + 8 <= meta_chunk.data.len() {
-                                let json_len = u32::from_be_bytes([
-                                    meta_chunk.data[pos + 4],
-                                    meta_chunk.data[pos + 5],
-                                    meta_chunk.data[pos + 6],
-                                    meta_chunk.data[pos + 7],
-                                ]) as usize;
-
-                                let json_start = pos + 8;
-                                let json_end = json_start + json_len;
-
-                                if json_end <= meta_chunk.data.len() {
-                                    println!("{}", String::from_utf8_lossy(&meta_chunk.data[json_start..json_end]));
-                                    return Ok(());
-                                }
-                            }
-                        }
-                    }
-                }
-                Err(err) => {
-                    chunk_scan_error = Some(anyhow::anyhow!(err));
-                }
-            }
-
-            let png_data = std::fs::read(&input)?;
-            match png_utils::extract_file_list_from_pixels(&png_data) {
-                Ok(json) => {
-                    println!("{}", json);
-                    return Ok(());
-                }
-                Err(pixel_err) => {
-                    if let Some(chunk_err) = chunk_scan_error {
-                        return Err(anyhow::anyhow!("chunk scan: {}; pixel scan: {}", chunk_err, pixel_err));
-                    }
-                }
-            }
-
-            return Err(anyhow::anyhow!("No file list found in PNG"));
-        }
-        Commands::Havepassphrase { input } => {
-            let buf = read_all(&input)?;
-            let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
-            if is_png {
-                let payload = png_utils::extract_payload_from_png(&buf).map_err(|e| anyhow::anyhow!(e))?;
-                if !payload.is_empty() && (payload[0] == 0x01 || payload[0] == 0x02 || payload[0] == 0x03) {
-                    println!("Passphrase detected.");
-                } else {
-                    println!("No passphrase detected.");
-                }
-            } else {
-                if !buf.is_empty() && (buf[0] == 0x01 || buf[0] == 0x02 || buf[0] == 0x03) {
-                    println!("Passphrase detected.");
-                } else {
-                    println!("No passphrase detected.");
-                }
-            }
-        }
-        Commands::Scan { input, channels, markers } => {
-            let buf = read_all(&input)?;
-            let marker_bytes = parse_markers(&markers);
-            let res = crate::core::scan_pixels_bytes(&buf, channels, marker_bytes.as_deref());
-            println!("magic_positions: {:?}", res.magic_positions);
-            println!("marker_positions: {:?}", res.marker_positions);
-        }
-        Commands::DeltaEncode { input, output } => {
-            let buf = read_all(&input)?;
-            let out = crate::core::delta_encode_bytes(&buf);
-            let dest = output.unwrap_or_else(|| PathBuf::from("delta.bin"));
-            write_all(&dest, &out)?;
-        }
-        Commands::DeltaDecode { input, output } => {
-            let buf = read_all(&input)?;
-            let out = crate::core::delta_decode_bytes(&buf);
-            let dest = output.unwrap_or_else(|| PathBuf::from("raw.bin"));
-            write_all(&dest, &out)?;
-        }
-        Commands::Compress { input, output, level, dict } => {
-            let buf = read_all(&input)?;
-            let dict_bytes: Option<Vec<u8>> = match dict {
-                Some(path) => Some(read_all(&path)?),
-                None => None,
-            };
-            let out = crate::core::zstd_compress_bytes(
-                &buf,
-                level,
-                dict_bytes.as_deref(),
-            )
-            .map_err(|e: String| anyhow::anyhow!(e))?;
-            let dest = output.unwrap_or_else(|| PathBuf::from("out.zst"));
-            write_all(&dest, &out)?;
-        }
-        Commands::Decompress { input, output, files, passphrase, dict, ram_budget_mb } => {
-            let ram_budget_mb = resolve_ram_budget_mb(ram_budget_mb);
-            std::env::set_var("ROX_RAM_BUDGET_MB_EFFECTIVE", ram_budget_mb.to_string());
-            let file_size = std::fs::metadata(&input).map(|m| m.len()).unwrap_or(0);
-            let is_png_file = input.extension().map(|e| e == "png").unwrap_or(false)
-                || (file_size >= 8 && {
-                    let mut sig = [0u8; 8];
-                    std::fs::File::open(&input).and_then(|mut f| { use std::io::Read; f.read_exact(&mut sig) }).is_ok()
-                        && sig == [137, 80, 78, 71, 13, 10, 26, 10]
-                });
-
-            let requested_files = match files.as_deref() {
-                Some(files_str) => Some(parse_requested_files(files_str)?),
-                None => None,
-            };
-
-            if is_png_file && dict.is_none() {
-                let out_dir = if requested_files.is_some() {
-                    output.clone().unwrap_or_else(|| PathBuf::from("."))
-                } else {
-                    output.clone().unwrap_or_else(|| PathBuf::from("out.raw"))
-                };
-
-                let should_try_streaming = file_size >= streaming_preference_threshold_bytes(ram_budget_mb);
-
-                if should_try_streaming {
-                    let streaming_result = if let Some(ref selected) = requested_files {
-                        streaming_decode::streaming_decode_selected_to_dir_encrypted_with_progress(
-                            &input,
-                            &out_dir,
-                            Some(selected.as_slice()),
-                            passphrase.as_deref(),
-                            Some(Box::new(|current, total, step| {
-                                eprintln!("PROGRESS:{}:{}:{}", current, total, step);
-                            })),
-                        )
-                    } else {
-                        streaming_decode::streaming_decode_to_dir_encrypted_with_progress(
-                            &input,
-                            &out_dir,
-                            passphrase.as_deref(),
-                            Some(Box::new(|current, total, step| {
-                                eprintln!("PROGRESS:{}:{}:{}", current, total, step);
-                            })),
-                        )
-                    };
-
-                    match streaming_result {
-                        Ok(written) => {
-                            eprintln!("PROGRESS:100:100:done");
-                            println!("Unpacked {} files", written.len());
-                            return Ok(());
-                        }
-                        Err(e) => {
-                            eprintln!("PROGRESS:12:100:streaming_fallback");
-                            eprintln!("Streaming decode failed, falling back to reconstruction: {}", e);
-                        }
-                    }
-                }
-
-                if file_size > ram_budget_bytes(ram_budget_mb) {
-                    return Err(anyhow::anyhow!(
-                        "PNG fallback requires in-memory reconstruction ({} MB file > {} MB RAM budget). Increase --ram-budget-mb.",
-                        file_size / MB_U64,
-                        ram_budget_mb
-                    ));
-                }
-
-                let buf = read_all(&input)?;
-
-                eprintln!("PROGRESS:20:100:decompressing");
-                let progress_cb = |current: u64, total: u64, step: &str| {
-                    eprintln!("PROGRESS:{}:{}:{}", current, total, step);
-                };
-
-                let normalized = normalize_png_archive_bytes(&buf, passphrase.as_deref())?;
-                let written = unpack_archive_bytes(
-                    normalized,
-                    &out_dir,
-                    requested_files.as_deref(),
-                    Some(&progress_cb),
-                )?;
-                eprintln!("PROGRESS:100:100:done");
-                println!("Unpacked {} files", written.len());
-                return Ok(());
-            }
-
-            if file_size > ram_budget_bytes(ram_budget_mb) {
-                return Err(anyhow::anyhow!(
-                    "Input is {} MB but RAM budget is {} MB. Increase --ram-budget-mb for non-streaming decode paths.",
-                    file_size / MB_U64,
-                    ram_budget_mb
-                ));
-            }
-
-            let buf = read_all(&input)?;
-
-            eprintln!("PROGRESS:20:100:decompressing");
-            let dict_bytes: Option<Vec<u8>> = match dict {
-                Some(path) => Some(read_all(&path)?),
-                None => None,
-            };
-                        if requested_files.is_some() {
-                                let file_list = requested_files;
-
-                                let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
-
-                                use std::io::Cursor;
-                let normalized: Vec<u8> = if is_png {
-                    let payload = png_utils::extract_payload_from_png(&buf).map_err(|e| anyhow::anyhow!(e))?;
-                    if payload.is_empty() { return Err(anyhow::anyhow!("Empty payload")); }
-                    if payload[0] == 0x00u8 {
-                        payload[1..].to_vec()
-                    } else {
-                                                let pass = passphrase.as_ref().map(|s: &String| s.as_str());
-                        match crate::crypto::try_decrypt(&payload, pass) {
-                            Ok(v) => v,
-                            Err(e) => return Err(anyhow::anyhow!("Encrypted payload: {}", e)),
-                        }
-                    }
-                } else {
-                                        if buf[0] == 0x00u8 {
-                        buf[1..].to_vec()
-                    } else if buf.starts_with(b"ROX1") {
-                        buf[4..].to_vec()
-                    } else if buf[0] == 0x01u8 || buf[0] == 0x02u8 || buf[0] == 0x03u8 {
-                        let pass = passphrase.as_ref().map(|s: &String| s.as_str());
-                        match crate::crypto::try_decrypt(&buf, pass) {
-                            Ok(v) => v,
-                            Err(e) => return Err(anyhow::anyhow!("Encrypted payload: {}", e)),
-                        }
-                    } else {
-                                                buf.to_vec()
-                    }
-                };
-
-                                                let mut reader: Box<dyn std::io::Read> = if normalized.starts_with(b"ROX1") {
-                    Box::new(Cursor::new(normalized[4..].to_vec()))
-                } else {
-                    let mut dec = zstd::stream::Decoder::new(Cursor::new(normalized)).map_err(|e| anyhow::anyhow!("zstd decoder init: {}", e))?;
-                    dec.window_log_max(31).map_err(|e| anyhow::anyhow!("zstd window_log_max: {}", e))?;
-                    Box::new(dec)
-                };
-
-                let out_dir = output.unwrap_or_else(|| PathBuf::from("."));
-                std::fs::create_dir_all(&out_dir).map_err(|e| anyhow::anyhow!("Cannot create output directory {:?}: {}", out_dir, e))?;
-                let files_slice = file_list.as_ref().map(|v| v.as_slice());
-
-                                let written = packer::unpack_stream_to_dir(&mut reader, &out_dir, files_slice, Some(&|current, total, step| {
-                                    eprintln!("PROGRESS:{}:{}:{}", current, total, step);
-                                }), 0).map_err(|e| anyhow::anyhow!(e))?;
-                eprintln!("PROGRESS:100:100:done");
-                println!("Unpacked {} files", written.len());
-            } else {
-                                                let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
-                let out_bytes = if is_png {
-                    let payload = png_utils::extract_payload_from_png(&buf).map_err(|e| anyhow::anyhow!(e))?;
-                    if payload.is_empty() { return Err(anyhow::anyhow!("Empty payload")); }
-                    let first = payload[0];
-                    if first == 0x00u8 {
-                        let compressed = payload[1..].to_vec();
-                        match crate::core::zstd_decompress_bytes(&compressed, dict_bytes.as_deref()) {
-                            Ok(mut o) => {
-                                if o.starts_with(b"ROX1") { o = o[4..].to_vec(); }
-                                o
-                            }
-                            Err(e) => {
-                                if compressed.starts_with(b"ROX1") {
-                                    eprintln!("⚠️ zstd decompress failed ({}), but payload starts with ROX1: falling back to raw pack", e);
-                                    compressed[4..].to_vec()
-                                } else {
-                                    return Err(anyhow::anyhow!("zstd decompress error: {}", e));
-                                }
-                            }
-                        }
-                    } else {
-                        let pass = passphrase.as_ref().map(|s| s.as_str());
-                        match crate::crypto::try_decrypt(&payload, pass) {
-                            Ok(v) => {
-                                let inner = if v.starts_with(b"ROX1") {
-                                    v[4..].to_vec()
-                                } else {
-                                    v
-                                };
-                                match crate::core::zstd_decompress_bytes(&inner, dict_bytes.as_deref()) {
-                                    Ok(mut o) => {
-                                        if o.starts_with(b"ROX1") { o = o[4..].to_vec(); }
-                                        o
-                                    }
-                                    Err(_) => inner,
-                                }
-                            }
-                            Err(e) => return Err(anyhow::anyhow!("Encrypted payload: {}", e)),
-                        }
-                    }
-                } else {
-                    match crate::core::zstd_decompress_bytes(&buf, dict_bytes.as_deref()) {
-                        Ok(mut x) => { if x.starts_with(b"ROX1") { x = x[4..].to_vec(); } x },
-                        Err(e) => {
-                            if buf.starts_with(b"ROX1") {
-                                eprintln!("⚠️ zstd decompress failed ({}), but input already starts with ROX1: using raw pack", e);
-                                buf[4..].to_vec()
-                            } else {
-                                return Err(anyhow::anyhow!("zstd decompress error: {}", e));
-                            }
-                        }
-                    }
-                };
-
-                let dest = output.unwrap_or_else(|| PathBuf::from("out.raw"));
-
-                if archive::is_tar(&out_bytes) {
-                    let out_dir = if dest.extension().is_none() || dest.is_dir() {
-                        dest
-                    } else {
-                        PathBuf::from(".")
-                    };
-                    std::fs::create_dir_all(&out_dir)
-                        .map_err(|e| anyhow::anyhow!("mkdir {:?}: {}", out_dir, e))?;
-                    let written = archive::tar_unpack(&out_bytes, &out_dir)
-                        .map_err(|e| anyhow::anyhow!(e))?;
-                    println!("Unpacked {} files to {:?}", written.len(), out_dir);
-                } else if out_bytes.len() >= 4
-                    && (u32::from_be_bytes(out_bytes[0..4].try_into().unwrap()) == 0x524f5850u32
-                        || u32::from_be_bytes(out_bytes[0..4].try_into().unwrap()) == 0x524f5849u32)
-                {
-                    let out_dir = if dest.extension().is_none() || dest.is_dir() {
-                        dest
-                    } else {
-                        PathBuf::from(".")
-                    };
-                    std::fs::create_dir_all(&out_dir)
-                        .map_err(|e| anyhow::anyhow!("mkdir {:?}: {}", out_dir, e))?;
-                    let written = packer::unpack_buffer_to_dir(&out_bytes, &out_dir, None)
-                        .map_err(|e| anyhow::anyhow!(e))?;
-                    println!("Unpacked {} files to {:?}", written.len(), out_dir);
-                } else if dest.is_dir() {
-                    let fname = if is_png {
-                        png_utils::extract_name_from_png(&buf)
-                    } else {
-                        None
-                    }.unwrap_or_else(|| {
-                        input.file_stem()
-                            .map(|s| s.to_string_lossy().to_string())
-                            .unwrap_or_else(|| "out.raw".to_string())
-                    });
-                    write_all(&dest.join(&fname), &out_bytes)?;
-                } else {
-                    write_all(&dest, &out_bytes)?;
-                }
-                eprintln!("PROGRESS:100:100:done");
-            }
-        }
-        Commands::Crc32 { input } => {
-            let buf = read_all(&input)?;
-            println!("crc32: {}", crate::core::crc32_bytes(&buf));
-        }
-        Commands::Adler32 { input } => {
-            let buf = read_all(&input)?;
-            println!("adler32: {}", crate::core::adler32_bytes(&buf));
-        }
-    }
-    Ok(())
-}
-