roxify 1.11.1 → 1.12.1

package/native/bwt.rs

@@ -1,56 +0,0 @@
-use anyhow::Result;
-use libsais::bwt::Bwt;
-use libsais::typestate::OwnedBuffer;
-use libsais::BwtConstruction;
-use rayon::prelude::*;
-
-pub struct BwtResult {
-    pub transformed: Vec<u8>,
-    pub primary_index: u32,
-}
-
-pub fn bwt_encode(data: &[u8]) -> Result<BwtResult> {
-    let n = data.len();
-    if n == 0 {
-        return Ok(BwtResult { transformed: Vec::new(), primary_index: 0 });
-    }
-
-    let bwt_result = BwtConstruction::for_text(data)
-        .with_owned_temporary_array_buffer32()
-        .single_threaded()
-        .run()
-        .map_err(|e| anyhow::anyhow!("libsais BWT: {:?}", e))?;
-
-    let primary_index = bwt_result.primary_index() as u32;
-    let transformed = bwt_result.bwt().to_vec();
-
-    Ok(BwtResult { transformed, primary_index })
-}
-
-pub fn bwt_decode(bwt_data: &[u8], primary_index: u32) -> Result<Vec<u8>> {
-    if bwt_data.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    let bwt_obj: Bwt<'static, u8, OwnedBuffer> =
-        unsafe { Bwt::from_parts(bwt_data.to_vec(), primary_index as usize) };
-
-    let text = bwt_obj
-        .unbwt()
-        .with_owned_temporary_array_buffer32()
-        .single_threaded()
-        .run()
-        .map_err(|e| anyhow::anyhow!("libsais UnBWT: {:?}", e))?;
-
-    Ok(text.as_slice().to_vec())
-}
-
-pub fn bwt_encode_streaming(block_size: usize, data: &[u8]) -> Result<Vec<(BwtResult, usize)>> {
-    data.par_chunks(block_size)
-        .enumerate()
-        .map(|(i, chunk)| {
-            let result = bwt_encode(chunk)?;
-            Ok((result, i * block_size))
-        })
-        .collect()
-}

package/native/context_mixing.rs

@@ -1,117 +0,0 @@
-#[derive(Clone, Copy, Debug)]
-pub struct ProbabilityEstimate {
-    pub p0: u32,
-    pub p1: u32,
-    pub total: u32,
-}
-
-impl ProbabilityEstimate {
-    pub fn entropy_bits(&self) -> f32 {
-        if self.total == 0 {
-            return 0.0;
-        }
-        let p0 = (self.p0 as f32) / (self.total as f32);
-        let p1 = (self.p1 as f32) / (self.total as f32);
-
-        let mut bits = 0.0;
-        if p0 > 0.0 {
-            bits -= p0 * p0.log2();
-        }
-        if p1 > 0.0 {
-            bits -= p1 * p1.log2();
-        }
-        bits
-    }
-}
-
-pub struct ContextMixer {
-    contexts_order0: Vec<ProbabilityEstimate>,
-    contexts_order1: Vec<[ProbabilityEstimate; 256]>,
-    contexts_order2: Vec<[[ProbabilityEstimate; 256]; 256]>,
-}
-
-impl ContextMixer {
-    pub fn new() -> Self {
-        ContextMixer {
-            contexts_order0: vec![ProbabilityEstimate { p0: 1, p1: 1, total: 2 }; 1],
-            contexts_order1: vec![
-                [ProbabilityEstimate { p0: 1, p1: 1, total: 2 }; 256];
-                256
-            ],
-            contexts_order2: vec![
-                [[ProbabilityEstimate { p0: 1, p1: 1, total: 2 }; 256]; 256];
-                256
-            ],
-        }
-    }
-
-    pub fn predict_order0(&self) -> ProbabilityEstimate {
-        self.contexts_order0[0]
-    }
-
-    pub fn predict_order1(&self, context1: u8) -> ProbabilityEstimate {
-        self.contexts_order1[context1 as usize][0]
-    }
-
-    pub fn predict_order2(&self, context1: u8, context2: u8) -> ProbabilityEstimate {
-        self.contexts_order2[context1 as usize][context2 as usize][0]
-    }
-
-    pub fn update_order0(&mut self, bit: bool) {
-        let ctx = &mut self.contexts_order0[0];
-        if bit {
-            ctx.p1 += 1;
-        } else {
-            ctx.p0 += 1;
-        }
-        ctx.total += 1;
-    }
-
-    pub fn update_order1(&mut self, context1: u8, bit: bool) {
-        let ctx = &mut self.contexts_order1[context1 as usize][0];
-        if bit {
-            ctx.p1 += 1;
-        } else {
-            ctx.p0 += 1;
-        }
-        ctx.total += 1;
-    }
-
-    pub fn update_order2(&mut self, context1: u8, context2: u8, bit: bool) {
-        let ctx = &mut self.contexts_order2[context1 as usize][context2 as usize][0];
-        if bit {
-            ctx.p1 += 1;
-        } else {
-            ctx.p0 += 1;
-        }
-        ctx.total += 1;
-    }
-}
-
-pub fn analyze_entropy(data: &[u8]) -> f32 {
-    let mut freq = [0u32; 256];
-    for &byte in data {
-        freq[byte as usize] += 1;
-    }
-
-    let total = data.len() as f32;
-    if total == 0.0 {
-        return 0.0;
-    }
-
-    let inv_total = 1.0 / total;
-    let mut entropy = 0.0f32;
-    for &f in &freq {
-        if f > 0 {
-            let p = f as f32 * inv_total;
-            entropy -= p * p.log2();
-        }
-    }
-    entropy
-}
-
-pub fn estimate_compression_gain(original: &[u8], entropy_bits: f32) -> f64 {
-    let theoretical_min = (original.len() as f64) * (entropy_bits as f64) / 8.0;
-    let ratio = theoretical_min / (original.len() as f64);
-    (1.0 - ratio) * 100.0
-}

