tenho seguinte código tauri v2 rust


use std::{fs, path::Path};
use reqwest::blocking::get;
use std::io::Write;
use serde::Serialize;
use tauri::Emitter;

#[derive(Serialize)]
pub struct DownloadProgress {
    pub status_message: String,
    pub current_file: usize,
    pub total_files: usize,
    pub file_name: String,
    pub downloaded_bytes: u64,
    pub total_bytes: u64,
}

#[tauri::command]
pub fn start_download(app_handle: tauri::AppHandle) -> Result<(), String> {
    let patch_file = "patch.lua";

    // Lendo o arquivo patch.lua
    let content = fs::read_to_string(patch_file).map_err(|_| "Falha ao ler patch.lua")?;

    // Parse do arquivo patch.lua
    let updates = lua::parse_updates(&content)?;

    // Criar pasta "patch" caso não exista
    let patch_dir = Path::new("patch");
    if !patch_dir.exists() {
        fs::create_dir(&patch_dir).map_err(|_| "Não foi possível criar a pasta patch")?;
    }

    // Total de arquivos
    let total_files = updates.len();

    for (current_file, update) in updates.iter().enumerate() {
        let file_name = &update.file_name;
        let url = format!("https://hil-speed.hetzner.com/{}", file_name);
        let destination = patch_dir.join(&update.file_name);

        // Emitir status inicial
        app_handle
            .emit(
                "download-progress",
                DownloadProgress {
                    status_message: "Conectando ao servidor".to_string(),
                    current_file: current_file + 1,
                    total_files,
                    file_name: file_name.clone(),
                    downloaded_bytes: 0,
                    total_bytes: 0,
                },
            )
            .unwrap();

        // Baixar arquivo
        let response = get(&url).map_err(|_| "Erro ao conectar ao servidor")?;
        let total_bytes = response.content_length().ok_or("Tamanho do arquivo desconhecido")?;
        let mut downloaded_bytes = 0;
        let mut file = fs::File::create(&destination).map_err(|_| "Erro ao criar arquivo local")?;

        for chunk_result in response.bytes() {
            let chunk = chunk_result.map_err(|_| "Erro durante o download")?;
            downloaded_bytes += chunk.len() as u64;
            file.write_all(&chunk).map_err(|_| "Erro ao gravar no arquivo")?;

            // Emitir progresso
            app_handle
                .emit(
                    "download-progress",
                    DownloadProgress {
                        status_message: "Baixando arquivo".to_string(),
                        current_file: current_file + 1,
                        total_files,
                        file_name: file_name.clone(),
                        downloaded_bytes,
                        total_bytes,
                    },
                )
                .unwrap();
        }
    }

    Ok(())
}

pub mod lua {
    use mlua::{Lua, Value};
    use super::DownloadProgress;

    pub fn parse_updates(content: &str) -> Result<Vec<DownloadProgress>, String> {
        let lua = Lua::new();
        let globals = lua.globals();

        lua.load(content).exec().map_err(|e| format!("Erro ao carregar Lua: {}", e))?;
        let updates: Value = globals.get("updates").map_err(|e| format!("Erro ao acessar tabela Lua: {}", e))?;

        if let Value::Table(table) = updates {
            let mut result = Vec::new();
            for pair in table.sequence_values::<mlua::Table>() {
                let _item = pair.map_err(|_| "Erro ao iterar valores Lua")?;
                let update = DownloadProgress {
                    status_message: "Download".to_string(),
                    current_file: 0,
                    total_files: 0,
                    file_name: "Desconhecido".to_string(),
                    downloaded_bytes: 0,
                    total_bytes: 0,
                };
                result.push(update);
            }
            Ok(result)
        } else {
            Err("Estrutura inesperada em updates".to_string())
        }
    }
}

recebo erro

error[E0277]: the trait bound `DownloadProgress: Clone` is not satisfied
   --> src\download.rs:45:17
    |
43  |               .emit(
    |                ---- required by a bound introduced by this call
44  |                   "download-progress",
45  | /                 DownloadProgress {
46  | |                     status_message: "Conectando ao servidor".to_string(),
47  | |                     current_file: current_file + 1,
48  | |                     total_files,
...   |
51  | |                     total_bytes: 0,
52  | |                 },
    | |_________________^ the trait `Clone` is not implemented for `DownloadProgress`
    |
note: required by a bound in `emit`
   --> C:\Users\jonatas\.cargo\registry\src\index.crates.io-6f17d22bba15001f\tauri-2.1.1\src/lib.rs:934:26
    |
934 |   fn emit<S: Serialize + Clone>(&self, event: &str, payload: S) -> Result<()>;
    |                          ^^^^^ required by this bound in `Emitter::emit`
help: consider annotating `DownloadProgress` with `#[derive(Clone)]`
    |
8   + #[derive(Clone)]
9   | pub struct DownloadProgress {
    |

error[E0599]: no method named `map_err` found for struct `bytes::bytes::Bytes` in the current scope
  --> src\download.rs:63:38
   |
63 |             let chunk = chunk_result.map_err(|_| "Erro durante o download")?;
   |                                      ^^^^^^^ method not found in `Bytes`

error[E0277]: the trait bound `DownloadProgress: Clone` is not satisfied
   --> src\download.rs:71:21
    |
69  |                   .emit(
    |                    ---- required by a bound introduced by this call
70  |                       "download-progress",
71  | /                     DownloadProgress {
72  | |                         status_message: "Baixando arquivo".to_string(),
73  | |                         current_file: current_file + 1,
74  | |                         total_files,
...   |
77  | |                         total_bytes,
78  | |                     },
    | |_____________________^ the trait `Clone` is not implemented for `DownloadProgress`
    |
note: required by a bound in `emit`
   --> C:\Users\jonatas\.cargo\registry\src\index.crates.io-6f17d22bba15001f\tauri-2.1.1\src/lib.rs:934:26
    |
934 |   fn emit<S: Serialize + Clone>(&self, event: &str, payload: S) -> Result<()>;
    |                          ^^^^^ required by this bound in `Emitter::emit`
help: consider annotating `DownloadProgress` with `#[derive(Clone)]`
    |
8   + #[derive(Clone)]
9   | pub struct DownloadProgress {
    |

Some errors have detailed explanations: E0277, E0599.       
For more information about an error, try `rustc --explain E0277`.
error: could not compile `RagnaTales` (lib) due to 3 previous errors