formatting

31 files changed, 208 insertions, 327 deletions

diff --git a/src/bin/client/repl.rs b/src/bin/client/repl.rs
index 7fa462a..9af4ea9 100644
--- a/src/bin/client/repl.rs
+++ b/src/bin/client/repl.rs
@@ -1,14 +1,14 @@
 use rusqlite::Connection;
-use std::io::{stdout, Write};
+use std::io::{Write, stdout};
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
 use crossterm::{
     cursor::{MoveToColumn, MoveUp, Show},
-    event::{read, Event, KeyCode, KeyEventKind, KeyModifiers},
+    event::{Event, KeyCode, KeyEventKind, KeyModifiers, read},
     execute,
     style::Stylize,
-    terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType},
+    terminal::{Clear, ClearType, disable_raw_mode, enable_raw_mode},
 };
 
 use sha2::{Digest, Sha256};
@@ -20,7 +20,7 @@ use zagan_bet::client::ui::{
     visual_line_count,
 };
 use zagan_bet::protocol::io_failure_message;
-use zagan_bet::roulette::{color as roulette_color, WHEEL};
+use zagan_bet::roulette::{WHEEL, color as roulette_color};
 
 use crate::connection::TlsStream;
 
@@ -71,8 +71,7 @@ impl ClientState {
                 self.core.set_connected(true);
                 self.core.set_logged_in(authed_user);
                 let fingerprint = database::get_fingerprint(&self.conn, addr);
-                self.core
-                    .set_host_info(Some(addr.to_string()), fingerprint);
+                self.core.set_host_info(Some(addr.to_string()), fingerprint);
                 database::save_host(&self.conn, addr);
             }
             Err(e) => {
@@ -178,12 +177,9 @@ impl ClientState {
                 Effect::Print(lines) => {
                     self.commit_prompt_line();
                     for line in lines {
-                        let rendered = if line.starts_with("ERROR")
-                            || line.contains("failed")
-                        {
+                        let rendered = if line.starts_with("ERROR") || line.contains("failed") {
                             line.as_str().red().to_string()
-                        } else if line.starts_with("Logged in")
-                            || line.starts_with("Successfully")
+                        } else if line.starts_with("Logged in") || line.starts_with("Successfully")
                         {
                             line.as_str().green().to_string()
                         } else if line.starts_with("Available commands:")
@@ -249,10 +245,7 @@ impl ClientState {
                 Effect::ForgetHost(target) => {
                     self.commit_prompt_line();
                     match database::forget_host(&self.conn, &target) {
-                        Ok(_) => println!(
-                            "Cleared trust and stored credentials for {}.",
-                            target
-                        ),
+                        Ok(_) => println!("Cleared trust and stored credentials for {}.", target),
                         Err(error) => println!("Failed to forget host: {}", error),
                     }
                 }
@@ -297,9 +290,7 @@ impl ClientState {
         let roulette = lines
             .first()
             .is_some_and(|first| first.contains("ROULETTE"));
-        let crash = lines
-            .first()
-            .is_some_and(|first| first.contains("CRASH"));
+        let crash = lines.first().is_some_and(|first| first.contains("CRASH"));
         let rendered: Vec<String> = lines
             .iter()
             .map(|line| {
diff --git a/src/bin/client/tls.rs b/src/bin/client/tls.rs
index b46f52b..e14ed98 100644
--- a/src/bin/client/tls.rs
+++ b/src/bin/client/tls.rs
@@ -17,10 +17,10 @@ use std::net::TcpStream;
 use std::sync::Arc;
 
 use parking_lot::Mutex;
-use rustls::client::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
 use rustls::DigitallySignedStruct;
+use rustls::client::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
 use zagan_bet::protocol::LineBuffer;
-use zagan_bet::tofu::{decide, spki_fingerprint, TrustDecision};
+use zagan_bet::tofu::{TrustDecision, decide, spki_fingerprint};
 
 pub struct TlsConnector {
     config: Arc<rustls::ClientConfig>,
@@ -53,7 +53,10 @@ impl TlsConnector {
         })
     }
 
-    pub fn connect(&self, stream: TcpStream) -> Result<TlsStream, Box<dyn std::error::Error + Send + Sync>> {
+    pub fn connect(
+        &self,
+        stream: TcpStream,
+    ) -> Result<TlsStream, Box<dyn std::error::Error + Send + Sync>> {
         let mut conn =
             rustls::ClientConnection::new(Arc::clone(&self.config), self.server_name.clone())?;
         let mut sock = stream;
@@ -200,10 +203,7 @@ impl TlsStream {
     }
 
     /// Apply a read timeout to the underlying TCP socket.
-    pub fn set_read_timeout(
-        &self,
-        duration: Option<std::time::Duration>,
-    ) -> std::io::Result<()> {
+    pub fn set_read_timeout(&self, duration: Option<std::time::Duration>) -> std::io::Result<()> {
         let mut s = self.session.lock();
         s.read_timeout = duration;
         s.sock.set_read_timeout(duration)
@@ -235,8 +235,7 @@ impl TlsStream {
                             Err(error)
                                 if matches!(
                                     error.kind(),
-                                    std::io::ErrorKind::WouldBlock
-                                        | std::io::ErrorKind::TimedOut
+                                    std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
                                 ) =>
                             {
                                 return Ok(());
diff --git a/src/bin/server/args.rs b/src/bin/server/args.rs
index 1babd1d..1db2a28 100644
--- a/src/bin/server/args.rs
+++ b/src/bin/server/args.rs
@@ -31,10 +31,7 @@ pub fn parse_args() -> Args {
                 if i + 1 < args.len() {
                     ip = args[i + 1].clone();
                     if ip != "127.0.0.1" && ip != "0.0.0.0" {
-                        eprintln!(
-                            "Invalid IP address: {}. Must be 127.0.0.1 or 0.0.0.0",
-                            ip
-                        );
+                        eprintln!("Invalid IP address: {}. Must be 127.0.0.1 or 0.0.0.0", ip);
                         std::process::exit(1);
                     }
                     i += 2;
diff --git a/src/bin/server/main.rs b/src/bin/server/main.rs
index 85e3134..f42574d 100644
--- a/src/bin/server/main.rs
+++ b/src/bin/server/main.rs
@@ -40,9 +40,9 @@ fn main() {
     let db_path = std::env::var("SERVER_DB").unwrap_or_else(|_| "server.db".to_string());
     match zagan_bet::server::core::recover_orphaned_reservations(&db_path) {
         Ok(0) => {}
-        Ok(count) => println!(
-            "Settled {count} orphaned reservation(s) as abandoned after a restart"
-        ),
+        Ok(count) => {
+            println!("Settled {count} orphaned reservation(s) as abandoned after a restart")
+        }
         Err(error) => {
             eprintln!("Failed to settle orphaned reservations in {db_path}: {error}");
             std::process::exit(1);
diff --git a/src/bin/server/tls.rs b/src/bin/server/tls.rs
index 5d84589..420b5b4 100644
--- a/src/bin/server/tls.rs
+++ b/src/bin/server/tls.rs
@@ -80,10 +80,7 @@ impl TlsStream {
 
     /// Read timeout for the socket. The connection loop uses a short one so it
     /// can advance crash rounds while no request is in flight.
-    pub fn set_read_timeout(
-        &self,
-        duration: Option<std::time::Duration>,
-    ) -> std::io::Result<()> {
+    pub fn set_read_timeout(&self, duration: Option<std::time::Duration>) -> std::io::Result<()> {
         self.stream.get_ref().set_read_timeout(duration)
     }
 }
diff --git a/src/client/core.rs b/src/client/core.rs
index 5f8c513..06d9c42 100644
--- a/src/client/core.rs
+++ b/src/client/core.rs
@@ -3,8 +3,8 @@ use crate::client::games::response::{
     parse_blackjack_response, parse_crash_response, parse_roulette_response, parse_spin_response,
 };
 use crate::client::ui::{
-    command_names, completion_lines, display_width, help_lines, input_cursor_column,
-    parse_bet_arg, record_history,
+    command_names, completion_lines, display_width, help_lines, input_cursor_column, parse_bet_arg,
+    record_history,
 };
 use crate::crash::{multiplier_at, CrashState};
 use crate::roulette::{Bets, NumberBet};
@@ -225,10 +225,7 @@ impl ClientCore {
                         "Game exited. Active hand forfeited ({} PLN lost).",
                         state.bet
                     );
-                    vec![
-                        Effect::ClearRegion,
-                        Effect::Print(vec![message]),
-                    ]
+                    vec![Effect::ClearRegion, Effect::Print(vec![message])]
                 }
                 Err(message) => {
                     self.game.set_error(message);
@@ -258,10 +255,7 @@ impl ClientCore {
                 Ok(state) => {
                     self.crash_started = None;
                     self.game.end_game();
-                    let message = format!(
-                        "Game exited. Round forfeited ({} PLN lost).",
-                        state.bet
-                    );
+                    let message = format!("Game exited. Round forfeited ({} PLN lost).", state.bet);
                     vec![Effect::ClearRegion, Effect::Print(vec![message])]
                 }
                 Err(_) if self.game.crash_status() != "running" => {
@@ -286,9 +280,7 @@ impl ClientCore {
                     self.logged_in = None;
                     vec![
                         Effect::Disconnect,
-                        Effect::Print(vec![
-                            "Connection lost".to_string(),
-                        ]),
+                        Effect::Print(vec!["Connection lost".to_string()]),
                     ]
                 }
             }
@@ -531,27 +523,20 @@ impl ClientCore {
                 }
             }
             Key::Char(' ') => self.start_blackjack(),
-            Key::Char('h')
-                if hand.as_ref().is_some_and(|hand| hand.phase == "player") =>
-            {
+            Key::Char('h') if hand.as_ref().is_some_and(|hand| hand.phase == "player") => {
                 self.blackjack_action("hit")
             }
-            Key::Char('s')
-                if hand.as_ref().is_some_and(|hand| hand.phase == "player") =>
-            {
+            Key::Char('s') if hand.as_ref().is_some_and(|hand| hand.phase == "player") => {
                 self.blackjack_action("stand")
             }
             Key::Char('d')
                 if hand.as_ref().is_some_and(|hand| {
-                    hand.phase == "player"
-                        && hand.actions.iter().any(|action| action == "double")
+                    hand.phase == "player" && hand.actions.iter().any(|action| action == "double")
                 }) =>
             {
                 self.blackjack_action("double")
             }
-            Key::Char('+') | Key::Char('=')
-                if matches!(status.as_str(), "ready" | "done") =>
-            {
+            Key::Char('+') | Key::Char('=') if matches!(status.as_str(), "ready" | "done") => {
                 let _ = self.game.adjust_bet(10);
                 self.board_effects()
             }
@@ -602,9 +587,7 @@ impl ClientCore {
         if hand.phase != "player" {
             return Vec::new();
         }
-        if action == "double"
-            && !hand.actions.iter().any(|available| available == "double")
-        {
+        if action == "double" && !hand.actions.iter().any(|available| available == "double") {
             return Vec::new();
         }
         self.pending = Some(Pending::BlackjackAction);
@@ -914,9 +897,9 @@ impl ClientCore {
             Some(fingerprint) => {
                 effects.push(Effect::Print(vec![format!("Fingerprint: {fingerprint}")]))
             }
-            None => effects.push(Effect::Print(vec![
-                "Fingerprint: (not trusted)".to_string(),
-            ])),
+            None => effects.push(Effect::Print(
+                vec!["Fingerprint: (not trusted)".to_string()],
+            )),
         }
 
         self.pending = Some(Pending::Info);
diff --git a/src/client/database.rs b/src/client/database.rs
index e1fa42d..e1cedaf 100644
--- a/src/client/database.rs
+++ b/src/client/database.rs
@@ -110,9 +110,8 @@ pub fn get_all_hosts(conn: &Connection) -> Vec<(String, Option<String>)> {
     let mut stmt = conn
         .prepare("SELECT host, fingerprint FROM hosts ORDER BY last_used DESC")
         .unwrap();
-    let rows = stmt.query_map([], |row| {
-        Ok((row.get(0)?, row.get(1)?))
-    })
-    .unwrap();
+    let rows = stmt
+        .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
+        .unwrap();
     rows.filter_map(|r| r.ok()).collect()
 }
diff --git a/src/client/games/blackjack.rs b/src/client/games/blackjack.rs
index bad1781..d5f45b3 100644
--- a/src/client/games/blackjack.rs
+++ b/src/client/games/blackjack.rs
@@ -56,15 +56,14 @@ impl Game for BlackjackGame {
             .get("status")
             .map(String::as_str)
             .unwrap_or("ready");
-        let balance = state
-            .data
-            .get("balance")
-            .map(String::as_str)
-            .unwrap_or("?");
+        let balance = state.data.get("balance").map(String::as_str).unwrap_or("?");
         let hand = Self::state(state);
 
         if let Some(error) = state.data.get("error") {
-            let bet = hand.as_ref().map(|hand| hand.bet).unwrap_or(state.bet_amount);
+            let bet = hand
+                .as_ref()
+                .map(|hand| hand.bet)
+                .unwrap_or(state.bet_amount);
             return format!(
                 "=== BLACKJACK ===\r\nBalance: {balance} PLN   Bet: {bet} PLN\r\n\r\n\r\nERROR: {error}\r\n[Q] Quit"
             );
diff --git a/src/client/games/manager.rs b/src/client/games/manager.rs
index 4d9e6a8..b20ff44 100644
--- a/src/client/games/manager.rs
+++ b/src/client/games/manager.rs
@@ -138,9 +138,7 @@ impl GameManager {
         session.bet_amount = result.bet_amount;
         session.data.remove("error");
         session.data.insert("reels".to_string(), result.reels);
-        session
-            .data
-            .insert("win_type".to_string(), result.win_type);
+        session.data.insert("win_type".to_string(), result.win_type);
         session.data.insert(
             "win_lines".to_string(),
             result
@@ -339,7 +337,9 @@ impl GameManager {
         for key in ["crash_point", "payout"] {
             session.data.remove(key);
         }
-        session.data.insert("status".to_string(), state.phase.clone());
+        session
+            .data
+            .insert("status".to_string(), state.phase.clone());
         session
             .data
             .insert("session_id".to_string(), state.session_id);
diff --git a/src/client/games/response.rs b/src/client/games/response.rs
index 71e1fed..88df459 100644
--- a/src/client/games/response.rs
+++ b/src/client/games/response.rs
@@ -128,8 +128,8 @@ pub fn parse_roulette_response(response: &str) -> Result<RouletteResult, String>
         return Err(format!("Invalid roulette color: {color}"));
     }
     let bets = parts[7].to_string();
-    let _: crate::roulette::Bets = serde_json::from_str(&bets)
-        .map_err(|error| format!("Invalid roulette bets: {error}"))?;
+    let _: crate::roulette::Bets =
+        serde_json::from_str(&bets).map_err(|error| format!("Invalid roulette bets: {error}"))?;
 
     Ok(RouletteResult {
         session_id: parts[1].to_string(),
diff --git a/src/client/games/roulette.rs b/src/client/games/roulette.rs
index 3379317..e80eca8 100644
--- a/src/client/games/roulette.rs
+++ b/src/client/games/roulette.rs
@@ -53,11 +53,7 @@ impl RouletteGame {
 
         match state.data.get("status").map(String::as_str) {
             Some("result") => {
-                let number = state
-                    .data
-                    .get("number")
-                    .map(String::as_str)
-                    .unwrap_or("?");
+                let number = state.data.get("number").map(String::as_str).unwrap_or("?");
                 let color = state
                     .data
                     .get("color")
@@ -102,11 +98,7 @@ impl Game for RouletteGame {
     fn render(&self, state: &GameState) -> String {
         let bets = Self::bets(state);
         let chip = state.data.get("chip").map(String::as_str).unwrap_or("10");
-        let balance = state
-            .data
-            .get("balance")
-            .map(String::as_str)
-            .unwrap_or("?");
+        let balance = state.data.get("balance").map(String::as_str).unwrap_or("?");
         let input = state
             .data
             .get("number_input")
diff --git a/src/client/games/slots.rs b/src/client/games/slots.rs
index d34bf49..2ec354e 100644
--- a/src/client/games/slots.rs
+++ b/src/client/games/slots.rs
@@ -109,11 +109,7 @@ impl Game for SlotsGame {
 
     fn render(&self, state: &GameState) -> String {
         let reels = state.data.get("reels").cloned().unwrap_or_default();
-        let balance = state
-            .data
-            .get("balance")
-            .map(String::as_str)
-            .unwrap_or("?");
+        let balance = state.data.get("balance").map(String::as_str).unwrap_or("?");
         let winning = Self::highlighted_cells(state);
         let grid = self.render_grid(&reels, &winning);
         let paytable = paytable_lines();
diff --git a/src/client/ui.rs b/src/client/ui.rs
index 0fe78ae..4ab0759 100644
--- a/src/client/ui.rs
+++ b/src/client/ui.rs
@@ -94,10 +94,7 @@ pub fn command_names() -> Vec<&'static str> {
 pub fn help_lines() -> Vec<String> {
     let mut lines = vec!["Available commands:".to_string()];
     for command in COMMANDS {
-        lines.push(format!(
-            "  {:<28} - {}",
-            command.usage, command.description
-        ));
+        lines.push(format!("  {:<28} - {}", command.usage, command.description));
     }
     lines
 }
@@ -291,16 +288,12 @@ pub fn host_lines(hosts: &[(String, Option<String>)]) -> Vec<String> {
 /// on the current line. `render()` has no trailing newline, so a 7-line board
 /// needs `MoveUp(6)`.
 pub fn lines_to_move_up(previous_lines: usize) -> u16 {
-    previous_lines
-        .saturating_sub(1)
-        .min(u16::MAX as usize) as u16
+    previous_lines.saturating_sub(1).min(u16::MAX as usize) as u16
 }
 
 /// Column (0-based) to move to after the given prompt and input text.
 pub fn input_cursor_column(prompt_len: usize, input_len: usize) -> u16 {
-    prompt_len
-        .saturating_add(input_len)
-        .min(u16::MAX as usize) as u16
+    prompt_len.saturating_add(input_len).min(u16::MAX as usize) as u16
 }
 
 /// Number of terminal rows a block of logical lines occupies after wrapping.
diff --git a/src/crash.rs b/src/crash.rs
index 55aab19..2936b99 100644
--- a/src/crash.rs
+++ b/src/crash.rs
@@ -24,9 +24,7 @@ pub fn multiplier_at_secs(seconds: f64) -> f64 {
     if !seconds.is_finite() || seconds <= 0.0 {
         return 1.0;
     }
-    (GROWTH_RATE * seconds)
-        .exp()
-        .clamp(1.0, MAX_MULTIPLIER)
+    (GROWTH_RATE * seconds).exp().clamp(1.0, MAX_MULTIPLIER)
 }
 
 /// How long a round runs before reaching `multiplier`.
diff --git a/src/roulette.rs b/src/roulette.rs
index b59f92e..426ecc3 100644
--- a/src/roulette.rs
+++ b/src/roulette.rs
@@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize};
 
 /// European wheel clockwise from zero.
 pub const WHEEL: [u8; 37] = [
-    0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5,
-    24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26,
+    0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20,
+    14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26,
 ];
 
 pub const RED_NUMBERS: [u8; 18] = [
@@ -92,8 +92,7 @@ impl Bets {
             if is_red(number) {
                 winnings = winnings.saturating_add(self.red.saturating_mul(EVEN_MONEY_RETURN));
             } else {
-                winnings =
-                    winnings.saturating_add(self.black.saturating_mul(EVEN_MONEY_RETURN));
+                winnings = winnings.saturating_add(self.black.saturating_mul(EVEN_MONEY_RETURN));
             }
             if is_even(number) {
                 winnings = winnings.saturating_add(self.even.saturating_mul(EVEN_MONEY_RETURN));
@@ -104,8 +103,7 @@ impl Bets {
 
         for bet in &self.numbers {
             if bet.number == number {
-                winnings = winnings
-                    .saturating_add(bet.amount.saturating_mul(STRAIGHT_RETURN));
+                winnings = winnings.saturating_add(bet.amount.saturating_mul(STRAIGHT_RETURN));
             }
         }
 
diff --git a/src/server/core.rs b/src/server/core.rs
index e0f0ff2..4b68ccb 100644
--- a/src/server/core.rs
+++ b/src/server/core.rs
@@ -49,11 +49,7 @@ impl ServerCore {
         Self::with_registry(conn, GameRegistry::with_defaults(), DEFAULT_COST)
     }
 
-    pub fn with_registry(
-        conn: Connection,
-        registry: GameRegistry,
-        bcrypt_cost: u32,
-    ) -> Self {
+    pub fn with_registry(conn: Connection, registry: GameRegistry, bcrypt_cost: u32) -> Self {
         Self {
             conn,
             sessions: SessionManager::new(),
@@ -115,8 +111,7 @@ impl ServerCore {
             }
             "GAME_INFO" => {
                 if parts.len() != 2 {
-                    "ERROR Invalid GAME_INFO format. Usage: GAME_INFO <game_type>"
-                        .to_string()
+                    "ERROR Invalid GAME_INFO format. Usage: GAME_INFO <game_type>".to_string()
                 } else {
                     match self.registry.get_game(parts[1]) {
                         Some(game) => format!(
@@ -143,16 +138,14 @@ impl ServerCore {
             }
             "CRASH_CASHOUT" => {
                 if parts.len() != 2 {
-                    "ERROR Invalid CRASH_CASHOUT format. Usage: CRASH_CASHOUT <session>"
-                        .to_string()
+                    "ERROR Invalid CRASH_CASHOUT format. Usage: CRASH_CASHOUT <session>".to_string()
                 } else {
                     self.handle_crash_end(state, parts[1], false)
                 }
             }
             "CRASH_FORFEIT" => {
                 if parts.len() != 2 {
-                    "ERROR Invalid CRASH_FORFEIT format. Usage: CRASH_FORFEIT <session>"
-                        .to_string()
+                    "ERROR Invalid CRASH_FORFEIT format. Usage: CRASH_FORFEIT <session>".to_string()
                 } else {
                     self.handle_crash_end(state, parts[1], true)
                 }
@@ -351,12 +344,8 @@ impl ServerCore {
                 if hand.player.len() != 2 {
                     return "ERROR Double is only allowed on the first two cards".to_string();
                 }
-                if database::extend_reservation(
-                    &mut self.conn,
-                    session_id,
-                    hand.base_bet as i64,
-                )
-                .is_err()
+                if database::extend_reservation(&mut self.conn, session_id, hand.base_bet as i64)
+                    .is_err()
                 {
                     return "ERROR Insufficient balance".to_string();
                 }
@@ -515,7 +504,12 @@ impl ServerCore {
 
     /// Cash out or forfeit. The multiplier comes from the server clock at the
     /// moment the request is handled; the client never supplies one.
-    fn handle_crash_end(&mut self, state: &ConnectionState, session_id: &str, forfeit: bool) -> String {
+    fn handle_crash_end(
+        &mut self,
+        state: &ConnectionState,
+        session_id: &str,
+        forfeit: bool,
+    ) -> String {
         let Some(user) = state.user.as_deref() else {
             return "ERROR Not logged in".to_string();
         };
@@ -698,11 +692,7 @@ impl ServerCore {
                         .get("number")
                         .cloned()
                         .unwrap_or_default();
-                    let color = result
-                        .result_data
-                        .get("color")
-                        .cloned()
-                        .unwrap_or_default();
+                    let color = result.result_data.get("color").cloned().unwrap_or_default();
                     let bets = result
                         .result_data
                         .get("bets")
@@ -712,11 +702,7 @@ impl ServerCore {
                         "ROULETTE_RESULT {session_id} {winnings} {bet_amount} {new_balance} {number} {color} {bets}"
                     )
                 } else {
-                    let reels = result
-                        .result_data
-                        .get("reels")
-                        .cloned()
-                        .unwrap_or_default();
+                    let reels = result.result_data.get("reels").cloned().unwrap_or_default();
                     let win_type = result
                         .result_data
                         .get("win_type")
@@ -753,8 +739,7 @@ impl ServerCore {
                         if let Ok(mut hand) = BlackjackHand::from_json(raw) {
                             if !hand.is_done() {
                                 hand.forfeit();
-                                let balance =
-                                    database::get_balance(&self.conn, user).unwrap_or(0);
+                                let balance = database::get_balance(&self.conn, user).unwrap_or(0);
                                 let final_state = hand.state(&session.session_id, balance);
                                 let details = serde_json::to_string(&final_state)
                                     .unwrap_or_else(|_| "{}".to_string());
diff --git a/src/server/games/blackjack.rs b/src/server/games/blackjack.rs
index df5a6ac..cea817a 100644
--- a/src/server/games/blackjack.rs
+++ b/src/server/games/blackjack.rs
@@ -1,7 +1,5 @@
 use super::traits::{Game, GameError, GamePhase, GameResult, GameState};
-use crate::blackjack::{
-    card_value, fresh_shoe, hand_total, is_blackjack, BlackjackState,
-};
+use crate::blackjack::{card_value, fresh_shoe, hand_total, is_blackjack, BlackjackState};
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use serde::{Deserialize, Serialize};
diff --git a/src/server/games/roulette.rs b/src/server/games/roulette.rs
index 7beb8c9..0a58323 100644
--- a/src/server/games/roulette.rs
+++ b/src/server/games/roulette.rs
@@ -65,17 +65,15 @@ impl Game for RouletteGame {
 
         match action {
             "spin" => {
-                if state.phase != GamePhase::WaitingToStart
-                    && state.phase != GamePhase::Playing
-                {
+                if state.phase != GamePhase::WaitingToStart && state.phase != GamePhase::Playing {
                     return Err(GameError::InvalidAction(
                         "Cannot spin in current phase".to_string(),
                     ));
                 }
 
-                let payload = params
-                    .first()
-                    .ok_or(GameError::InvalidAction("Missing roulette bets".to_string()))?;
+                let payload = params.first().ok_or(GameError::InvalidAction(
+                    "Missing roulette bets".to_string(),
+                ))?;
                 let bets: Bets = serde_json::from_str(payload)
                     .map_err(|error| GameError::InvalidAction(format!("Invalid bets: {error}")))?;
 
diff --git a/src/server/games/slots.rs b/src/server/games/slots.rs
index 298cd4c..caced24 100644
--- a/src/server/games/slots.rs
+++ b/src/server/games/slots.rs
@@ -175,9 +175,7 @@ impl Game for SlotsGame {
 
         match action {
             "spin" => {
-                if state.phase != GamePhase::WaitingToStart
-                    && state.phase != GamePhase::Playing
-                {
+                if state.phase != GamePhase::WaitingToStart && state.phase != GamePhase::Playing {
                     return Err(GameError::InvalidAction(
                         "Cannot spin in current phase".to_string(),
                     ));
diff --git a/src/server/setup.rs b/src/server/setup.rs
index 96982c5..023e6ed 100644
--- a/src/server/setup.rs
+++ b/src/server/setup.rs
@@ -47,19 +47,8 @@ pub fn init_identity(dir: &Path, common_name: &str) -> Result<SetupReport, Strin
     run_openssl(
         dir,
         &[
-            "req",
-            "-x509",
-            "-newkey",
-            "rsa:2048",
-            "-keyout",
-            "key.pem",
-            "-out",
-            "cert.pem",
-            "-days",
-            "3650",
-            "-nodes",
-            "-subj",
-            &subject,
+            "req", "-x509", "-newkey", "rsa:2048", "-keyout", "key.pem", "-out", "cert.pem",
+            "-days", "3650", "-nodes", "-subj", &subject,
         ],
         "generate the certificate",
         &manual,
@@ -98,9 +87,8 @@ pub fn init_identity(dir: &Path, common_name: &str) -> Result<SetupReport, Strin
                 .map_err(|error| format!("Could not inspect {}: {error}", path.display()))?;
             let mut permissions = metadata.permissions();
             permissions.set_mode(0o600);
-            std::fs::set_permissions(path, permissions).map_err(|error| {
-                format!("Could not protect {}: {error}", path.display())
-            })?;
+            std::fs::set_permissions(path, permissions)
+                .map_err(|error| format!("Could not protect {}: {error}", path.display()))?;
         }
     }
 
diff --git a/src/slots.rs b/src/slots.rs
index 9e41f05..443444e 100644
--- a/src/slots.rs
+++ b/src/slots.rs
@@ -16,14 +16,8 @@ pub const PAYLINES: [[usize; REELS]; 5] = [
 pub const LINE_NAMES: [&str; 5] = ["top", "middle", "bottom", "V", "inverted V"];
 
 /// Symbol value multipliers.
-pub const SYMBOL_MULTIPLIERS: [(char, u64); 6] = [
-    ('C', 1),
-    ('L', 2),
-    ('O', 3),
-    ('G', 4),
-    ('D', 6),
-    ('S', 10),
-];
+pub const SYMBOL_MULTIPLIERS: [(char, u64); 6] =
+    [('C', 1), ('L', 2), ('O', 3), ('G', 4), ('D', 6), ('S', 10)];
 
 /// (match length, shape multiplier): 3, 4 or 5 of a kind.
 pub const SHAPE_MULTIPLIERS: [(usize, u64); 3] = [(3, 1), (4, 3), (5, 14)];
diff --git a/src/tofu.rs b/src/tofu.rs
index 6308813..15f38d1 100644
--- a/src/tofu.rs
+++ b/src/tofu.rs
@@ -17,10 +17,7 @@ pub enum TrustDecision {
     /// Stored fingerprint matches: proceed.
     Trusted,
     /// Key changed since first use: reject with details.
-    Mismatch {
-        expected: String,
-        actual: String,
-    },
+    Mismatch { expected: String, actual: String },
 }
 
 /// Hex-encoded SHA-256 of the SPKI inside a DER-encoded X.509 certificate.
diff --git a/tests/blackjack.rs b/tests/blackjack.rs
index f90ca8d..36ed7cf 100644
--- a/tests/blackjack.rs
+++ b/tests/blackjack.rs
@@ -16,7 +16,12 @@ fn card_values_and_soft_totals_are_correct() {
     assert_eq!(card_label("AS"), "A♠");
     assert_eq!(card_label("10H"), "10♥");
 
-    let cards = |values: &[&str]| values.iter().map(|card| card.to_string()).collect::<Vec<_>>();
+    let cards = |values: &[&str]| {
+        values
+            .iter()
+            .map(|card| card.to_string())
+            .collect::<Vec<_>>()
+    };
     assert_eq!(hand_total(&cards(&["AS", "10H"])), 21);
     assert_eq!(hand_total(&cards(&["AS", "9H"])), 20);
     assert_eq!(hand_total(&cards(&["AS", "AS", "9H"])), 21);
diff --git a/tests/client_core.rs b/tests/client_core.rs
index e8b5646..176791e 100644
--- a/tests/client_core.rs
+++ b/tests/client_core.rs
@@ -4,6 +4,7 @@
 //! logical `Effect`s that `ClientCore` emits, so assertions are about what a
 //! player would see, not about ANSI sequences.
 
+use std::time::Duration;
 use zagan_bet::blackjack::BlackjackState;
 use zagan_bet::client::core::{ClientCore, Effect, InteractiveCommand, Key};
 use zagan_bet::client::games::response::{
@@ -11,7 +12,6 @@ use zagan_bet::client::games::response::{
 };
 use zagan_bet::client::ui::command_names;
 use zagan_bet::crash::CrashState;
-use std::time::Duration;
 
 const WIN3: &str = "CCCCLLCLODGSDGS";
 const LOSS: &str = "CLOOGDSLCDCOGLS";
@@ -67,10 +67,7 @@ impl Screen {
                 }
                 Effect::SendLine(line) => sent.push(line.clone()),
                 Effect::Interactive(command) => interactive.push(command.clone()),
-                Effect::Quit
-                | Effect::Disconnect
-                | Effect::ListHosts
-                | Effect::ForgetHost(_) => {}
+                Effect::Quit | Effect::Disconnect | Effect::ListHosts | Effect::ForgetHost(_) => {}
             }
         }
     }
@@ -276,7 +273,8 @@ fn a_mega_win_shows_all_winning_lines() {
 
     assert_eq!(h.board().len(), 10);
     assert!(h.board()[7].contains("MEGA WIN! 700 PLN"));
-    assert!(h.board()[8].contains("Winning lines: 1 (top), 2 (middle), 3 (bottom), 4 (V), 5 (inverted V)"));
+    assert!(h.board()[8]
+        .contains("Winning lines: 1 (top), 2 (middle), 3 (bottom), 4 (V), 5 (inverted V)"));
     assert_eq!(h.board()[2].matches("{ C }").count(), 5);
 }
 
@@ -423,10 +421,7 @@ fn help_lists_every_command() {
 
     let transcript = h.screen.lines.join("\n");
     for command in command_names() {
-        assert!(
-            transcript.contains(command),
-            "help is missing '{command}'"
-        );
+        assert!(transcript.contains(command), "help is missing '{command}'");
     }
 }
 
@@ -548,11 +543,7 @@ fn send_prints_the_echo() {
     h.line("send hello");
     h.reply("hello");
 
-    assert!(h
-        .screen
-        .lines
-        .iter()
-        .any(|line| line == "Echo: hello"));
+    assert!(h.screen.lines.iter().any(|line| line == "Echo: hello"));
 }
 
 #[test]
@@ -560,11 +551,7 @@ fn disconnect_clears_connection_state() {
     let mut h = Harness::new();
     h.line("disconnect");
 
-    assert!(h
-        .screen
-        .lines
-        .iter()
-        .any(|line| line == "Disconnected"));
+    assert!(h.screen.lines.iter().any(|line| line == "Disconnected"));
 
     h.line("play slots");
     assert!(h
@@ -636,8 +623,7 @@ fn roulette_split_bets_spin_and_show_the_result() {
         "PLAY_START roulette 30 {\"red\":10,\"black\":0,\"even\":10,\"odd\":0,\"numbers\":[{\"number\":17,\"amount\":10}]}"
     );
 
-    let bets =
-        r#"{"red":10,"black":0,"even":10,"odd":0,"numbers":[{"number":17,"amount":10}]}"#;
+    let bets = r#"{"red":10,"black":0,"even":10,"odd":0,"numbers":[{"number":17,"amount":10}]}"#;
     h.reply(&format!(
         "ROULETTE_RESULT session-1 360 30 1330 17 black {bets}"
     ));
@@ -655,7 +641,10 @@ fn roulette_rejects_an_empty_spin_and_accepts_the_equals_chip_key() {
 
     h.key(Key::Char(' '));
     assert!(h.board()[4].contains("ERROR: Place at least one bet"));
-    assert!(!h.sent.iter().any(|line| line.starts_with("PLAY_START roulette")));
+    assert!(!h
+        .sent
+        .iter()
+        .any(|line| line.starts_with("PLAY_START roulette")));
 
     h.key(Key::Char('='));
     assert!(h.board()[1].contains("Chip: 20 PLN"));
@@ -716,10 +705,7 @@ fn blackjack_deals_hits_and_settles() {
     assert!(h.board()[4].contains("Press [SPACE] to deal."));
 
     h.key(Key::Char(' '));
-    assert!(h
-        .sent
-        .iter()
-        .any(|line| line == "PLAY_START blackjack 10"));
+    assert!(h.sent.iter().any(|line| line == "PLAY_START blackjack 10"));
 
     let player = bj_state(
         "bj1",
@@ -847,10 +833,7 @@ fn blackjack_ready_board_can_change_the_next_bet() {
     assert!(h.board()[1].contains("Bet: 20 PLN"));
 
     h.key(Key::Char(' '));
-    assert!(h
-        .sent
-        .iter()
-        .any(|line| line == "PLAY_START blackjack 20"));
+    assert!(h.sent.iter().any(|line| line == "PLAY_START blackjack 20"));
 }
 
 #[test]
@@ -875,7 +858,13 @@ fn parses_a_blackjack_state() {
     assert!(parse_blackjack_response("ERROR Insufficient balance").is_err());
 }
 
-fn crash_state(phase: &str, multiplier: f64, crash_point: Option<f64>, payout: u64, balance: i64) -> CrashState {
+fn crash_state(
+    phase: &str,
+    multiplier: f64,
+    crash_point: Option<f64>,
+    payout: u64,
+    balance: i64,
+) -> CrashState {
     CrashState {
         session_id: "cr1".to_string(),
         phase: phase.to_string(),
@@ -920,10 +909,7 @@ fn crash_starts_a_round_and_draws_the_multiplier_locally() {
     assert!(h.board()[3].contains("Potential: 20 PLN"));
 
     h.key(Key::Char('c'));
-    assert_eq!(
-        h.sent.last().map(String::as_str),
-        Some("CRASH_CASHOUT cr1")
-    );
+    assert_eq!(h.sent.last().map(String::as_str), Some("CRASH_CASHOUT cr1"));
 
     let cashed = crash_state("cashed", 2.0, Some(3.0), 20, 1010);
     h.reply(&crash_line("CRASH_STATE", &cashed));
@@ -967,10 +953,7 @@ fn crash_q_forfeits_an_active_round() {
     h.reply(&crash_line("CRASH_START", &running));
 
     h.key(Key::Char('q'));
-    assert_eq!(
-        h.sent.last().map(String::as_str),
-        Some("CRASH_FORFEIT cr1")
-    );
+    assert_eq!(h.sent.last().map(String::as_str), Some("CRASH_FORFEIT cr1"));
 
     let forfeited = crash_state("forfeit", 1.2, Some(2.0), 0, 990);
     h.reply(&crash_line("CRASH_STATE", &forfeited));
diff --git a/tests/client_ui.rs b/tests/client_ui.rs
index 7a1b675..44febde 100644
--- a/tests/client_ui.rs
+++ b/tests/client_ui.rs
@@ -1,9 +1,9 @@
+use std::time::Duration;
 use zagan_bet::client::ui::{
-    command_names, completion_lines, display_width, first_contact_lines, format_pong,
-    help_lines, host_lines, input_cursor_column, lines_to_move_up, parse_bet_arg, record_history,
+    command_names, completion_lines, display_width, first_contact_lines, format_pong, help_lines,
+    host_lines, input_cursor_column, lines_to_move_up, parse_bet_arg, record_history,
     visual_line_count,
 };
-use std::time::Duration;
 
 #[test]
 fn help_has_no_source_indentation() {
@@ -27,13 +27,7 @@ fn help_documents_every_command() {
 fn completion_knows_every_command() {
     let commands = command_names();
     for expected in [
-        "connect",
-        "games",
-        "play",
-        "hosts",
-        "send",
-        "logout",
-        "quit",
+        "connect", "games", "play", "hosts", "send", "logout", "quit",
     ] {
         assert!(
             commands.contains(&expected),
@@ -109,19 +103,12 @@ fn display_width_ignores_ansi_sequences() {
 fn visual_line_count_ignores_ansi_sequences() {
     let styled = format!("\x1b[31m{}\x1b[0m", "x".repeat(75));
     assert_eq!(visual_line_count(&[styled], 72), 2);
-    assert_eq!(
-        visual_line_count(&["\x1b[31m18\x1b[0m".to_string()], 80),
-        1
-    );
+    assert_eq!(visual_line_count(&["\x1b[31m18\x1b[0m".to_string()], 80), 1);
 }
 
 #[test]
 fn visual_line_count_accounts_for_terminal_wrapping() {
-    let lines = vec![
-        "12345".to_string(),
-        "123456".to_string(),
-        String::new(),
-    ];
+    let lines = vec!["12345".to_string(), "123456".to_string(), String::new()];
 
     assert_eq!(visual_line_count(&lines, 5), 4); // 1 + 2 + 1
     assert_eq!(visual_line_count(&lines, 6), 3); // 1 + 1 + 1
@@ -146,7 +133,10 @@ fn completions_wrap_within_the_requested_width() {
     let commands = command_names();
     let lines = completion_lines(&commands, 40);
 
-    assert_eq!(lines.first().map(String::as_str), Some("Possible completions:"));
+    assert_eq!(
+        lines.first().map(String::as_str),
+        Some("Possible completions:")
+    );
     for line in &lines[1..] {
         assert!(
             line.len() <= 40,
@@ -208,10 +198,7 @@ fn pong_is_formatted_to_one_decimal() {
 fn host_lines_fit_an_80_column_terminal() {
     let fingerprint = "a4d6f80784154c2cb739a1df61ab3e9038ed731ee2e05c7611457ac741b3834c";
     let lines = host_lines(&[
-        (
-            "127.0.0.1:11525".to_string(),
-            Some(fingerprint.to_string()),
-        ),
+        ("127.0.0.1:11525".to_string(), Some(fingerprint.to_string())),
         ("unknown.example:443".to_string(), None),
     ]);
 
@@ -233,10 +220,7 @@ fn hosts_sharing_a_fingerprint_are_shown_as_one_server() {
     let lines = host_lines(&[
         ("10.0.0.100:11525".to_string(), Some(key.to_string())),
         ("127.0.0.1:11525".to_string(), Some(key.to_string())),
-        (
-            "other.example:11525".to_string(),
-            Some("ff".repeat(32)),
-        ),
+        ("other.example:11525".to_string(), Some("ff".repeat(32))),
     ]);
 
     assert_eq!(
@@ -264,7 +248,10 @@ fn hosts_without_a_fingerprint_are_never_merged() {
     assert!(lines.contains(&"  a.example:443".to_string()));
     assert!(lines.contains(&"  b.example:443".to_string()));
     assert_eq!(
-        lines.iter().filter(|line| line.contains("no fingerprint")).count(),
+        lines
+            .iter()
+            .filter(|line| line.contains("no fingerprint"))
+            .count(),
         2
     );
 }
diff --git a/tests/crash.rs b/tests/crash.rs
index f59c52f..49eaf89 100644
--- a/tests/crash.rs
+++ b/tests/crash.rs
@@ -18,7 +18,11 @@ fn the_multiplier_doubles_every_five_seconds() {
     close(multiplier_at(Duration::ZERO), 1.0, 1e-9);
     close(multiplier_at(Duration::from_secs(5)), 2.0, 1e-9);
     close(multiplier_at(Duration::from_secs(10)), 4.0, 1e-6);
-    close(multiplier_at(Duration::from_millis(2500)), 1.414_213_562, 1e-6);
+    close(
+        multiplier_at(Duration::from_millis(2500)),
+        1.414_213_562,
+        1e-6,
+    );
 
     // Never below 1x, even for nonsense input.
     assert_eq!(multiplier_at_secs(-3.0), 1.0);
diff --git a/tests/protocol.rs b/tests/protocol.rs
index 2962574..bf8a4fd 100644
--- a/tests/protocol.rs
+++ b/tests/protocol.rs
@@ -40,8 +40,14 @@ fn reads_multiple_lines_from_a_reader() {
     let mut buffer = LineBuffer::new();
     let mut reader = Cursor::new(b"one\ntwo\n".to_vec());
 
-    assert_eq!(buffer.read_line(&mut reader).unwrap().as_deref(), Some("one"));
-    assert_eq!(buffer.read_line(&mut reader).unwrap().as_deref(), Some("two"));
+    assert_eq!(
+        buffer.read_line(&mut reader).unwrap().as_deref(),
+        Some("one")
+    );
+    assert_eq!(
+        buffer.read_line(&mut reader).unwrap().as_deref(),
+        Some("two")
+    );
     assert_eq!(buffer.read_line(&mut reader).unwrap(), None);
 }
 
diff --git a/tests/roulette.rs b/tests/roulette.rs
index 6b99d17..932bace 100644
--- a/tests/roulette.rs
+++ b/tests/roulette.rs
@@ -1,6 +1,4 @@
-use zagan_bet::roulette::{
-    color, is_black, is_even, is_odd, is_red, rtp, Bets, NumberBet, WHEEL,
-};
+use zagan_bet::roulette::{color, is_black, is_even, is_odd, is_red, rtp, Bets, NumberBet, WHEEL};
 use zagan_bet::server::games::roulette::RouletteGame;
 use zagan_bet::server::games::traits::Game;
 
@@ -171,14 +169,13 @@ fn rejects_bad_roulette_results() {
     use zagan_bet::client::games::response::parse_roulette_response;
 
     let valid_bets = r#"{"red":10}"#;
-    assert!(parse_roulette_response(&format!(
-        "ROULETTE_RESULT s 1 1 1 37 green {valid_bets}"
-    ))
-    .is_err());
-    assert!(parse_roulette_response(&format!(
-        "ROULETTE_RESULT s 1 1 1 17 purple {valid_bets}"
-    ))
-    .is_err());
+    assert!(
+        parse_roulette_response(&format!("ROULETTE_RESULT s 1 1 1 37 green {valid_bets}")).is_err()
+    );
+    assert!(
+        parse_roulette_response(&format!("ROULETTE_RESULT s 1 1 1 17 purple {valid_bets}"))
+            .is_err()
+    );
     assert!(parse_roulette_response("ROULETTE_RESULT s 1 1 1 17 black nope").is_err());
     assert!(parse_roulette_response("").is_err());
 }
diff --git a/tests/server_core.rs b/tests/server_core.rs
index 0350fb6..6b7b415 100644
--- a/tests/server_core.rs
+++ b/tests/server_core.rs
@@ -4,13 +4,13 @@ use std::sync::Arc;
 use rusqlite::Connection;
 use zagan_bet::blackjack::BlackjackState;
 use zagan_bet::crash::CrashState;
+use zagan_bet::roulette::Bets;
 use zagan_bet::server::core::{ConnectionState, ServerCore};
 use zagan_bet::server::database;
 use zagan_bet::server::games::crash::ManualClock;
 use zagan_bet::server::games::registry::GameRegistry;
 use zagan_bet::server::games::roulette::RouletteGame;
 use zagan_bet::server::games::slots::SlotsGame;
-use zagan_bet::roulette::Bets;
 
 fn setup(name: &str, grid: &str) -> (ServerCore, String) {
     let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
@@ -63,8 +63,7 @@ fn setup_blackjack(name: &str, deck: &[&str]) -> (ServerCore, String) {
 
     let deck = deck.iter().map(|card| card.to_string()).collect();
     (
-        ServerCore::with_registry(conn, GameRegistry::with_defaults(), 4)
-            .with_blackjack_deck(deck),
+        ServerCore::with_registry(conn, GameRegistry::with_defaults(), 4).with_blackjack_deck(deck),
         path,
     )
 }
@@ -216,7 +215,10 @@ fn plays_record_the_game_type_and_game_specific_details() {
     login(&mut core, &mut state, "alice");
 
     let response = core.handle_message(&mut state, "PLAY_START slots 10");
-    assert!(response.starts_with("GAME_RESULT"), "spin failed: {response}");
+    assert!(
+        response.starts_with("GAME_RESULT"),
+        "spin failed: {response}"
+    );
 
     let conn = Connection::open(&path).unwrap();
     let (game_type, details): (String, String) = conn
@@ -242,8 +244,7 @@ fn roulette_settles_split_bets_and_records_details() {
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
 
-    let bets =
-        r#"{"red":10,"black":10,"even":10,"odd":10,"numbers":[{"number":17,"amount":5}]}"#;
+    let bets = r#"{"red":10,"black":10,"even":10,"odd":10,"numbers":[{"number":17,"amount":5}]}"#;
     let response = core.handle_message(&mut state, &format!("PLAY_START roulette 45 {bets}"));
 
     assert!(
@@ -254,7 +255,10 @@ fn roulette_settles_split_bets_and_records_details() {
         response.contains(" 220 45 1175 17 black "),
         "response: {response}"
     );
-    assert!(response.ends_with(&format!(" {bets}")), "response: {response}");
+    assert!(
+        response.ends_with(&format!(" {bets}")),
+        "response: {response}"
+    );
     assert_eq!(core.balance("alice"), Some(1175));
     assert_eq!(core.play_count("alice"), 1);
     assert_eq!(core.session_count(), 0);
@@ -327,7 +331,10 @@ fn a_winning_spin_updates_the_balance_and_the_audit_row() {
     login(&mut core, &mut state, "alice");
 
     let response = core.handle_message(&mut state, "PLAY_START slots 10");
-    assert!(response.starts_with("GAME_RESULT"), "spin failed: {response}");
+    assert!(
+        response.starts_with("GAME_RESULT"),
+        "spin failed: {response}"
+    );
     assert!(response.contains(" 10 10 1000 "), "response: {response}");
     assert!(response.ends_with(" win 1 0,3,6"), "response: {response}");
 
@@ -364,11 +371,8 @@ fn a_negative_balance_is_rejected_without_wrapping() {
     login(&mut core, &mut state, "alice");
 
     let conn = Connection::open(&path).unwrap();
-    conn.execute(
-        "UPDATE users SET balance = -5 WHERE username = 'alice'",
-        [],
-    )
-    .unwrap();
+    conn.execute("UPDATE users SET balance = -5 WHERE username = 'alice'", [])
+        .unwrap();
 
     assert_eq!(
         core.handle_message(&mut state, "PLAY_START slots 10"),
@@ -394,10 +398,7 @@ fn unknown_games_are_rejected_before_a_session_is_created() {
 
 #[test]
 fn blackjack_reserves_the_bet_and_settles_a_hit_hand() {
-    let (mut core, path) = setup_blackjack(
-        "blackjack-hit",
-        &["10S", "9D", "6H", "8C", "5D"],
-    );
+    let (mut core, path) = setup_blackjack("blackjack-hit", &["10S", "9D", "6H", "8C", "5D"]);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -442,10 +443,7 @@ fn blackjack_reserves_the_bet_and_settles_a_hit_hand() {
 
 #[test]
 fn blackjack_double_reserves_an_extra_bet() {
-    let (mut core, path) = setup_blackjack(
-        "blackjack-double",
-        &["5S", "9D", "5H", "8C", "10D"],
-    );
+    let (mut core, path) = setup_blackjack("blackjack-double", &["5S", "9D", "5H", "8C", "10D"]);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -483,8 +481,7 @@ fn blackjack_double_reserves_an_extra_bet() {
 
 #[test]
 fn blackjack_natural_settles_immediately() {
-    let (mut core, _path) =
-        setup_blackjack("blackjack-natural", &["AS", "9D", "KH", "8C"]);
+    let (mut core, _path) = setup_blackjack("blackjack-natural", &["AS", "9D", "KH", "8C"]);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -501,8 +498,7 @@ fn blackjack_natural_settles_immediately() {
 
 #[test]
 fn blackjack_forfeit_keeps_the_reserved_bet() {
-    let (mut core, _path) =
-        setup_blackjack("blackjack-cancel", &["10S", "9D", "6H", "8C"]);
+    let (mut core, _path) = setup_blackjack("blackjack-cancel", &["10S", "9D", "6H", "8C"]);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -524,8 +520,7 @@ fn blackjack_forfeit_keeps_the_reserved_bet() {
 
 #[test]
 fn blackjack_disconnect_forfeits_the_reserved_bet() {
-    let (mut core, _path) =
-        setup_blackjack("blackjack-disconnect", &["10S", "9D", "6H", "8C"]);
+    let (mut core, _path) = setup_blackjack("blackjack-disconnect", &["10S", "9D", "6H", "8C"]);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -578,10 +573,9 @@ fn crash_cashout_pays_the_multiplier_from_the_server_clock() {
 
     // Five seconds of round time: 2.00x, still below the 3.00x crash point.
     clock.advance(5.0);
-    let cashed = crash_state(&core.handle_message(
-        &mut state,
-        &format!("CRASH_CASHOUT {}", started.session_id),
-    ));
+    let cashed = crash_state(
+        &core.handle_message(&mut state, &format!("CRASH_CASHOUT {}", started.session_id)),
+    );
 
     assert_eq!(cashed.phase, "cashed");
     assert_eq!(cashed.multiplier, 2.0);
@@ -600,7 +594,15 @@ fn crash_cashout_pays_the_multiplier_from_the_server_clock() {
             "SELECT game_type, bet_amount, winnings, balance_after, details
              FROM plays WHERE username = 'alice'",
             [],
-            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?, row.get(4)?)),
+            |row| {
+                Ok((
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    row.get(3)?,
+                    row.get(4)?,
+                ))
+            },
         )
         .unwrap();
     assert_eq!(game_type, "crash");
@@ -627,10 +629,9 @@ fn a_cashout_after_the_crash_time_loses_the_reserved_bet() {
     let started = crash_state(&core.handle_message(&mut state, "PLAY_START crash 10"));
 
     clock.advance(20.0);
-    let late = crash_state(&core.handle_message(
-        &mut state,
-        &format!("CRASH_CASHOUT {}", started.session_id),
-    ));
+    let late = crash_state(
+        &core.handle_message(&mut state, &format!("CRASH_CASHOUT {}", started.session_id)),
+    );
 
     assert_eq!(late.phase, "crashed");
     assert_eq!(late.payout, 0);
@@ -679,10 +680,9 @@ fn crash_forfeit_keeps_the_reserved_bet() {
     login(&mut core, &mut state, "alice");
 
     let started = crash_state(&core.handle_message(&mut state, "PLAY_START crash 10"));
-    let forfeited = crash_state(&core.handle_message(
-        &mut state,
-        &format!("CRASH_FORFEIT {}", started.session_id),
-    ));
+    let forfeited = crash_state(
+        &core.handle_message(&mut state, &format!("CRASH_FORFEIT {}", started.session_id)),
+    );
 
     assert_eq!(forfeited.phase, "forfeit");
     assert_eq!(forfeited.payout, 0);
@@ -747,10 +747,7 @@ fn crash_rounds_are_owned_by_the_player_who_started_them() {
 
     clock.advance(5.0);
     assert_eq!(
-        core.handle_message(
-            &mut bob,
-            &format!("CRASH_CASHOUT {}", started.session_id)
-        ),
+        core.handle_message(&mut bob, &format!("CRASH_CASHOUT {}", started.session_id)),
         "ERROR Invalid session"
     );
     assert_eq!(core.balance("bob"), Some(1000));
@@ -775,10 +772,9 @@ fn a_crash_reservation_is_durable_until_the_round_settles() {
     drop(conn);
 
     clock.advance(5.0);
-    let cashed = crash_state(&core.handle_message(
-        &mut state,
-        &format!("CRASH_CASHOUT {}", started.session_id),
-    ));
+    let cashed = crash_state(
+        &core.handle_message(&mut state, &format!("CRASH_CASHOUT {}", started.session_id)),
+    );
     assert_eq!(cashed.phase, "cashed");
 
     let conn = Connection::open(&path).unwrap();
diff --git a/tests/slots.rs b/tests/slots.rs
index 8bdd9af..7f0b6b5 100644
--- a/tests/slots.rs
+++ b/tests/slots.rs
@@ -1,8 +1,8 @@
 //! Regression tests for the server-side 5x3 slots game.
 
-use zagan_bet::slots::{paytable_lines, LINE_NAMES, SHAPE_MULTIPLIERS, SYMBOL_MULTIPLIERS};
 use zagan_bet::server::games::slots::{LineWin, SlotsGame, PAYLINES, REELS, ROWS};
 use zagan_bet::server::games::traits::{Game, GamePhase};
+use zagan_bet::slots::{paytable_lines, LINE_NAMES, SHAPE_MULTIPLIERS, SYMBOL_MULTIPLIERS};
 
 /// Convert row-major test rows into the column-major wire format.
 fn grid(rows: [&str; 3]) -> String {
@@ -62,7 +62,10 @@ fn four_of_a_kind_pays_more_than_three() {
 fn five_of_a_kind_pays_all_lines() {
     let (winnings, wins) = payout(["SSSSS", "SSSSS", "SSSSS"], 10);
 
-    assert_eq!(winnings, 7000, "five SSSSS lines: 5 * 10 * S(10) * shape5(14)");
+    assert_eq!(
+        winnings, 7000,
+        "five SSSSS lines: 5 * 10 * S(10) * shape5(14)"
+    );
     assert_eq!(lines(&wins), vec![1, 2, 3, 4, 5]);
     assert_eq!(wins[0].cells, vec![0, 3, 6, 9, 12]);
     assert_eq!(wins[3].cells, vec![0, 4, 8, 10, 12]);
diff --git a/tests/tofu.rs b/tests/tofu.rs
index 4f59d6d..b644cc4 100644
--- a/tests/tofu.rs
+++ b/tests/tofu.rs
@@ -74,7 +74,10 @@ fn fingerprint_is_sha256_of_spki() {
     let expected = openssl_spki_sha256(dir.join("primary.pem").to_str().unwrap());
 
     let fp = spki_fingerprint(&der).expect("must parse the test certificate");
-    assert_eq!(fp, expected, "fingerprint must equal openssl's SPKI SHA-256");
+    assert_eq!(
+        fp, expected,
+        "fingerprint must equal openssl's SPKI SHA-256"
+    );
 }
 
 #[test]
@@ -90,10 +93,7 @@ fn first_contact_trusts_and_records() {
 
 #[test]
 fn matching_key_is_trusted() {
-    assert_eq!(
-        decide(Some("ab12cd34"), "ab12cd34"),
-        TrustDecision::Trusted
-    );
+    assert_eq!(decide(Some("ab12cd34"), "ab12cd34"), TrustDecision::Trusted);
 }
 
 #[test]