package/native/core.rs

@@ -1,382 +0,0 @@
-use rayon::prelude::*;
-use std::sync::Arc;
-use std::path::PathBuf;
-use anyhow::Result;
-
-pub struct PlainScanResult {
-    pub marker_positions: Vec<u32>,
-    pub magic_positions: Vec<u32>,
-}
-
-pub fn scan_pixels_bytes(buf: &[u8], channels: usize, marker_bytes: Option<&[u8]>) -> PlainScanResult {
-    let magic = b"ROX1";
-
-    let magic_positions: Vec<u32> = if buf.len() >= 4 {
-        (0..(buf.len() - 3))
-            .into_par_iter()
-            .filter_map(|i| if &buf[i..i + 4] == magic { Some(i as u32) } else { None })
-            .collect()
-    } else {
-        Vec::new()
-    };
-
-    let markers: Vec<[u8; 3]> = match marker_bytes {
-        Some(bytes) if !bytes.is_empty() => {
-            if bytes.len() % 3 != 0 {
-                return PlainScanResult { marker_positions: Vec::new(), magic_positions };
-            }
-            bytes.chunks(3).map(|c| [c[0], c[1], c[2]]).collect()
-        }
-        _ => Vec::new(),
-    };
-
-    let marker_positions = if markers.is_empty() {
-        Vec::new()
-    } else {
-        let markers = Arc::new(markers);
-        let ch = channels as usize;
-        if ch < 3 || buf.len() < 3 {
-            Vec::new()
-        } else {
-            let pixel_count = buf.len() / ch;
-            (0..pixel_count)
-                .into_par_iter()
-                .filter_map(|i| {
-                    let base = i * ch;
-                    if base + 3 > buf.len() {
-                        return None;
-                    }
-                    for m in markers.iter() {
-                        if buf[base] == m[0] && buf[base + 1] == m[1] && buf[base + 2] == m[2] {
-                            return Some(i as u32);
-                        }
-                    }
-                    None
-                })
-                .collect()
-        }
-    };
-
-    PlainScanResult { marker_positions, magic_positions }
-}
-
-pub fn crc32_bytes(buf: &[u8]) -> u32 {
-    // parallelize checksum on large buffers, since crc32fast::hash is single-threaded
-    const PAR_THRESHOLD: usize = 4 * 1024 * 1024; // 4 MiB
-    if buf.len() < PAR_THRESHOLD {
-        crc32fast::hash(buf)
-    } else {
-        // compute per-chunk hasher in parallel then combine
-        let chunk = PAR_THRESHOLD;
-        let combined = buf
-            .par_chunks(chunk)
-            .map(|chunk| {
-                let mut h = crc32fast::Hasher::new();
-                h.update(chunk);
-                h
-            })
-            .reduce(|| crc32fast::Hasher::new(), |mut a, b| {
-                a.combine(&b);
-                a
-            });
-        combined.finalize()
-    }
-}
-
-pub fn adler32_bytes(buf: &[u8]) -> u32 {
-    const MOD: u32 = 65521;
-    const NMAX: usize = 5552;
-
-    if buf.len() > 4 * 1024 * 1024 {
-        return adler32_parallel(buf);
-    }
-
-    let mut a: u32 = 1;
-    let mut b: u32 = 0;
-
-    for chunk in buf.chunks(NMAX) {
-        for &v in chunk {
-            a += v as u32;
-            b += a;
-        }
-        a %= MOD;
-        b %= MOD;
-    }
-
-    (b << 16) | a
-}
-
-fn adler32_parallel(buf: &[u8]) -> u32 {
-    use rayon::prelude::*;
-    const MOD: u32 = 65521;
-    const CHUNK: usize = 1024 * 1024;
-
-    let chunks: Vec<&[u8]> = buf.chunks(CHUNK).collect();
-    let partials: Vec<(u32, u32, usize)> = chunks.par_iter().map(|chunk| {
-        let mut a: u32 = 0;
-        let mut b: u32 = 0;
-        for &v in *chunk {
-            a += v as u32;
-            b += a;
-        }
-        a %= MOD;
-        b %= MOD;
-        (a, b, chunk.len())
-    }).collect();
-
-    let mut a: u64 = 1;
-    let mut b: u64 = 0;
-    for (pa, pb, len) in partials {
-        b = (b + pb as u64 + a * len as u64) % MOD as u64;
-        a = (a + pa as u64) % MOD as u64;
-    }
-
-    ((b as u32) << 16) | (a as u32)
-}
-
-pub fn delta_encode_bytes(buf: &[u8]) -> Vec<u8> {
-    let len = buf.len();
-    if len == 0 {
-        return Vec::new();
-    }
-    let mut out = vec![0u8; len];
-    out[0] = buf[0];
-    for i in 1..len {
-        out[i] = buf[i].wrapping_sub(buf[i - 1]);
-    }
-    out
-}
-
-pub fn delta_decode_bytes(buf: &[u8]) -> Vec<u8> {
-    let len = buf.len();
-    if len == 0 {
-        return Vec::new();
-    }
-    let mut out = vec![0u8; len];
-    out[0] = buf[0];
-    for i in 1..len {
-        out[i] = out[i - 1].wrapping_add(buf[i]);
-    }
-    out
-}
-
-fn compress_with_chunk_size(buf: &[u8], level: i32, chunk_size: usize) -> std::result::Result<Vec<u8>, String> {
-    use std::io::Write;
-
-    // Allow ultra levels (20-22) for maximum compression
-    let actual_level = level.min(22).max(1);
-    let mut encoder = zstd::stream::Encoder::new(Vec::new(), actual_level)
-        .map_err(|e| format!("zstd encoder init error: {}", e))?;
-
-    let threads = num_cpus::get() as u32;
-    if threads > 1 {
-        // Ultra levels (>=20) use much more memory per thread; limit to 4
-        let max_threads = if actual_level >= 20 { threads.min(4) } else { threads };
-        let _ = encoder.multithread(max_threads);
-    }
-
-    if buf.len() > 1024 * 1024 {
-        let _ = encoder.long_distance_matching(true);
-        let wlog = if buf.len() > 512 * 1024 * 1024 { 28 }
-            else if buf.len() > 64 * 1024 * 1024 { 27 }
-            else { 26 };
-        let _ = encoder.window_log(wlog);
-    }
-
-    let _ = encoder.set_pledged_src_size(Some(buf.len() as u64));
-
-    for chunk in buf.chunks(chunk_size) {
-        encoder.write_all(chunk).map_err(|e| format!("zstd write error: {}", e))?;
-    }
-
-    encoder.finish().map_err(|e| format!("zstd finish error: {}", e))
-}
-
-pub fn train_zstd_dictionary(sample_paths: &[PathBuf], dict_size: usize) -> Result<Vec<u8>> {
-    // load all sample files contiguously
-    let mut samples = Vec::new();
-    let mut lengths = Vec::new();
-    for path in sample_paths {
-        let data = std::fs::read(path)?;
-        lengths.push(data.len());
-        samples.extend_from_slice(&data);
-    }
-    let dict = zstd::dict::from_continuous(&samples, &lengths, dict_size)?;
-    Ok(dict)
-}
-
-/// Compress a slice with optional zstd dictionary.
-///
-/// When `dict` is `Some`, the dictionary is passed to the encoder (same
-/// dict required for decompression).  Pass `None` for normal compression.
-///
-/// For large buffers (>50 MiB) without a dictionary, multiple chunk sizes
-/// are benchmarked on a sample and the best is selected automatically.
-pub fn zstd_compress_bytes(buf: &[u8], level: i32, dict: Option<&[u8]>) -> std::result::Result<Vec<u8>, String> {
-    zstd_compress_with_prefix(buf, level, dict, &[])
-}
-
-pub fn zstd_compress_with_prefix(buf: &[u8], level: i32, dict: Option<&[u8]>, prefix: &[u8]) -> std::result::Result<Vec<u8>, String> {
-    use std::io::Write;
-
-    let actual_level = level.min(22).max(1);
-    let total_len = prefix.len() + buf.len();
-
-    let adaptive_level = if total_len > 2 * 1024 * 1024 * 1024 {
-        actual_level.min(1)
-    } else if total_len > 1024 * 1024 * 1024 {
-        actual_level.min(3)
-    } else if total_len > 256 * 1024 * 1024 {
-        actual_level.min(6)
-    } else if total_len > 64 * 1024 * 1024 {
-        actual_level.min(12)
-    } else {
-        actual_level
-    };
-
-    if dict.is_none() && total_len < 4 * 1024 * 1024 {
-        if prefix.is_empty() {
-            return zstd::bulk::compress(buf, adaptive_level)
-                .map_err(|e| format!("zstd bulk compress error: {}", e));
-        }
-        let mut combined = Vec::with_capacity(total_len);
-        combined.extend_from_slice(prefix);
-        combined.extend_from_slice(buf);
-        return zstd::bulk::compress(&combined, adaptive_level)
-            .map_err(|e| format!("zstd bulk compress error: {}", e));
-    }
-
-    let mut encoder = if let Some(d) = dict {
-        zstd::stream::Encoder::with_dictionary(Vec::with_capacity(total_len / 2), adaptive_level, d)
-            .map_err(|e| format!("zstd encoder init error: {}", e))?
-    } else {
-        zstd::stream::Encoder::new(Vec::with_capacity(total_len / 2), adaptive_level)
-            .map_err(|e| format!("zstd encoder init error: {}", e))?
-    };
-
-    let threads = num_cpus::get() as u32;
-    if threads > 1 {
-        let max_threads = if adaptive_level >= 20 { threads.min(4) } else { threads };
-        let _ = encoder.multithread(max_threads);
-    }
-
-    if total_len > 256 * 1024 && adaptive_level >= 3 {
-        let _ = encoder.long_distance_matching(true);
-    }
-    if total_len > 256 * 1024 {
-        let wlog = if total_len > 1024 * 1024 * 1024 { 30 }
-            else if total_len > 512 * 1024 * 1024 { 29 }
-            else if total_len > 64 * 1024 * 1024 { 28 }
-            else if total_len > 8 * 1024 * 1024 { 27 }
-            else { 26 };
-        let _ = encoder.window_log(wlog);
-    }
-
-    let _ = encoder.set_pledged_src_size(Some(total_len as u64));
-
-    if !prefix.is_empty() {
-        encoder.write_all(prefix).map_err(|e| format!("zstd write prefix error: {}", e))?;
-    }
-
-    let chunk_size = if total_len > 256 * 1024 * 1024 { 16 * 1024 * 1024 }
-        else if total_len > 64 * 1024 * 1024 { 8 * 1024 * 1024 }
-        else { buf.len() };
-
-    for chunk in buf.chunks(chunk_size) {
-        encoder.write_all(chunk).map_err(|e| format!("zstd write error: {}", e))?;
-    }
-
-    encoder.finish().map_err(|e| format!("zstd finish error: {}", e))
-}
-
-pub fn zstd_decompress_bytes(buf: &[u8], dict: Option<&[u8]>) -> std::result::Result<Vec<u8>, String> {
-    use std::io::Read;
-    let mut out = Vec::with_capacity(buf.len() * 2);
-    if let Some(d) = dict {
-        let mut decoder = zstd::stream::Decoder::with_dictionary(std::io::Cursor::new(buf), d)
-            .map_err(|e| format!("zstd decoder init error: {}", e))?;
-        decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max error: {}", e))?;
-        decoder.read_to_end(&mut out).map_err(|e| format!("zstd decompress error: {}", e))?;
-    } else {
-        let mut decoder = zstd::stream::Decoder::new(std::io::Cursor::new(buf))
-            .map_err(|e| format!("zstd decoder init error: {}", e))?;
-        decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max error: {}", e))?;
-        decoder.read_to_end(&mut out).map_err(|e| format!("zstd decompress error: {}", e))?;
-    }
-    Ok(out)
-}
-
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_scan_magic() {
-        let data = b"xxxxROX1yyyyROX1".to_vec();
-        let res = scan_pixels_bytes(&data, 3, None);
-        assert_eq!(res.magic_positions.len(), 2);
-    }
-
-    #[test]
-    fn test_markers() {
-        let pixels = vec![1u8,2,3, 4,5,6, 1,2,3];
-        let markers_vec = vec![1u8,2,3];
-        let res = scan_pixels_bytes(&pixels, 3, Some(&markers_vec));
-        assert_eq!(res.marker_positions, vec![0,2]);
-    }
-
-    #[test]
-    fn test_train_dictionary() {
-        use std::fs::{write, create_dir_all};
-        let td = std::env::temp_dir().join("rox_dict_test");
-        let _ = create_dir_all(&td);
-        let f1 = td.join("a.bin");
-        let f2 = td.join("b.bin");
-        // produce 1 MiB of repeated data per file
-        let big = vec![0xABu8; 1024 * 1024];
-        write(&f1, &big).unwrap();
-        write(&f2, &big).unwrap();
-        // choose dictionary size 16 KiB (far below total sample size ≈2 MiB)
-        match train_zstd_dictionary(&[f1.clone(), f2.clone()], 16 * 1024) {
-            Ok(dict) => {
-                assert!(dict.len() <= 16 * 1024);
-                assert!(!dict.is_empty());
-            }
-            Err(e) => {
-                // dictionary training may fail due to insufficient or unsuitable samples;
-                // ensure error string is nonempty to catch panics
-                assert!(!e.to_string().is_empty());
-            }
-        }
-    }
-
-    #[test]
-    fn test_delta_roundtrip() {
-        let data = vec![10u8, 20, 30, 40, 250];
-        let enc = delta_encode_bytes(&data);
-        let dec = delta_decode_bytes(&enc);
-        assert_eq!(dec, data);
-    }
-
-    #[test]
-    fn test_crc_adler() {
-        let data = b"hello".to_vec();
-        assert_eq!(crc32_bytes(&data), crc32fast::hash(&data));
-        assert_eq!(adler32_bytes(&data), adler32_bytes(&data));
-
-        // also test large buffer triggers parallel branch
-        let big = vec![0xAAu8; 5 * 1024 * 1024];
-        assert_eq!(crc32_bytes(&big), crc32fast::hash(&big));
-    }
-
-    #[test]
-    fn test_zstd_dict_roundtrip() {
-        let data = b"this is some test data that repeats. ".repeat(1000);
-        // simple dictionary containing a substring
-        let dict = b"test data";
-        let compressed = zstd_compress_bytes(&data, 3, Some(dict)).expect("compress");
-        let decompressed = zstd_decompress_bytes(&compressed, Some(dict)).expect("decompress");
-        assert_eq!(decompressed, data);
-    }
-}

