roxify 1.9.8 → 1.10.1

package/dist/utils/encoder.js

@@ -93,7 +93,8 @@ export async function encodeBinaryToPng(input, opts = {}) {
     // This must be checked BEFORE TS compression to avoid double-compression.
     if (typeof native.nativeEncodePngWithNameAndFilelist === 'function' &&
         opts.includeFileList &&
-        opts.fileList) {
+        opts.fileList &&
+        opts.compression !== 'bwt-ans') {
         const fileName = opts.name || undefined;
         const inputBuf = Array.isArray(input) ? Buffer.concat(input) : input;
         let sizeMap = null;
@@ -170,15 +171,27 @@ export async function encodeBinaryToPng(input, opts = {}) {
     }
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_start', total: totalLen });
-    let payload = await parallelZstdCompress(payloadInput, compressionLevel, (loaded, total) => {
-        if (opts.onProgress) {
-            opts.onProgress({
-                phase: 'compress_progress',
-                loaded,
-                total,
-            });
-        }
-    }, opts.dict);
+    let payload;
+    if (opts.compression === 'bwt-ans' && native?.hybridCompress) {
+        const flat = Array.isArray(payloadInput) ? Buffer.concat(payloadInput) : payloadInput;
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'compress_progress', loaded: 0, total: 1 });
+        const compressed = Buffer.from(native.hybridCompress(flat));
+        payload = [compressed];
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'compress_progress', loaded: 1, total: 1 });
+    }
+    else {
+        payload = await parallelZstdCompress(payloadInput, compressionLevel, (loaded, total) => {
+            if (opts.onProgress) {
+                opts.onProgress({
+                    phase: 'compress_progress',
+                    loaded,
+                    total,
+                });
+            }
+        }, opts.dict);
+    }
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_done', loaded: payload.length });
     if (Array.isArray(input)) {
@@ -392,7 +405,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
             [...dataWithoutMarkers, Buffer.alloc(padding)]
             : dataWithoutMarkers;
         const markerStartBytes = colorsToBytes(MARKER_START);
-        const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);
+        const compressionMarkerBytes = colorsToBytes(opts.compression === 'bwt-ans' ? COMPRESSION_MARKERS['bwt-ans'] : COMPRESSION_MARKERS.zstd);
         const dataWithMarkers = [
             markerStartBytes,
             compressionMarkerBytes,

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

@@ -15,9 +15,12 @@ else {
     }
 }
 function findRustBinary() {
-    const binNames = process.platform === 'win32'
-        ? ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe']
-        : ['roxify_native', 'roxify-cli', 'roxify_cli'];
+    const platformBins = {
+        win32: ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe'],
+        darwin: ['rox-macos-universal', 'roxify_native-macos-arm64', 'roxify_native-macos-x64', 'roxify_native', 'roxify-cli', 'roxify_cli'],
+        linux: ['roxify_native', 'roxify-cli', 'roxify_cli'],
+    };
+    const binNames = platformBins[process.platform] || platformBins.linux;
     const baseDir = moduleDir;
     for (const name of binNames) {
         const sameDirPath = join(baseDir, name);

package/dist/utils/types.d.ts

@@ -1,7 +1,7 @@
 import { PackedFile } from '../pack.js';
 import type { EccLevel } from './ecc.js';
 export interface EncodeOptions {
-    compression?: 'zstd';
+    compression?: 'zstd' | 'bwt-ans';
     compressionLevel?: number;
     passphrase?: string;
     /** optional dictionary to use for zstd compression */

package/native/bench_hybrid.rs

@@ -0,0 +1,145 @@
+use std::time::Instant;
+
+mod rans_byte;
+mod bwt;
+mod mtf;
+mod context_mixing;
+mod pool;
+mod hybrid;
+
+fn bench_roundtrip(name: &str, data: &[u8]) {
+    let compressor = hybrid::HybridCompressor::new(false, 4);
+
+    let start = Instant::now();
+    let (compressed, stats) = compressor.compress(data).unwrap();
+    let compress_time = start.elapsed();
+
+    let start = Instant::now();
+    let decompressed = compressor.decompress(&compressed).unwrap();
+    let decompress_time = start.elapsed();
+
+    let ratio = (compressed.len() as f64) / (data.len() as f64) * 100.0;
+    let compress_mbps = (data.len() as f64 / 1_048_576.0) / compress_time.as_secs_f64();
+    let decompress_mbps = (data.len() as f64 / 1_048_576.0) / decompress_time.as_secs_f64();
+
+    assert_eq!(decompressed, data, "ROUND-TRIP FAILED for {}", name);
+
+    println!("=== {} ===", name);
+    println!("  Input:       {} bytes", data.len());
+    println!("  Compressed:  {} bytes ({:.1}%)", compressed.len(), ratio);
+    println!("  Reduction:   {:.1}%", 100.0 - ratio);
+    println!("  Compress:    {:.1} ms ({:.1} MB/s)", compress_time.as_secs_f64() * 1000.0, compress_mbps);
+    println!("  Decompress:  {:.1} ms ({:.1} MB/s)", decompress_time.as_secs_f64() * 1000.0, decompress_mbps);
+    println!("  Entropy:     {:.2} bits/byte", stats.entropy_bits);
+    println!();
+}
+
+fn bench_zstd(name: &str, data: &[u8], level: i32) {
+    let start = Instant::now();
+    let compressed = zstd::encode_all(std::io::Cursor::new(data), level).unwrap();
+    let compress_time = start.elapsed();
+
+    let start = Instant::now();
+    let decompressed = zstd::decode_all(std::io::Cursor::new(&compressed)).unwrap();
+    let decompress_time = start.elapsed();
+
+    let ratio = (compressed.len() as f64) / (data.len() as f64) * 100.0;
+    let compress_mbps = (data.len() as f64 / 1_048_576.0) / compress_time.as_secs_f64();
+    let decompress_mbps = (data.len() as f64 / 1_048_576.0) / decompress_time.as_secs_f64();
+
+    assert_eq!(decompressed, data);
+
+    println!("=== Zstd L{} ({}) ===", level, name);
+    println!("  Compressed:  {} bytes ({:.1}%)", compressed.len(), ratio);
+    println!("  Reduction:   {:.1}%", 100.0 - ratio);
+    println!("  Compress:    {:.1} ms ({:.1} MB/s)", compress_time.as_secs_f64() * 1000.0, compress_mbps);
+    println!("  Decompress:  {:.1} ms ({:.1} MB/s)", decompress_time.as_secs_f64() * 1000.0, decompress_mbps);
+    println!();
+}
+
+fn main() {
+    println!("╔══════════════════════════════════════════════════════════╗");
+    println!("║     ROXIFY BWT-ANS COMPRESSION BENCHMARK               ║");
+    println!("╚══════════════════════════════════════════════════════════╝\n");
+
+    let text_1k: Vec<u8> = "Hello World! This is a test of the roxify compression engine. ".repeat(16).into_bytes();
+    bench_roundtrip("Text 1KB", &text_1k);
+    bench_zstd("Text 1KB", &text_1k, 3);
+    bench_zstd("Text 1KB", &text_1k, 19);
+
+    let text_100k: Vec<u8> = "The quick brown fox jumps over the lazy dog. Pack my box with five dozen liquor jugs. ".repeat(1200).into_bytes();
+    bench_roundtrip("Text 100KB", &text_100k);
+    bench_zstd("Text 100KB", &text_100k, 3);
+    bench_zstd("Text 100KB", &text_100k, 19);
+
+    let text_1m: Vec<u8> = {
+        let mut data = Vec::with_capacity(1_048_576);
+        let phrases = [
+            b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".as_slice(),
+            b"Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ".as_slice(),
+            b"Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. ".as_slice(),
+            b"Duis aute irure dolor in reprehenderit in voluptate velit esse. ".as_slice(),
+            b"Excepteur sint occaecat cupidatat non proident, sunt in culpa. ".as_slice(),
+        ];
+        let mut i = 0;
+        while data.len() < 1_048_576 {
+            data.extend_from_slice(phrases[i % phrases.len()]);
+            i += 1;
+        }
+        data.truncate(1_048_576);
+        data
+    };
+    bench_roundtrip("Text 1MB", &text_1m);
+    bench_zstd("Text 1MB", &text_1m, 3);
+    bench_zstd("Text 1MB", &text_1m, 19);
+
+    let json_data: Vec<u8> = {
+        let mut data = String::with_capacity(512_000);
+        data.push('[');
+        for i in 0..5000 {
+            if i > 0 { data.push(','); }
+            data.push_str(&format!(
+                r#"{{"id":{},"name":"user_{}","email":"user{}@example.com","active":{},"score":{:.2},"tags":["tag1","tag2","tag3"]}}"#,
+                i, i, i, i % 2 == 0, (i as f64) * 1.337
+            ));
+        }
+        data.push(']');
+        data.into_bytes()
+    };
+    bench_roundtrip("JSON 500KB", &json_data);
+    bench_zstd("JSON 500KB", &json_data, 3);
+    bench_zstd("JSON 500KB", &json_data, 19);
+
+    let random_data: Vec<u8> = {
+        let mut data = vec![0u8; 100_000];
+        let mut state = 12345u64;
+        for b in data.iter_mut() {
+            state = state.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+            *b = (state >> 33) as u8;
+        }
+        data
+    };
+    bench_roundtrip("Random 100KB", &random_data);
+    bench_zstd("Random 100KB", &random_data, 3);
+
+    let binary_data: Vec<u8> = {
+        let mut data = Vec::with_capacity(256_000);
+        for i in 0..256_000u32 {
+            match i % 7 {
+                0 => data.push(0),
+                1 => data.push(0xFF),
+                2 => data.push((i & 0xFF) as u8),
+                3 => data.push(((i >> 8) & 0xFF) as u8),
+                4 => data.push(b'A' + (i % 26) as u8),
+                5 => data.push(0x20),
+                _ => data.push((i.wrapping_mul(37) & 0xFF) as u8),
+            }
+        }
+        data
+    };
+    bench_roundtrip("Binary 256KB", &binary_data);
+    bench_zstd("Binary 256KB", &binary_data, 3);
+    bench_zstd("Binary 256KB", &binary_data, 19);
+
+    println!("All round-trip tests PASSED!");
+}

package/native/bwt.rs

@@ -1,4 +1,7 @@
 use anyhow::Result;
+use libsais::bwt::Bwt;
+use libsais::typestate::OwnedBuffer;
+use libsais::BwtConstruction;
 use rayon::prelude::*;
 
 pub struct BwtResult {
@@ -7,86 +10,39 @@ pub struct BwtResult {
 }
 
 pub fn bwt_encode(data: &[u8]) -> Result<BwtResult> {
-    if data.is_empty() {
-        return Ok(BwtResult {
-            transformed: Vec::new(),
-            primary_index: 0,
-        });
-    }
-
     let n = data.len();
-    let mut rotations: Vec<usize> = (0..n).collect();
-
-    rotations.par_sort_by(|&a, &b| {
-        for i in 0..n {
-            let ca = data[(a + i) % n];
-            let cb = data[(b + i) % n];
-            if ca != cb {
-                return ca.cmp(&cb);
-            }
-        }
-        std::cmp::Ordering::Equal
-    });
+    if n == 0 {
+        return Ok(BwtResult { transformed: Vec::new(), primary_index: 0 });
+    }
 
-    let mut transformed = Vec::with_capacity(n);
-    let mut primary_index = 0u32;
+    let bwt_result = BwtConstruction::for_text(data)
+        .with_owned_temporary_array_buffer32()
+        .single_threaded()
+        .run()
+        .map_err(|e| anyhow::anyhow!("libsais BWT: {:?}", e))?;
 
-    for (idx, &rot) in rotations.iter().enumerate() {
-        if rot == 0 {
-            primary_index = idx as u32;
-        }
-        transformed.push(data[(rot + n - 1) % n]);
-    }
+    let primary_index = bwt_result.primary_index() as u32;
+    let transformed = bwt_result.bwt().to_vec();
 
-    Ok(BwtResult {
-        transformed,
-        primary_index,
-    })
+    Ok(BwtResult { transformed, primary_index })
 }
 
-pub fn bwt_decode(data: &[u8], primary_index: u32) -> Result<Vec<u8>> {
-    if data.is_empty() {
+pub fn bwt_decode(bwt_data: &[u8], primary_index: u32) -> Result<Vec<u8>> {
+    if bwt_data.is_empty() {
         return Ok(Vec::new());
     }
 
-    let n = data.len();
-    let primary_idx = primary_index as usize;
-
-    if primary_idx >= n {
-        return Err(anyhow::anyhow!("Invalid primary index"));
-    }
+    let bwt_obj: Bwt<'static, u8, OwnedBuffer> =
+        unsafe { Bwt::from_parts(bwt_data.to_vec(), primary_index as usize) };
 
-    let mut counts = vec![0usize; 256];
-    for &byte in data {
-        counts[byte as usize] += 1;
-    }
-
-    let mut cumsum = vec![0usize; 256];
-    let mut sum = 0;
-    for i in 0..256 {
-        cumsum[i] = sum;
-        sum += counts[i];
-    }
-
-    let mut next = vec![0usize; n];
-    let mut counts = vec![0usize; 256];
-
-    for i in 0..n {
-        let byte = data[i] as usize;
-        let pos = cumsum[byte] + counts[byte];
-        next[pos] = i;
-        counts[byte] += 1;
-    }
-
-    let mut result = Vec::with_capacity(n);
-    let mut idx = primary_idx;
-
-    for _ in 0..n {
-        result.push(data[idx]);
-        idx = next[idx];
-    }
+    let text = bwt_obj
+        .unbwt()
+        .with_owned_temporary_array_buffer32()
+        .single_threaded()
+        .run()
+        .map_err(|e| anyhow::anyhow!("libsais UnBWT: {:?}", e))?;
 
-    Ok(result)
+    Ok(text.as_slice().to_vec())
 }
 
 pub fn bwt_encode_streaming(block_size: usize, data: &[u8]) -> Result<Vec<(BwtResult, usize)>> {

package/native/hybrid.rs

@@ -1,12 +1,11 @@
 use anyhow::Result;
 use rayon::prelude::*;
-use crate::bwt::bwt_encode;
+use crate::bwt::{bwt_encode, bwt_decode};
+use crate::mtf::{mtf_encode, mtf_decode, rle0_encode, rle0_decode};
+use crate::rans_byte::{SymbolStats, rans_encode_block, rans_decode_block};
 use crate::context_mixing::analyze_entropy;
-use crate::rans::{build_symbols_from_frequencies, RansEncoder};
-use crate::pool::BufferPool;
-use std::sync::Arc;
 
-const BLOCK_SIZE: usize = 16 * 1024 * 1024;
+const BLOCK_SIZE: usize = 1024 * 1024;
 
 #[derive(Clone, Debug)]
 pub struct CompressionStats {
@@ -18,16 +17,12 @@ pub struct CompressionStats {
 }
 
 pub struct HybridCompressor {
-    pool: Arc<BufferPool>,
-    enable_gpu: bool,
     block_size: usize,
 }
 
 impl HybridCompressor {
-    pub fn new(enable_gpu: bool, pool_size: usize) -> Self {
+    pub fn new(_enable_gpu: bool, _pool_size: usize) -> Self {
         HybridCompressor {
-            pool: Arc::new(BufferPool::new(pool_size, BLOCK_SIZE)),
-            enable_gpu,
             block_size: BLOCK_SIZE,
         }
     }
@@ -40,12 +35,15 @@ impl HybridCompressor {
         let blocks_count = blocks.len();
 
         let compressed_blocks: Vec<Vec<u8>> = blocks
-            .into_par_iter()
-            .map(|block| self.compress_block(block))
+            .into_iter()
+            .map(|block| compress_block(block))
             .collect::<Result<Vec<_>, _>>()?;
 
-        let mut result = Vec::with_capacity(original_size as usize / 2);
+        let total_compressed: usize = compressed_blocks.iter().map(|b| b.len() + 4).sum();
+        let mut result = Vec::with_capacity(16 + total_compressed);
+        result.extend_from_slice(b"RBW1");
         result.extend_from_slice(&(blocks_count as u32).to_le_bytes());
+        result.extend_from_slice(&original_size.to_le_bytes());
 
         for block in &compressed_blocks {
             result.extend_from_slice(&(block.len() as u32).to_le_bytes());
@@ -64,83 +62,53 @@ impl HybridCompressor {
         }))
     }
 
-    fn compress_block(&self, block: &[u8]) -> Result<Vec<u8>> {
-        if block.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        let bwt = bwt_encode(block)?;
-        let bwt_data = &bwt.transformed;
-
-        let mut freqs = vec![0u32; 256];
-        for &byte in bwt_data {
-            freqs[byte as usize] += 1;
+    pub fn decompress(&self, data: &[u8]) -> Result<Vec<u8>> {
+        if data.len() < 16 {
+            return Err(anyhow::anyhow!("Invalid compressed data"));
         }
 
-        let symbols = build_symbols_from_frequencies(&freqs);
-        let mut encoder = RansEncoder::new(symbols);
-
-        for &byte in bwt_data {
-            for bit_idx in 0..8 {
-                let bit = (byte >> bit_idx) & 1 == 1;
-                let symbol_idx = if bit { 1 } else { 0 };
-                let _ = encoder.encode(symbol_idx);
-            }
+        if &data[0..4] != b"RBW1" {
+            return Err(anyhow::anyhow!("Invalid magic"));
         }
 
-        let encoded = encoder.finish();
-        let mut result = Vec::with_capacity(4 + encoded.len());
-        result.extend_from_slice(&bwt.primary_index.to_le_bytes());
-        result.extend_from_slice(&encoded);
-
-        Ok(result)
-    }
-
-    pub fn decompress(&self, data: &[u8]) -> Result<Vec<u8>> {
-        if data.len() < 4 {
-            return Err(anyhow::anyhow!("Invalid compressed data"));
-        }
+        let blocks_count = u32::from_le_bytes([data[4], data[5], data[6], data[7]]) as usize;
+        let original_size = u64::from_le_bytes([
+            data[8], data[9], data[10], data[11],
+            data[12], data[13], data[14], data[15],
+        ]) as usize;
 
-        let blocks_count = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize;
-        let mut pos = 4;
-        let mut result = Vec::new();
+        let mut pos = 16;
+        let mut block_ranges: Vec<(usize, usize)> = Vec::with_capacity(blocks_count);
 
         for _ in 0..blocks_count {
             if pos + 4 > data.len() {
                 return Err(anyhow::anyhow!("Truncated block header"));
             }
-
             let block_size = u32::from_le_bytes([
-                data[pos],
-                data[pos + 1],
-                data[pos + 2],
-                data[pos + 3],
+                data[pos], data[pos + 1], data[pos + 2], data[pos + 3],
             ]) as usize;
             pos += 4;
-
             if pos + block_size > data.len() {
                 return Err(anyhow::anyhow!("Truncated block data"));
             }
-
-            let block_data = &data[pos..pos + block_size];
+            block_ranges.push((pos, block_size));
             pos += block_size;
-
-            let decompressed = self.decompress_block(block_data)?;
-            result.extend_from_slice(&decompressed);
         }
 
-        Ok(result)
-    }
+        let decompressed_blocks: Vec<Vec<u8>> = block_ranges
+            .into_iter()
+            .map(|(start, size)| {
+                let block_data = &data[start..start + size];
+                decompress_block(block_data)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
 
-    fn decompress_block(&self, block: &[u8]) -> Result<Vec<u8>> {
-        if block.len() < 4 {
-            return Ok(Vec::new());
+        let mut result = Vec::with_capacity(original_size);
+        for block in decompressed_blocks {
+            result.extend_from_slice(&block);
         }
 
-        let _primary_index = u32::from_le_bytes([block[0], block[1], block[2], block[3]]);
-        let _encoded_data = &block[4..];
-
-        Ok(Vec::new())
+        Ok(result)
     }
 
     pub fn estimate_gain(&self, data: &[u8]) -> f64 {
@@ -151,12 +119,66 @@ impl HybridCompressor {
     }
 }
 
+fn compress_block(block: &[u8]) -> Result<Vec<u8>> {
+    if block.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let bwt = bwt_encode(block)?;
+    let mtf_data = mtf_encode(&bwt.transformed);
+    let rle_data = rle0_encode(&mtf_data);
+
+    let stats = SymbolStats::from_data(&rle_data);
+    let encoded = rans_encode_block(&rle_data, &stats);
+
+    let stats_bytes = stats.serialize();
+    let rle_len = rle_data.len() as u32;
+    let orig_len = block.len() as u32;
+
+    let mut result = Vec::with_capacity(4 + 4 + 4 + stats_bytes.len() + encoded.len());
+    result.extend_from_slice(&bwt.primary_index.to_le_bytes());
+    result.extend_from_slice(&orig_len.to_le_bytes());
+    result.extend_from_slice(&rle_len.to_le_bytes());
+    result.extend_from_slice(&stats_bytes);
+    result.extend_from_slice(&encoded);
+
+    Ok(result)
+}
+
+fn decompress_block(block: &[u8]) -> Result<Vec<u8>> {
+    if block.len() < 12 {
+        return Err(anyhow::anyhow!("Block too small"));
+    }
+
+    let primary_index = u32::from_le_bytes([block[0], block[1], block[2], block[3]]);
+    let orig_len = u32::from_le_bytes([block[4], block[5], block[6], block[7]]) as usize;
+    let rle_len = u32::from_le_bytes([block[8], block[9], block[10], block[11]]) as usize;
+
+    let (stats, stats_size) = SymbolStats::deserialize(&block[12..])?;
+    let encoded = &block[12 + stats_size..];
+
+    let rle_data = rans_decode_block(encoded, &stats, rle_len)?;
+    let mtf_data = rle0_decode(&rle_data);
+    let bwt_data = mtf_decode(&mtf_data);
+    let original = bwt_decode(&bwt_data, primary_index)?;
+
+    if original.len() != orig_len {
+        return Err(anyhow::anyhow!(
+            "Size mismatch: expected {}, got {}",
+            orig_len,
+            original.len()
+        ));
+    }
+
+    Ok(original)
+}
+
 pub fn compress_high_performance(data: &[u8]) -> Result<(Vec<u8>, CompressionStats)> {
-    let compressor = HybridCompressor::new(true, 4);
+    let compressor = HybridCompressor::new(false, 4);
     compressor.compress(data)
 }
 
 pub fn decompress_high_performance(data: &[u8]) -> Result<Vec<u8>> {
-    let compressor = HybridCompressor::new(true, 4);
+    let compressor = HybridCompressor::new(false, 4);
     compressor.decompress(data)
 }

package/native/lib.rs

@@ -9,7 +9,9 @@ mod core;
 #[cfg(feature = "gpu")]
 mod gpu;
 mod rans;
+mod rans_byte;
 mod bwt;
+mod mtf;
 mod context_mixing;
 mod pool;
 mod hybrid;
@@ -150,17 +152,18 @@ pub fn entropy_estimate(buffer: Buffer) -> f32 {
 
 #[cfg(not(test))]
 #[napi]
-pub fn hybrid_compress(buffer: Buffer) -> Result<Vec<u8>> {
+pub fn hybrid_compress(buffer: Buffer) -> Result<Buffer> {
     match hybrid::compress_high_performance(&buffer) {
-        Ok((compressed, _stats)) => Ok(compressed),
+        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<Vec<u8>> {
+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()))
 }