style: apply cargo fmt across the crate

Pre-existing repo-wide rustfmt drift (~44 files, not CI-gated). Pure cargo fmt normalisation: AST-preserving, no behaviour change. Kept out of the PD-CLI-CONV-B functional slice on purpose; landed as a dedicated, separately-approved style commit.

Co-Authored-By: aeroftp[bot] <aeroftp[bot]@users.noreply.github.com>
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

src-tauri/src/aerorsync/delta_transport_impl.rs

@@ -66,7 +66,7 @@ use tokio::io::{AsyncSeekExt, AsyncWriteExt};
 use crate::aerorsync::engine_adapter::{
     BaselineSource, CurrentDeltaSyncBridge, FileBaseline, MemoryBaseline,
 };
-use crate::aerorsync::fallback_policy::{FallbackVerdict, classify_fallback};
+use crate::aerorsync::fallback_policy::{classify_fallback, FallbackVerdict};
 use crate::aerorsync::native_driver::{AerorsyncDriver, PreambleProfile};
 use crate::aerorsync::real_wire::FileListEntry;
 use crate::aerorsync::remote_command::RemoteCommandSpec;
@@ -167,10 +167,7 @@ impl AerorsyncDeltaTransport {
             // resolves SSH_AUTH_SOCK at connect time. `prefers_russh_leg`
             // then routes probe + single-shot through russh (libssh2 is
             // pubkey-file-only).
-            auth_agent: matches!(
-                cfg.auth_method,
-                crate::rsync_over_ssh::AuthMethod::Agent
-            ),
+            auth_agent: matches!(cfg.auth_method, crate::rsync_over_ssh::AuthMethod::Agent),
             // B.1/B.4: probe stock `rsync --version` on the remote. The
             // parser in `parse_probe_protocol` extracts the numeric
             // protocol version from the multi-line banner. A missing
@@ -1828,8 +1825,15 @@ mod tests {
             .expect("sparse write");
 
         let back = std::fs::read(&target).unwrap();
-        assert_eq!(back.len(), data.len(), "size must match (set_len fixed trailing hole)");
-        assert_eq!(back, data, "sparse output must be byte-identical (holes read as zeros)");
+        assert_eq!(
+            back.len(),
+            data.len(),
+            "size must match (set_len fixed trailing hole)"
+        );
+        assert_eq!(
+            back, data,
+            "sparse output must be byte-identical (holes read as zeros)"
+        );
     }
 
     #[cfg(unix)]
@@ -1856,7 +1860,10 @@ mod tests {
             .expect("sparse write");
 
         // Logical content identical.
-        assert_eq!(std::fs::read(&dense).unwrap(), std::fs::read(&sparse).unwrap());
+        assert_eq!(
+            std::fs::read(&dense).unwrap(),
+            std::fs::read(&sparse).unwrap()
+        );
 
         let dense_blocks = std::fs::metadata(&dense).unwrap().blocks();
         let sparse_blocks = std::fs::metadata(&sparse).unwrap().blocks();

src-tauri/src/aerorsync/engine_adapter.rs

@@ -26,7 +26,7 @@ use crate::aerorsync::protocol::{
     DeltaInstruction as ProtocolDeltaInstruction, SignatureBlock as ProtocolSignatureBlock,
 };
 use crate::delta_sync;
-use crate::delta_sync::{RollingChecksum, strong_hash};
+use crate::delta_sync::{strong_hash, RollingChecksum};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EngineSignatureBlock {

src-tauri/src/aerorsync/local_transport.rs

@@ -112,11 +112,12 @@ impl LocalDeltaTransport {
         // Apply the plan to the baseline to reconstruct the target bytes.
         // For an identical baseline this is purely CopyBlock ops and the
         // output equals `source`.
-        let reconstructed = delta_sync::apply_delta(&baseline, &ops, block_size)
-            .map_err(|e| RsyncError::TransferFailed {
+        let reconstructed = delta_sync::apply_delta(&baseline, &ops, block_size).map_err(|e| {
+            RsyncError::TransferFailed {
                 exit: 0,
                 stderr: format!("local delta apply failed: {e}"),
-            })?;
+            }
+        })?;
 
         // Account literal bytes for the speedup metric: this is the byte
         // count that would have travelled on the wire in a real delta sync.
@@ -209,13 +210,10 @@ impl DeltaTransport for LocalDeltaTransport {
         Ok(())
     }
 
-    async fn upload(
-        &self,
-        local_path: &Path,
-        remote_path: &str,
-    ) -> Result<RsyncStats, RsyncError> {
+    async fn upload(&self, local_path: &Path, remote_path: &str) -> Result<RsyncStats, RsyncError> {
         // `remote_path` is interpreted as a local filesystem path.
-        self.transfer_inner(local_path, Path::new(remote_path)).await
+        self.transfer_inner(local_path, Path::new(remote_path))
+            .await
     }
 
     async fn download(
@@ -224,7 +222,8 @@ impl DeltaTransport for LocalDeltaTransport {
         local_path: &Path,
     ) -> Result<RsyncStats, RsyncError> {
         // Inverted direction: `remote_path` is the source on the local fs.
-        self.transfer_inner(Path::new(remote_path), local_path).await
+        self.transfer_inner(Path::new(remote_path), local_path)
+            .await
     }
 }
 
@@ -478,7 +477,9 @@ mod tests {
         let dir = tmp_dir();
         let src = dir.path().join("src.bin");
         let dst = dir.path().join("dst.bin");
-        tokio::fs::write(&src, vec![0u8; 1024 * 1024 + 1]).await.unwrap();
+        tokio::fs::write(&src, vec![0u8; 1024 * 1024 + 1])
+            .await
+            .unwrap();
         let perms = std::fs::Permissions::from_mode(0o640);
         std::fs::set_permissions(&src, perms).unwrap();
 

src-tauri/src/aerorsync/native_driver.rs

@@ -47,25 +47,25 @@
 //! checkpoint doc.
 
 use crate::aerorsync::engine_adapter::{
-    BaselineSource, DeltaEngineAdapter, DeltaPlanProducer, EngineDeltaOp, EngineSignatureBlock,
-    RollingDeltaPlanProducer, apply_delta_streaming,
+    apply_delta_streaming, BaselineSource, DeltaEngineAdapter, DeltaPlanProducer, EngineDeltaOp,
+    EngineSignatureBlock, RollingDeltaPlanProducer,
 };
 use crate::aerorsync::events::EventSink;
 use crate::aerorsync::real_wire::{
-    ClientPreamble, DeltaOp, DeltaStreamReport, FileListDecodeOptions, FileListDecodeOutcome,
-    FileListEntry, MAX_DELTA_LITERAL_LEN, MuxHeader, MuxPoll, MuxStreamReader, MuxTag, NDX_DONE,
-    NDX_FLIST_EOF, NdxState, RealWireError, SumBlock, SumHead, SummaryFrame,
     compress_zstd_literal_stream, decode_delta_stream, decode_file_list_entry, decode_item_flags,
     decode_ndx, decode_server_preamble, decode_sum_block, decode_sum_head, decode_summary_frame,
     decompress_zstd_literal_stream_boundaries, encode_client_preamble, encode_delta_stream,
     encode_file_list_entry, encode_file_list_terminator, encode_item_flags, encode_ndx,
-    encode_sum_block, encode_sum_head, encode_summary_frame,
+    encode_sum_block, encode_sum_head, encode_summary_frame, ClientPreamble, DeltaOp,
+    DeltaStreamReport, FileListDecodeOptions, FileListDecodeOutcome, FileListEntry, MuxHeader,
+    MuxPoll, MuxStreamReader, MuxTag, NdxState, RealWireError, SumBlock, SumHead, SummaryFrame,
+    MAX_DELTA_LITERAL_LEN, NDX_DONE, NDX_FLIST_EOF,
 };
 use crate::aerorsync::remote_command::{RemoteCommandFlavor, RemoteCommandSpec};
 use crate::aerorsync::transport::{CancelHandle, RawByteStream, RawRemoteShellTransport};
 use crate::aerorsync::types::{AerorsyncError, AerorsyncErrorKind, SessionRole, SessionStats};
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite};
-use xxhash_rust::xxh3::{Xxh3Default, xxh3_128, xxh3_128_with_seed};
+use xxhash_rust::xxh3::{xxh3_128, xxh3_128_with_seed, Xxh3Default};
 
 /// Compute the 16-byte file-level strong checksum rsync verifies at the
 /// end of the delta stream when `xxh128` is the negotiated algo.
@@ -317,7 +317,11 @@ fn wire_dump_append(file: &str, header: &str, bytes: &[u8]) {
             let _ = write!(
                 out,
                 "{}",
-                if (0x20..0x7f).contains(&c) { c as char } else { '.' }
+                if (0x20..0x7f).contains(&c) {
+                    c as char
+                } else {
+                    '.'
+                }
             );
         }
         let _ = writeln!(out, "|");
@@ -1071,10 +1075,7 @@ impl<T: RawRemoteShellTransport> AerorsyncDriver<T> {
                     })?;
                     let chunk = stream.read_bytes(RAW_READ_CHUNK).await?;
                     if chunk.is_empty() {
-                        wire_dump_server_response(
-                            &scratch,
-                            "remote-closed-before-server-preamble",
-                        );
+                        wire_dump_server_response(&scratch, "remote-closed-before-server-preamble");
                         return Err(AerorsyncError::transport(
                             "perform_preamble_exchange: remote closed before server preamble",
                         ));
@@ -2027,34 +2028,23 @@ impl<T: RawRemoteShellTransport> AerorsyncDriver<T> {
                     // loop-top would. An empty `buf` here is a genuine
                     // no-payload no-op (keep the local baseline).
                     if !buf.is_empty() {
-                        match decode_delta_stream(
-                            &buf,
-                            A2_3_FILE_CHECKSUM_LEN,
-                            sum_head_count,
-                        ) {
+                        match decode_delta_stream(&buf, A2_3_FILE_CHECKSUM_LEN, sum_head_count) {
                             Ok((report, consumed)) => {
-                                self.stash_post_delta_into_summary_seed(
-                                    &buf[consumed..],
-                                );
-                                self.received_file_checksum =
-                                    Some(report.file_checksum.clone());
+                                self.stash_post_delta_into_summary_seed(&buf[consumed..]);
+                                self.received_file_checksum = Some(report.file_checksum.clone());
                                 self.install_reconstructed_from_wire(
                                     destination_data,
                                     adapter,
                                     report.ops,
                                 )?;
-                                self.phase =
-                                    AerorsyncSessionPhase::DeltaReceived;
+                                self.phase = AerorsyncSessionPhase::DeltaReceived;
                                 return Ok(());
                             }
                             Err(RealWireError::DeltaTokenTruncated { .. }) => {
                                 return Err(e);
                             }
                             Err(other) => {
-                                return Err(map_realwire_error(
-                                    other,
-                                    "delta stream",
-                                ));
+                                return Err(map_realwire_error(other, "delta stream"));
                             }
                         }
                     }
@@ -2175,17 +2165,10 @@ impl<T: RawRemoteShellTransport> AerorsyncDriver<T> {
                     // loop-top would. An empty `buf` here is a genuine
                     // no-payload no-op (keep the local baseline).
                     if !buf.is_empty() {
-                        match decode_delta_stream(
-                            &buf,
-                            A2_3_FILE_CHECKSUM_LEN,
-                            sum_head_count,
-                        ) {
+                        match decode_delta_stream(&buf, A2_3_FILE_CHECKSUM_LEN, sum_head_count) {
                             Ok((report, consumed)) => {
-                                self.stash_post_delta_into_summary_seed(
-                                    &buf[consumed..],
-                                );
-                                self.received_file_checksum =
-                                    Some(report.file_checksum.clone());
+                                self.stash_post_delta_into_summary_seed(&buf[consumed..]);
+                                self.received_file_checksum = Some(report.file_checksum.clone());
                                 self.install_reconstructed_from_wire_streaming(
                                     baseline, writer, adapter, report.ops,
                                 )
@@ -2200,10 +2183,7 @@ impl<T: RawRemoteShellTransport> AerorsyncDriver<T> {
                                 return Err(e);
                             }
                             Err(other) => {
-                                return Err(map_realwire_error(
-                                    other,
-                                    "delta stream",
-                                ));
+                                return Err(map_realwire_error(other, "delta stream"));
                             }
                         }
                     }
@@ -2294,9 +2274,9 @@ impl<T: RawRemoteShellTransport> AerorsyncDriver<T> {
         let zstd_on = self.zstd_negotiated();
         let engine_ops = self.delta_wire_to_engine_ops(&wire_ops, zstd_on)?;
         let _ = adapter; // adapter is unused on the streaming path -
-        // engine ops carry everything apply_delta_streaming needs.
-        // Kept in the signature for parity with the bulk twin and
-        // to leave room for future adapter-driven dispatch.
+                         // engine ops carry everything apply_delta_streaming needs.
+                         // Kept in the signature for parity with the bulk twin and
+                         // to leave room for future adapter-driven dispatch.
         let block_size = self
             .sent_sum_head
             .as_ref()
@@ -2963,11 +2943,11 @@ mod tests {
     use crate::aerorsync::engine_adapter::{
         DeltaEngineAdapter, EngineDeltaOp, EngineDeltaPlan, EngineSignatureBlock,
     };
-    use crate::aerorsync::events::{AerorsyncEvent, CollectingSink, classify_oob_frame};
+    use crate::aerorsync::events::{classify_oob_frame, AerorsyncEvent, CollectingSink};
     use crate::aerorsync::fixtures::RealRsyncBaselineByteTranscript;
     use crate::aerorsync::mock::{MockRemoteShellTransport, MockTransportConfig};
     use crate::aerorsync::real_wire::{
-        ServerPreamble, decode_client_preamble, encode_server_preamble, reassemble_msg_data,
+        decode_client_preamble, encode_server_preamble, reassemble_msg_data, ServerPreamble,
     };
 
     /// Mock adapter used by A2.2/A2.3 tests. Returns a configurable
@@ -3080,7 +3060,7 @@ mod tests {
         blocks: &[SumBlock],
     ) -> Vec<u8> {
         use crate::aerorsync::real_wire::{
-            NdxState, encode_item_flags, encode_ndx, encode_sum_block, encode_sum_head,
+            encode_item_flags, encode_ndx, encode_sum_block, encode_sum_head, NdxState,
         };
         let mut st = NdxState::new();
         let mut out = Vec::new();
@@ -3138,8 +3118,8 @@ mod tests {
             block_len,
         }
     }
-    use std::sync::Arc;
     use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::Arc;
 
     // ---- helpers ---------------------------------------------------------
 

src-tauri/src/aerorsync/real_wire.rs

@@ -3217,7 +3217,11 @@ mod tests {
 
         let err = decode_server_preamble(&buf).unwrap_err();
         match err {
-            RealWireError::TruncatedBuffer { at, needed, available } => {
+            RealWireError::TruncatedBuffer {
+                at,
+                needed,
+                available,
+            } => {
                 assert_eq!(at, "server_checksum_algos");
                 assert_eq!(needed, 25); // 1 len byte + 24 declared bytes
                 assert!(
@@ -3247,7 +3251,11 @@ mod tests {
 
         let err = decode_server_preamble(&buf).unwrap_err();
         match err {
-            RealWireError::TruncatedBuffer { at, needed, available } => {
+            RealWireError::TruncatedBuffer {
+                at,
+                needed,
+                available,
+            } => {
                 assert_eq!(at, "server_compression_algos");
                 assert_eq!(needed, 25);
                 assert!(available < needed);
@@ -5306,7 +5314,10 @@ mod tests {
         let (outcome, _) = decode_file_list_entry(&reg_bytes, &opts).unwrap();
         match outcome {
             FileListDecodeOutcome::Entry(d) => {
-                assert!(d.symlink_target.is_none(), "regular file must have no symlink target");
+                assert!(
+                    d.symlink_target.is_none(),
+                    "regular file must have no symlink target"
+                );
             }
             other => panic!("expected Entry, got {other:?}"),
         }

src-tauri/src/aerorsync/russh_session_transport.rs

@@ -17,8 +17,8 @@ use russh::keys::{self, Algorithm, EcdsaCurve, HashAlg, PrivateKeyWithHashAlg, P
 use russh::Preferred;
 use russh::{Channel, ChannelMsg};
 use secrecy::ExposeSecret;
-use std::borrow::Cow;
 use sha2::{Digest, Sha256};
+use std::borrow::Cow;
 use tokio::sync::Mutex as AsyncMutex;
 
 use crate::aerorsync::ssh_transport::{parse_probe_protocol, SshHostKeyPolicy, SshTransportConfig};
@@ -208,9 +208,10 @@ async fn authenticate_agent(
             "ssh-agent connect (SSH_AUTH_SOCK): {e}; is an agent running and SSH_AUTH_SOCK set?"
         ))
     })?;
-    let identities = agent.request_identities().await.map_err(|e| {
-        AerorsyncError::transport(format!("ssh-agent request_identities: {e}"))
-    })?;
+    let identities = agent
+        .request_identities()
+        .await
+        .map_err(|e| AerorsyncError::transport(format!("ssh-agent request_identities: {e}")))?;
     if identities.is_empty() {
         return Err(AerorsyncError::transport(
             "ssh-agent has no identities loaded (run `ssh-add` first)",
@@ -1065,9 +1066,9 @@ mod tests {
         let before = transport.handshake_count();
         match transport.reconnect().await {
             Err(_) => {}
-            Ok(_) => panic!(
-                "reconnect to port 1 should not succeed in CI: see connect_refuses_port_1"
-            ),
+            Ok(_) => {
+                panic!("reconnect to port 1 should not succeed in CI: see connect_refuses_port_1")
+            }
         }
         assert_eq!(
             transport.handshake_count(),

src-tauri/src/aerovault_v2.rs

@@ -155,7 +155,11 @@ pub async fn vault_v2_add_files(
     let paths: Vec<std::path::PathBuf> = file_paths.iter().map(std::path::PathBuf::from).collect();
     report.step(format!(
         "encrypt+seal: AES-256-GCM-SIV{} over 64KiB chunks, rebuild container",
-        if cascade { " + ChaCha20-Poly1305 cascade" } else { "" }
+        if cascade {
+            " + ChaCha20-Poly1305 cascade"
+        } else {
+            ""
+        }
     ));
     let added = vault.add_files(&paths).map_err(|e| e.to_string())?;
     let total = vault.list().map_err(|e| e.to_string())?.len();
@@ -171,8 +175,7 @@ pub async fn vault_v2_add_files(
     report.encrypted_bytes = size_after.saturating_sub(size_before);
     report.step(format!(
         "done: {} file(s) added, container grew {} byte(s)",
-        added,
-        report.encrypted_bytes
+        added, report.encrypted_bytes
     ));
     report.finish(started.elapsed().as_millis() as u64);