package/native/crypto.rs

@@ -1,119 +0,0 @@
-use anyhow::{anyhow, Result};
-use aes_gcm::{
-    aead::{Aead, KeyInit},
-    Aes256Gcm, Nonce,
-};
-use pbkdf2::pbkdf2_hmac;
-use rand::RngCore;
-use sha2::Sha256;
-
-const ENC_NONE: u8 = 0x00;
-const ENC_AES: u8 = 0x01;
-const ENC_XOR: u8 = 0x02;
-const PBKDF2_ITERS: u32 = 600_000;
-
-pub fn encrypt_xor(data: &[u8], passphrase: &str) -> Vec<u8> {
-    let key = passphrase.as_bytes();
-    let mut result = Vec::with_capacity(1 + data.len());
-    result.push(ENC_XOR);
-
-    for (i, &byte) in data.iter().enumerate() {
-        result.push(byte ^ key[i % key.len()]);
-    }
-
-    result
-}
-
-pub fn encrypt_aes(data: &[u8], passphrase: &str) -> Result<Vec<u8>> {
-    let mut salt = [0u8; 16];
-    rand::thread_rng().fill_bytes(&mut salt);
-
-    let mut key = [0u8; 32];
-    pbkdf2_hmac::<Sha256>(passphrase.as_bytes(), &salt, PBKDF2_ITERS, &mut key);
-
-    let cipher = Aes256Gcm::new_from_slice(&key)
-        .map_err(|e| anyhow::anyhow!("Failed to create cipher: {}", e))?;
-
-    let mut iv = [0u8; 12];
-    rand::thread_rng().fill_bytes(&mut iv);
-    let nonce = Nonce::from_slice(&iv);
-
-    let ciphertext = cipher
-        .encrypt(nonce, data)
-        .map_err(|e| anyhow::anyhow!("Encryption failed: {}", e))?;
-
-    let cipher_len = ciphertext.len();
-    if cipher_len < 16 {
-        return Err(anyhow::anyhow!("Ciphertext too short"));
-    }
-
-    let tag = &ciphertext[cipher_len - 16..];
-    let encrypted_data = &ciphertext[..cipher_len - 16];
-
-    let mut result = Vec::with_capacity(1 + 16 + 12 + 16 + encrypted_data.len());
-    result.push(ENC_AES);
-    result.extend_from_slice(&salt);
-    result.extend_from_slice(&iv);
-    result.extend_from_slice(tag);
-    result.extend_from_slice(encrypted_data);
-
-    Ok(result)
-}
-
-pub fn no_encryption(data: &[u8]) -> Vec<u8> {
-    let mut result = Vec::with_capacity(1 + data.len());
-    result.push(ENC_NONE);
-    result.extend_from_slice(data);
-    result
-}
-
-pub fn decrypt_xor(data: &[u8], passphrase: &str) -> Result<Vec<u8>> {
-    if data.is_empty() { return Err(anyhow!("Empty xor payload")); }
-    if passphrase.is_empty() { return Err(anyhow!("Passphrase required")); }
-    let key = passphrase.as_bytes();
-    let mut out = Vec::with_capacity(data.len());
-    for (i, &b) in data.iter().enumerate() {
-        out.push(b ^ key[i % key.len()]);
-    }
-    Ok(out)
-}
-
-pub fn decrypt_aes(data: &[u8], passphrase: &str) -> Result<Vec<u8>> {
-    if data.len() < 1 + 16 + 12 + 16 { return Err(anyhow!("Invalid AES payload length")); }
-    let salt = &data[1..17];
-    let iv = &data[17..29];
-    let tag = &data[29..45];
-    let enc = &data[45..];
-
-    let mut key = [0u8; 32];
-    pbkdf2_hmac::<Sha256>(passphrase.as_bytes(), salt, PBKDF2_ITERS, &mut key);
-
-    let cipher = Aes256Gcm::new_from_slice(&key)
-        .map_err(|e| anyhow!("Failed to create cipher: {}", e))?;
-
-    let mut combined = Vec::with_capacity(enc.len() + tag.len());
-    combined.extend_from_slice(enc);
-    combined.extend_from_slice(tag);
-
-    let nonce = Nonce::from_slice(iv);
-    let decrypted = cipher.decrypt(nonce, combined.as_ref())
-        .map_err(|e| anyhow!("AES decryption failed: {}", e))?;
-    Ok(decrypted)
-}
-
-pub fn try_decrypt(buf: &[u8], passphrase: Option<&str>) -> Result<Vec<u8>> {
-    if buf.is_empty() { return Err(anyhow!("Empty buffer")); }
-    let flag = buf[0];
-    match flag {
-        ENC_NONE => Ok(buf[1..].to_vec()),
-        ENC_XOR => {
-            let pass = passphrase.ok_or_else(|| anyhow!("Passphrase required for XOR decryption"))?;
-            decrypt_xor(&buf[1..], pass)
-        }
-        ENC_AES => {
-            let pass = passphrase.ok_or_else(|| anyhow!("Passphrase required for AES decryption"))?;
-            decrypt_aes(buf, pass)
-        }
-        _ => Err(anyhow!("Unknown encryption flag: {}", flag)),
-    }
-}