diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 10a7ab2..0000000
Binary files a/.DS_Store and /dev/null differ
diff --git a/.github/workflows/check-bible-verify.yml b/.github/workflows/check-bible-verify.yml
index c87ed7f..fa00107 100644
--- a/.github/workflows/check-bible-verify.yml
+++ b/.github/workflows/check-bible-verify.yml
@@ -5,7 +5,7 @@ on:
       - main
 
 jobs:
-  build:
+  build-bible-verify:
     runs-on: ubuntu-latest  # Indented correctly under 'build'
 
     steps:
diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index ffe54ec..94d63fb 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -5,7 +5,7 @@ on:
       - main
 
 jobs:
-  build:
+  build-site:
     runs-on: ubuntu-latest  # Indented correctly under 'build'
 
     steps:
diff --git a/.gitignore b/.gitignore
index e08a429..c2f17ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .direnv
+.DS_Store
 result
 bible-verify/target
diff --git a/bible-verify.nix b/bible-verify/bible-verify.nix
similarity index 65%
rename from bible-verify.nix
rename to bible-verify/bible-verify.nix
index c883cc1..fa8faaf 100644
--- a/bible-verify.nix
+++ b/bible-verify/bible-verify.nix
@@ -2,10 +2,10 @@
 
 craneLib.buildPackage {
   src = pkgs.lib.fileset.toSource {
-    root = ./bible-verify;
+    root = ./.;
     fileset = pkgs.lib.fileset.unions [
-      (craneLib.fileset.commonCargoSources ./bible-verify)
-      (pkgs.lib.fileset.maybeMissing ./bible-verify/kjv.json)
+      (craneLib.fileset.commonCargoSources ./.)
+      (pkgs.lib.fileset.maybeMissing ./kjv.json)
     ];
   };
   pname = "bible-verify";
diff --git a/flake.nix b/flake.nix
index 08eefca..f3c12ac 100644
--- a/flake.nix
+++ b/flake.nix
@@ -48,11 +48,11 @@
 
         cargoArtifacts = craneLib.buildDepsOnly nativeArgs;
 
-        site = import ./site.nix {
+        site = import ./site/site.nix {
           inherit pkgs craneLib rustToolchain;
         };
 
-        bibleVerify = import ./bible-verify.nix {
+        bibleVerify = import ./bible-verify/bible-verify.nix {
           inherit pkgs craneLib;
         };
 
diff --git a/site/.DS_Store b/site/.DS_Store
deleted file mode 100644
index bc15083..0000000
Binary files a/site/.DS_Store and /dev/null differ
diff --git a/site/build.rs b/site/build.rs
index a7bbe1a..cb72589 100644
--- a/site/build.rs
+++ b/site/build.rs
@@ -1,8 +1,8 @@
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env;
 use std::fs;
 use std::path::Path;
-use serde::{Deserialize, Serialize};
 
 // Mirror the structures from the main code
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -22,7 +22,7 @@ impl VerseId {
         let packed = ((book_id as u32) << 24) | ((chapter & 0xFFF) << 12) | (verse & 0xFFF);
         VerseId(packed)
     }
-    
+
     fn from_book_name(book_name: &str, chapter: u32, verse: u32) -> Option<Self> {
         let book_id = book_name_to_id(book_name)?;
         Some(Self::new(book_id, chapter, verse))
@@ -71,7 +71,7 @@ fn book_name_to_id(book_name: &str) -> Option<u8> {
         "Haggai" => Some(37),
         "Zechariah" => Some(38),
         "Malachi" => Some(39),
-        
+
         // New Testament
         "Matthew" => Some(40),
         "Mark" => Some(41),
@@ -100,7 +100,7 @@ fn book_name_to_id(book_name: &str) -> Option<u8> {
         "3 John" => Some(64),
         "Jude" => Some(65),
         "Revelation" => Some(66),
-        
+
         _ => None,
     }
 }
@@ -109,7 +109,7 @@ fn expand_book_abbreviation(abbrev: &str) -> String {
     match abbrev {
         // Old Testament
         "Gen" => "Genesis",
-        "Exod" => "Exodus", 
+        "Exod" => "Exodus",
         "Lev" => "Leviticus",
         "Num" => "Numbers",
         "Deut" => "Deuteronomy",
@@ -147,7 +147,7 @@ fn expand_book_abbreviation(abbrev: &str) -> String {
         "Hag" => "Haggai",
         "Zech" => "Zechariah",
         "Mal" => "Malachi",
-        
+
         // New Testament
         "Matt" => "Matthew",
         "Mark" => "Mark",
@@ -176,25 +176,30 @@ fn expand_book_abbreviation(abbrev: &str) -> String {
         "3John" => "3 John",
         "Jude" => "Jude",
         "Rev" => "Revelation",
-        
+
         // Return as-is if not found
         _ => abbrev,
-    }.to_string()
+    }
+    .to_string()
 }
 
-fn parse_single_verse_reference(verse_ref: &str) -> Result<(String, u32, u32, Option<u32>), String> {
+fn parse_single_verse_reference(
+    verse_ref: &str,
+) -> Result<(String, u32, u32, Option<u32>), String> {
     let parts: Vec<&str> = verse_ref.split('.').collect();
-    
+
     if parts.len() != 3 {
         return Err("Invalid verse reference format".to_string());
     }
-    
+
     let book_name = expand_book_abbreviation(parts[0]);
-    let chapter = parts[1].parse::<u32>()
+    let chapter = parts[1]
+        .parse::<u32>()
         .map_err(|_| "Invalid chapter number".to_string())?;
-    let verse = parts[2].parse::<u32>()
+    let verse = parts[2]
+        .parse::<u32>()
         .map_err(|_| "Invalid verse number".to_string())?;
-    
+
     Ok((book_name, chapter, verse, None))
 }
 
@@ -212,44 +217,47 @@ fn parse_verse_reference(verse_ref: &str) -> Result<(String, u32, u32, Option<u3
 
 fn parse_cross_references(content: &str) -> Result<HashMap<VerseId, Vec<Reference>>, String> {
     let mut references_map = HashMap::new();
-    
+
     let lines = content.lines();
-    
+
     for (line_num, line) in lines.enumerate() {
         // Skip header line
         if line_num == 0 {
             continue;
         }
-        
+
         // Skip empty lines
         if line.trim().is_empty() {
             continue;
         }
-        
+
         // Split by tabs
         let parts: Vec<&str> = line.split('\t').collect();
         if parts.len() != 3 {
             continue; // Skip malformed lines
         }
-        
+
         let from_verse_ref = parts[0].trim();
         let to_verse_ref = parts[1].trim();
         let votes_str = parts[2].trim();
-        
+
         // Parse votes
-        let votes = votes_str.parse::<i32>()
+        let votes = votes_str
+            .parse::<i32>()
             .map_err(|_| "Invalid votes".to_string())?;
-        
+
         // Parse from verse
-        let (from_book, from_chapter, from_verse, _) = parse_single_verse_reference(from_verse_ref)?;
+        let (from_book, from_chapter, from_verse, _) =
+            parse_single_verse_reference(from_verse_ref)?;
         let from_key = match VerseId::from_book_name(&from_book, from_chapter, from_verse) {
             Some(id) => id,
             None => continue, // Skip unknown books
         };
-        
+
         // Parse to verse (can be range)
-        let (to_book, to_chapter, to_verse_start, to_verse_end) = parse_verse_reference(to_verse_ref)?;
-        
+        let (to_book, to_chapter, to_verse_start, to_verse_end) =
+            parse_verse_reference(to_verse_ref)?;
+
         let reference = Reference {
             to_book_name: to_book,
             to_chapter,
@@ -257,54 +265,61 @@ fn parse_cross_references(content: &str) -> Result<HashMap<VerseId, Vec<Referenc
             to_verse_end,
             votes,
         };
-        
+
         // Add to map
         references_map
             .entry(from_key)
             .or_insert_with(Vec::new)
             .push(reference);
     }
-    
+
     Ok(references_map)
 }
 
 fn main() {
     println!("cargo:rerun-if-changed=src/storage/cross_references.txt");
-    
+
     let cross_references_path = "src/storage/cross_references.txt";
-    
+
     // Read the cross-references file
-    let content = fs::read_to_string(cross_references_path)
-        .expect("Failed to read cross_references.txt");
-    
+    let content =
+        fs::read_to_string(cross_references_path).expect("Failed to read cross_references.txt");
+
     // Parse the cross-references
-    let references = parse_cross_references(&content)
-        .expect("Failed to parse cross-references");
-    
+    let references = parse_cross_references(&content).expect("Failed to parse cross-references");
+
     println!("Parsed {} verses with cross-references", references.len());
-    
+
     // Convert to simpler format for binary serialization
     let simplified_map: HashMap<u32, Vec<(String, u32, u32, Option<u32>, i32)>> = references
         .into_iter()
         .map(|(verse_id, refs)| {
-            let simplified_refs = refs.into_iter()
-                .map(|r| (r.to_book_name, r.to_chapter, r.to_verse_start, r.to_verse_end, r.votes))
+            let simplified_refs = refs
+                .into_iter()
+                .map(|r| {
+                    (
+                        r.to_book_name,
+                        r.to_chapter,
+                        r.to_verse_start,
+                        r.to_verse_end,
+                        r.votes,
+                    )
+                })
                 .collect();
             (verse_id.0, simplified_refs)
         })
         .collect();
-    
+
     // Serialize to binary format for faster loading
-    let binary_data = bincode::serialize(&simplified_map)
-        .expect("Failed to serialize cross-references");
-    
+    let binary_data =
+        bincode::serialize(&simplified_map).expect("Failed to serialize cross-references");
+
     // Write binary data to output directory
     let out_dir = env::var("OUT_DIR").unwrap();
     let binary_path = Path::new(&out_dir).join("cross_references.bin");
-    
-    fs::write(&binary_path, &binary_data)
-        .expect("Failed to write cross_references.bin");
-    
+
+    fs::write(&binary_path, &binary_data).expect("Failed to write cross_references.bin");
+
     // Generate simple Rust code that loads the binary at runtime
     let code = r#"// Auto-generated cross-references loader at compile time
 use crate::core::types::{References, Reference, VerseId};
@@ -342,12 +357,14 @@ pub fn get_compiled_cross_references() -> &'static References {
     })
 }
 "#;
-    
+
     // Write the Rust code
     let dest_path = Path::new(&out_dir).join("compiled_cross_references.rs");
-    fs::write(&dest_path, code)
-        .expect("Failed to write compiled_cross_references.rs");
-    
-    println!("Generated compiled cross-references with {} bytes of binary data", binary_data.len());
+    fs::write(&dest_path, code).expect("Failed to write compiled_cross_references.rs");
+
+    println!(
+        "Generated compiled cross-references with {} bytes of binary data",
+        binary_data.len()
+    );
     println!("Generated at: {}", dest_path.display());
-}
\ No newline at end of file
+}
diff --git a/site.nix b/site/site.nix
similarity index 98%
rename from site.nix
rename to site/site.nix
index 1112bec..1d700da 100644
--- a/site.nix
+++ b/site/site.nix
@@ -1,7 +1,7 @@
 { pkgs, craneLib, rustToolchain }:
 
 let
-  unfilteredRoot = ./site;
+  unfilteredRoot = ./.;
   src = pkgs.lib.fileset.toSource {
     root = unfilteredRoot;
     fileset = pkgs.lib.fileset.unions [
diff --git a/site/src/.DS_Store b/site/src/.DS_Store
deleted file mode 100644
index 6f38719..0000000
Binary files a/site/src/.DS_Store and /dev/null differ
diff --git a/site/src/api/bible_api.rs b/site/src/api/bible_api.rs
index 5db1885..bce7749 100644
--- a/site/src/api/bible_api.rs
+++ b/site/src/api/bible_api.rs
@@ -1,7 +1,7 @@
-use crate::core::{Bible, BIBLE, init_bible_signal};
+use crate::core::{init_bible_signal, Bible, BIBLE};
 use crate::storage::translations::get_current_translation;
-use leptos::prelude::Set;
 use gloo_net::http::Request;
+use leptos::prelude::Set;
 use rexie::{ObjectStore, Rexie, TransactionMode};
 
 pub async fn init_bible() -> std::result::Result<(), Box<dyn std::error::Error>> {
@@ -28,8 +28,10 @@ pub async fn init_bible() -> std::result::Result<(), Box<dyn std::error::Error>>
 }
 
 async fn load_or_fetch_bible() -> std::result::Result<Bible, Box<dyn std::error::Error>> {
-    use crate::storage::{get_selected_translation, is_translation_downloaded, load_downloaded_translation};
-    
+    use crate::storage::{
+        get_selected_translation, is_translation_downloaded, load_downloaded_translation,
+    };
+
     if let Some(selected_translation) = get_selected_translation() {
         if is_translation_downloaded(&selected_translation) {
             if let Ok(bible) = load_downloaded_translation(&selected_translation).await {
@@ -208,12 +210,15 @@ pub async fn try_fetch_bible(url: &str) -> std::result::Result<Bible, Box<dyn st
     Ok(bible)
 }
 
-pub async fn try_fetch_bible_with_progress<F>(url: &str, progress_callback: F) -> std::result::Result<Bible, Box<dyn std::error::Error>>
+pub async fn try_fetch_bible_with_progress<F>(
+    url: &str,
+    progress_callback: F,
+) -> std::result::Result<Bible, Box<dyn std::error::Error>>
 where
     F: Fn(f32, String) + Clone + 'static,
 {
     progress_callback(0.3, "Downloading Bible data...".to_string());
-    
+
     let response = Request::get(url).send().await?;
 
     progress_callback(0.6, "Processing response...".to_string());
@@ -232,4 +237,4 @@ where
 
     let bible: Bible = serde_json::from_str(&json_string)?;
     Ok(bible)
-}
\ No newline at end of file
+}
diff --git a/site/src/api/mod.rs b/site/src/api/mod.rs
index 687bec0..61ce2e6 100644
--- a/site/src/api/mod.rs
+++ b/site/src/api/mod.rs
@@ -1,3 +1,3 @@
 pub mod bible_api;
 
-pub use bible_api::*;
\ No newline at end of file
+pub use bible_api::*;
diff --git a/site/src/components/command_palette.rs b/site/src/components/command_palette.rs
index eac96b3..682eccb 100644
--- a/site/src/components/command_palette.rs
+++ b/site/src/components/command_palette.rs
@@ -1,17 +1,17 @@
 use crate::core::{Bible, Chapter, VerseRange};
-use crate::storage::translations::get_current_translation;
-use crate::storage::recent_chapters::get_recent_chapters;
-use crate::translation_map::translation::Translation;
-use crate::instructions::types::Instruction;
 use crate::instructions::processor::InstructionProcessor;
+use crate::instructions::types::Instruction;
 use crate::instructions::vim_keys::KeyboardMappings;
+use crate::storage::recent_chapters::get_recent_chapters;
+use crate::storage::translations::get_current_translation;
+use crate::translation_map::translation::Translation;
 use crate::view_state::ViewStateSignal;
 use leptos::prelude::*;
-use leptos_router::hooks::{use_navigate, use_location};
-use leptos_router::NavigateOptions;
-use wasm_bindgen_futures::spawn_local;
 use leptos::web_sys::KeyboardEvent;
+use leptos_router::hooks::{use_location, use_navigate};
+use leptos_router::NavigateOptions;
 use std::collections::HashMap;
+use wasm_bindgen_futures::spawn_local;
 
 // Removed unused cache - translation is now handled at Bible data level
 
@@ -40,25 +40,38 @@ impl SearchResult {
     pub fn get_display_name(&self) -> String {
         match self {
             SearchResult::Chapter(chapter) => chapter.name.clone(),
-            SearchResult::Verse { chapter, verse_number, .. } => {
+            SearchResult::Verse {
+                chapter,
+                verse_number,
+                ..
+            } => {
                 format!("{} verse {}", chapter.name, verse_number)
             }
             SearchResult::Instruction { name, .. } => name.clone(),
             SearchResult::RecentChapter { display_name, .. } => display_name.clone(),
         }
     }
-    
+
     pub fn to_path(&self) -> String {
         match self {
             SearchResult::Chapter(chapter) => chapter.to_path(),
-            SearchResult::Verse { chapter, verse_number, .. } => {
-                let verse_range = VerseRange { start: *verse_number, end: *verse_number };
+            SearchResult::Verse {
+                chapter,
+                verse_number,
+                ..
+            } => {
+                let verse_range = VerseRange {
+                    start: *verse_number,
+                    end: *verse_number,
+                };
                 let path = chapter.to_path_with_verses(&[verse_range]);
-                
+
                 // Debug log for verse navigation
                 #[cfg(target_arch = "wasm32")]
-                web_sys::console::log_1(&format!("Generating verse path: {} (verse {})", path, verse_number).into());
-                
+                web_sys::console::log_1(
+                    &format!("Generating verse path: {} (verse {})", path, verse_number).into(),
+                );
+
                 path
             }
             SearchResult::Instruction { .. } => {
@@ -80,19 +93,19 @@ struct VerseReference {
 fn parse_verse_reference(query: &str) -> Option<VerseReference> {
     // Handle formats like "gen 1:1", "genesis 1:5", "john 3:16", "mat 5:3-7", and "gen 1:" (incomplete)
     let query = query.trim().to_lowercase();
-    
+
     // Look for colon indicating verse reference
     if let Some(colon_pos) = query.find(':') {
         let before_colon = &query[..colon_pos];
         let after_colon = &query[colon_pos + 1..].trim();
-        
+
         // Split the part before colon into book and chapter
         let parts: Vec<&str> = before_colon.split_whitespace().collect();
         if parts.len() >= 2 {
             // Try to parse the last part as chapter number
             if let Ok(chapter_num) = parts.last().unwrap().parse::<u32>() {
                 let book_name = parts[..parts.len() - 1].join(" ");
-                
+
                 // Handle incomplete verse reference (just "gen 1:")
                 if after_colon.is_empty() {
                     return Some(VerseReference {
@@ -101,7 +114,7 @@ fn parse_verse_reference(query: &str) -> Option<VerseReference> {
                         verse: None, // No specific verse
                     });
                 }
-                
+
                 // Parse verse number (take only the first number if it's a range like "3-7")
                 let verse_str = after_colon.split('-').next().unwrap_or(after_colon);
                 if let Ok(verse_num) = verse_str.parse::<u32>() {
@@ -114,38 +127,37 @@ fn parse_verse_reference(query: &str) -> Option<VerseReference> {
             }
         }
     }
-    
+
     None
 }
 
 fn score_verse_number_match(verse_number: u32, search_number: u32) -> usize {
     let verse_str = verse_number.to_string();
     let search_str = search_number.to_string();
-    
+
     // Exact match gets highest score
     if verse_number == search_number {
         return 1000;
     }
-    
+
     // Check if verse number starts with search number (e.g., 10, 11, 12 when searching for 1)
     if verse_str.starts_with(&search_str) {
         return 800;
     }
-    
+
     // Check if search number starts with verse number (e.g., searching for 10 when verse is 1)
     if search_str.starts_with(&verse_str) {
         return 400;
     }
-    
+
     // Check if verse number contains search number (e.g., 21, 31 when searching for 1)
     if verse_str.contains(&search_str) {
         return 600;
     }
-    
+
     0
 }
 
-
 // Convert vim key notation to user-friendly display
 fn vim_key_to_display(vim_key: &str) -> String {
     match vim_key {
@@ -175,43 +187,133 @@ fn vim_key_to_display(vim_key: &str) -> String {
 // Convert instruction enum name to user-friendly display name and description
 fn instruction_to_display(instruction_name: &str) -> (String, String) {
     match instruction_name {
-        "NextVerse" => ("Next Verse".to_string(), "Navigate to the next verse".to_string()),
-        "PreviousVerse" => ("Previous Verse".to_string(), "Navigate to the previous verse".to_string()),
-        "NextChapter" => ("Next Chapter".to_string(), "Navigate to the next chapter".to_string()),
-        "PreviousChapter" => ("Previous Chapter".to_string(), "Navigate to the previous chapter".to_string()),
-        "NextBook" => ("Next Book".to_string(), "Navigate to the next book".to_string()),
-        "PreviousBook" => ("Previous Book".to_string(), "Navigate to the previous book".to_string()),
-        "BeginningOfChapter" => ("Beginning of Chapter".to_string(), "Go to the first verse of the chapter".to_string()),
-        "EndOfChapter" => ("End of Chapter".to_string(), "Go to the last verse of the chapter".to_string()),
-        "SwitchToPreviousChapter" => ("Switch to Previous Chapter".to_string(), "Go back to the previously viewed chapter".to_string()),
-        "CopyRawVerse" => ("Copy Raw Verse".to_string(), "Copy the verse text to clipboard".to_string()),
-        "CopyVerseWithReference" => ("Copy Verse with Reference".to_string(), "Copy verse with reference to clipboard".to_string()),
-        "ToggleSidebar" => ("Toggle Sidebar".to_string(), "Show/hide the books sidebar".to_string()),
-        "ToggleCrossReferences" => ("Toggle Cross References".to_string(), "Show/hide cross-references panel".to_string()),
-        "ToggleBiblePallate" => ("Toggle Command Palette".to_string(), "Toggle this command palette".to_string()),
-        "ToggleCommandPallate" => ("Open Command Palette".to_string(), "Open command palette with shortcuts".to_string()),
-        "NextReference" => ("Next Reference".to_string(), "Navigate to next cross-reference".to_string()),
-        "PreviousReference" => ("Previous Reference".to_string(), "Navigate to previous cross-reference".to_string()),
-        "NextPaletteResult" => ("Next Palette Result".to_string(), "Navigate to next search result".to_string()),
-        "PreviousPaletteResult" => ("Previous Palette Result".to_string(), "Navigate to previous search result".to_string()),
-        "OpenGithubRepository" => ("Open GitHub Repository".to_string(), "Open the project repository on GitHub".to_string()),
-        "RandomVerse" => ("Random Verse".to_string(), "Navigate to a random verse in the Bible".to_string()),
-        "RandomChapter" => ("Random Chapter".to_string(), "Navigate to a random chapter in the Bible".to_string()),
-        "OpenAboutPage" => ("About".to_string(), "View information about this Bible website".to_string()),
-        "ShowTranslations" => ("Show Translations".to_string(), "Go to the translation selection page".to_string()),
-        "ToggleVersePallate" => ("Open Verse Palette".to_string(), "Open command palette for verse navigation".to_string()),
-        "ExportToPDF" => ("Export to PDF".to_string(), "Export the entire Bible as a PDF document".to_string()),
-        "ExportToMarkdown" => ("Export to Markdown".to_string(), "Export the entire Bible as a Markdown document".to_string()),
-        "ExportLinkedMarkdown" => ("Export to Linked Markdown (Obsidian)".to_string(), "Export the entire Bible as linked Markdown files for Obsidian".to_string()),
-        "ToggleTranslationComparison" => ("Compare Translations".to_string(), "Open translation comparison panel for current verse".to_string()),
-        _ => (instruction_name.to_string(), format!("Execute {}", instruction_name)),
+        "NextVerse" => (
+            "Next Verse".to_string(),
+            "Navigate to the next verse".to_string(),
+        ),
+        "PreviousVerse" => (
+            "Previous Verse".to_string(),
+            "Navigate to the previous verse".to_string(),
+        ),
+        "NextChapter" => (
+            "Next Chapter".to_string(),
+            "Navigate to the next chapter".to_string(),
+        ),
+        "PreviousChapter" => (
+            "Previous Chapter".to_string(),
+            "Navigate to the previous chapter".to_string(),
+        ),
+        "NextBook" => (
+            "Next Book".to_string(),
+            "Navigate to the next book".to_string(),
+        ),
+        "PreviousBook" => (
+            "Previous Book".to_string(),
+            "Navigate to the previous book".to_string(),
+        ),
+        "BeginningOfChapter" => (
+            "Beginning of Chapter".to_string(),
+            "Go to the first verse of the chapter".to_string(),
+        ),
+        "EndOfChapter" => (
+            "End of Chapter".to_string(),
+            "Go to the last verse of the chapter".to_string(),
+        ),
+        "SwitchToPreviousChapter" => (
+            "Switch to Previous Chapter".to_string(),
+            "Go back to the previously viewed chapter".to_string(),
+        ),
+        "CopyRawVerse" => (
+            "Copy Raw Verse".to_string(),
+            "Copy the verse text to clipboard".to_string(),
+        ),
+        "CopyVerseWithReference" => (
+            "Copy Verse with Reference".to_string(),
+            "Copy verse with reference to clipboard".to_string(),
+        ),
+        "ToggleSidebar" => (
+            "Toggle Sidebar".to_string(),
+            "Show/hide the books sidebar".to_string(),
+        ),
+        "ToggleCrossReferences" => (
+            "Toggle Cross References".to_string(),
+            "Show/hide cross-references panel".to_string(),
+        ),
+        "ToggleBiblePallate" => (
+            "Toggle Command Palette".to_string(),
+            "Toggle this command palette".to_string(),
+        ),
+        "ToggleCommandPallate" => (
+            "Open Command Palette".to_string(),
+            "Open command palette with shortcuts".to_string(),
+        ),
+        "NextReference" => (
+            "Next Reference".to_string(),
+            "Navigate to next cross-reference".to_string(),
+        ),
+        "PreviousReference" => (
+            "Previous Reference".to_string(),
+            "Navigate to previous cross-reference".to_string(),
+        ),
+        "NextPaletteResult" => (
+            "Next Palette Result".to_string(),
+            "Navigate to next search result".to_string(),
+        ),
+        "PreviousPaletteResult" => (
+            "Previous Palette Result".to_string(),
+            "Navigate to previous search result".to_string(),
+        ),
+        "OpenGithubRepository" => (
+            "Open GitHub Repository".to_string(),
+            "Open the project repository on GitHub".to_string(),
+        ),
+        "RandomVerse" => (
+            "Random Verse".to_string(),
+            "Navigate to a random verse in the Bible".to_string(),
+        ),
+        "RandomChapter" => (
+            "Random Chapter".to_string(),
+            "Navigate to a random chapter in the Bible".to_string(),
+        ),
+        "OpenAboutPage" => (
+            "About".to_string(),
+            "View information about this Bible website".to_string(),
+        ),
+        "ShowTranslations" => (
+            "Show Translations".to_string(),
+            "Go to the translation selection page".to_string(),
+        ),
+        "ToggleVersePallate" => (
+            "Open Verse Palette".to_string(),
+            "Open command palette for verse navigation".to_string(),
+        ),
+        "ExportToPDF" => (
+            "Export to PDF".to_string(),
+            "Export the entire Bible as a PDF document".to_string(),
+        ),
+        "ExportToMarkdown" => (
+            "Export to Markdown".to_string(),
+            "Export the entire Bible as a Markdown document".to_string(),
+        ),
+        "ExportLinkedMarkdown" => (
+            "Export to Linked Markdown (Obsidian)".to_string(),
+            "Export the entire Bible as linked Markdown files for Obsidian".to_string(),
+        ),
+        "ToggleTranslationComparison" => (
+            "Compare Translations".to_string(),
+            "Open translation comparison panel for current verse".to_string(),
+        ),
+        _ => (
+            instruction_name.to_string(),
+            format!("Execute {}", instruction_name),
+        ),
     }
 }
 
 fn get_all_instructions() -> Vec<SearchResult> {
     let mappings = KeyboardMappings::load();
     let mut instruction_shortcuts: HashMap<String, Vec<String>> = HashMap::new();
-    
+
     // Group all shortcuts by instruction
     for (vim_key, instruction_name) in &mappings.mappings {
         let display_key = vim_key_to_display(vim_key);
@@ -220,30 +322,53 @@ fn get_all_instructions() -> Vec<SearchResult> {
             .or_insert_with(Vec::new)
             .push(display_key);
     }
-    
+
     // Add any instructions that might not have shortcuts yet (for future extensibility)
     let all_possible_instructions = [
-        "NextVerse", "PreviousVerse", "NextChapter", "PreviousChapter",
-        "NextBook", "PreviousBook", "BeginningOfChapter", "EndOfChapter",
-        "SwitchToPreviousChapter", "CopyRawVerse", "CopyVerseWithReference",
-        "ToggleSidebar", "ToggleCrossReferences", "ToggleBiblePallate", "ToggleCommandPallate",
-        "NextReference", "PreviousReference", "NextPaletteResult", "PreviousPaletteResult",
-        "OpenGithubRepository", "RandomVerse", "RandomChapter", "OpenAboutPage", "ShowTranslations", "ToggleVersePallate", "ToggleTranslationComparison", "ExportToPDF", "ExportToMarkdown", "ExportLinkedMarkdown"
+        "NextVerse",
+        "PreviousVerse",
+        "NextChapter",
+        "PreviousChapter",
+        "NextBook",
+        "PreviousBook",
+        "BeginningOfChapter",
+        "EndOfChapter",
+        "SwitchToPreviousChapter",
+        "CopyRawVerse",
+        "CopyVerseWithReference",
+        "ToggleSidebar",
+        "ToggleCrossReferences",
+        "ToggleBiblePallate",
+        "ToggleCommandPallate",
+        "NextReference",
+        "PreviousReference",
+        "NextPaletteResult",
+        "PreviousPaletteResult",
+        "OpenGithubRepository",
+        "RandomVerse",
+        "RandomChapter",
+        "OpenAboutPage",
+        "ShowTranslations",
+        "ToggleVersePallate",
+        "ToggleTranslationComparison",
+        "ExportToPDF",
+        "ExportToMarkdown",
+        "ExportLinkedMarkdown",
     ];
-    
+
     for instruction in &all_possible_instructions {
         if !instruction_shortcuts.contains_key(*instruction) {
             instruction_shortcuts.insert(instruction.to_string(), vec!["No shortcut".to_string()]);
         }
     }
-    
+
     // Create SearchResult for each unique instruction
     instruction_shortcuts
         .into_iter()
         .map(|(instruction_name, shortcuts)| {
             let (display_name, description) = instruction_to_display(&instruction_name);
             let shortcut_text = shortcuts.join(", ");
-            
+
             SearchResult::Instruction {
                 name: display_name,
                 description,
@@ -256,7 +381,10 @@ fn get_all_instructions() -> Vec<SearchResult> {
 // Removed redundant get_translated_chapter_name function - names are already translated
 
 fn get_current_chapter_from_bible(bible: &Bible, location_pathname: &str) -> Option<Chapter> {
-    let path_parts: Vec<&str> = location_pathname.trim_start_matches('/').split('/').collect();
+    let path_parts: Vec<&str> = location_pathname
+        .trim_start_matches('/')
+        .split('/')
+        .collect();
     if path_parts.len() == 2 {
         let book_name = path_parts[0].replace('_', " ");
         if let Ok(chapter_num) = path_parts[1].parse::<u32>() {
@@ -335,12 +463,10 @@ fn instruction_name_to_instruction(name: &str) -> Option<Instruction> {
 }
 
 #[component]
-pub fn CommandPalette(
-    view_state: crate::view_state::ViewStateSignal,
-) -> impl IntoView {
+pub fn CommandPalette(view_state: crate::view_state::ViewStateSignal) -> impl IntoView {
     let navigate = use_navigate();
     let location = use_location();
-    
+
     // Separate signals for input display vs actual search query (for debouncing)
     let (input_value, set_input_value) = signal(String::new());
     let (search_query, set_search_query) = signal(String::new());
@@ -348,26 +474,26 @@ pub fn CommandPalette(
     let (navigate_to, set_navigate_to) = signal::<Option<String>>(None);
     let (is_mounted, set_is_mounted) = signal(false);
     let (execute_instruction, set_execute_instruction) = signal::<Option<Instruction>>(None);
-    
+
     // Debouncing effect: update search_query 150ms after input_value stops changing
     Effect::new(move |_| {
         let input_val = input_value.get();
         let set_search_query_clone = set_search_query.clone();
-        
+
         spawn_local(async move {
             // Wait 150ms before updating search query
             gloo_timers::future::TimeoutFuture::new(150).await;
-            
+
             // Only update if the input value hasn't changed in the meantime
             if input_val == input_value.get_untracked() {
                 set_search_query_clone.set(input_val);
             }
         });
     });
-    
+
     // Create a node ref for the input element
     let input_ref = NodeRef::<leptos::html::Input>::new();
-    
+
     // Create instruction processor
     let processor = InstructionProcessor::new(navigate.clone());
 
@@ -377,26 +503,32 @@ pub fn CommandPalette(
             let pathname = location.pathname.get();
             let search = location.search.get();
             if update_view_state_from_url(view_state, &pathname, &search) {
-                let handled = view_state.with(|state| {
-                    processor.process(instruction.clone(), state)
-                });
-                
+                let handled =
+                    view_state.with(|state| processor.process(instruction.clone(), state));
+
                 if !handled {
                     use web_sys::CustomEvent;
-                    
+
                     // Handle export instructions that need special processing
-                    if matches!(instruction, 
-                        crate::instructions::Instruction::ExportToPDF | 
-                        crate::instructions::Instruction::ExportToMarkdown |
-                        crate::instructions::Instruction::ExportLinkedMarkdown
+                    if matches!(
+                        instruction,
+                        crate::instructions::Instruction::ExportToPDF
+                            | crate::instructions::Instruction::ExportToMarkdown
+                            | crate::instructions::Instruction::ExportLinkedMarkdown
                     ) {
                         if let Some(window) = web_sys::window() {
                             if let Some(document) = window.document() {
                                 // Create custom event with instruction data
                                 let event_name = match instruction {
-                                    crate::instructions::Instruction::ExportToPDF => "palette-pdf-export",
-                                    crate::instructions::Instruction::ExportToMarkdown => "palette-markdown-export",
-                                    crate::instructions::Instruction::ExportLinkedMarkdown => "palette-linked-markdown-export",
+                                    crate::instructions::Instruction::ExportToPDF => {
+                                        "palette-pdf-export"
+                                    }
+                                    crate::instructions::Instruction::ExportToMarkdown => {
+                                        "palette-markdown-export"
+                                    }
+                                    crate::instructions::Instruction::ExportLinkedMarkdown => {
+                                        "palette-linked-markdown-export"
+                                    }
                                     _ => "palette-instruction",
                                 };
                                 if let Ok(event) = CustomEvent::new(event_name) {
@@ -415,7 +547,7 @@ pub fn CommandPalette(
     Effect::new(move |_| {
         if let Some(query) = view_state.with(|state| state.initial_search_query.clone()) {
             set_input_value.set(query); // Set input_value to show in field, debouncing will handle search_query
-            // The signal will be cleared by the parent component
+                                        // The signal will be cleared by the parent component
         }
     });
 
@@ -425,11 +557,12 @@ pub fn CommandPalette(
         if query.is_empty() || query.starts_with(':') || query.starts_with('>') || query.len() < 3 {
             return false;
         }
-        
+
         // Check if there would be any chapter results
         if let Some(bible) = view_state.with(|state| state.get_bible().cloned()) {
             for book in &bible.books {
-                for chapter in book.chapters.iter().take(5) { // Quick check of first few chapters
+                for chapter in book.chapters.iter().take(5) {
+                    // Quick check of first few chapters
                     let original_name = chapter.name.to_lowercase();
                     if fuzzy_score(&original_name, &query.to_lowercase()) > 0 {
                         return false; // Found chapter results, not global search
@@ -446,16 +579,20 @@ pub fn CommandPalette(
         if query.is_empty() {
             // Show recent chapters when empty
             let recent_chapters = get_recent_chapters();
-            return recent_chapters.into_iter()
+            return recent_chapters
+                .into_iter()
                 .enumerate()
                 .map(|(index, recent)| {
                     let score = 1000 - index; // Higher score for more recent
-                    (SearchResult::RecentChapter {
-                        book_name: recent.book_name,
-                        chapter: recent.chapter,
-                        display_name: recent.display_name,
-                        path: recent.path,
-                    }, score)
+                    (
+                        SearchResult::RecentChapter {
+                            book_name: recent.book_name,
+                            chapter: recent.chapter,
+                            display_name: recent.display_name,
+                            path: recent.path,
+                        },
+                        score,
+                    )
                 })
                 .collect();
         }
@@ -464,19 +601,29 @@ pub fn CommandPalette(
         if query.starts_with('>') {
             let instruction_query = query.strip_prefix('>').unwrap_or("").to_lowercase();
             let instructions = get_all_instructions();
-            
+
             if instruction_query.is_empty() {
                 // Just ">" - show all instructions
                 return instructions.into_iter().map(|inst| (inst, 1000)).collect();
             } else {
                 // Filter instructions by name or description
-                return instructions.into_iter()
+                return instructions
+                    .into_iter()
                     .filter_map(|inst| {
-                        if let SearchResult::Instruction { name, description, .. } = &inst {
+                        if let SearchResult::Instruction {
+                            name, description, ..
+                        } = &inst
+                        {
                             let name_lower = name.to_lowercase();
                             let desc_lower = description.to_lowercase();
-                            if name_lower.contains(&instruction_query) || desc_lower.contains(&instruction_query) {
-                                let score = if name_lower.starts_with(&instruction_query) { 1000 } else { 500 };
+                            if name_lower.contains(&instruction_query)
+                                || desc_lower.contains(&instruction_query)
+                            {
+                                let score = if name_lower.starts_with(&instruction_query) {
+                                    1000
+                                } else {
+                                    500
+                                };
                                 Some((inst, score))
                             } else {
                                 None
@@ -491,11 +638,11 @@ pub fn CommandPalette(
 
         let query = query.to_lowercase();
         let mut results: Vec<(SearchResult, usize)> = Vec::new();
-        
+
         // Check if this is a current chapter verse shortcut (e.g., ":5" or ":")
         if let Some(verse_part) = query.strip_prefix(':') {
-            if let Some(current_chapter) = get_current_chapter(view_state, &location.pathname.get()) {
-                
+            if let Some(current_chapter) = get_current_chapter(view_state, &location.pathname.get())
+            {
                 if verse_part.is_empty() {
                     // Just ":" - show all verses from current chapter (limited to first 15)
                     for verse in current_chapter.verses.iter().take(15) {
@@ -505,22 +652,24 @@ pub fn CommandPalette(
                                 verse_number: verse.verse,
                                 verse_text: verse.text.clone(),
                             },
-                            1000 // High score for current chapter verses
+                            1000, // High score for current chapter verses
                         ));
                     }
                 } else if let Ok(verse_num) = verse_part.parse::<u32>() {
                     // ":5" - jump to specific verse in current chapter
-                    if let Some(verse) = current_chapter.verses.iter().find(|v| v.verse == verse_num) {
+                    if let Some(verse) =
+                        current_chapter.verses.iter().find(|v| v.verse == verse_num)
+                    {
                         results.push((
                             SearchResult::Verse {
                                 chapter: current_chapter.clone(),
                                 verse_number: verse.verse,
                                 verse_text: verse.text.clone(),
                             },
-                            2000 // Very high score for exact verse match
+                            2000, // Very high score for exact verse match
                         ));
                     }
-                    
+
                     // Also show nearby verses for context
                     for verse in &current_chapter.verses {
                         let score = score_verse_number_match(verse.verse, verse_num);
@@ -531,7 +680,7 @@ pub fn CommandPalette(
                                     verse_number: verse.verse,
                                     verse_text: verse.text.clone(),
                                 },
-                                score + 500 // Bonus for being in current chapter
+                                score + 500, // Bonus for being in current chapter
                             ));
                         }
                     }
@@ -544,41 +693,54 @@ pub fn CommandPalette(
             if let Some(translation) = get_current_translation() {
                 if let Some(first_language) = translation.languages.first() {
                     let translation_obj = Translation::from_language(*first_language);
-                    
+
                     // Try to translate the book name
-                    let book_name_to_search = if let Some(translated) = translation_obj.get(&verse_ref.book_name) {
-                        translated
-                    } else {
-                        verse_ref.book_name.clone()
-                    };
-                    
+                    let book_name_to_search =
+                        if let Some(translated) = translation_obj.get(&verse_ref.book_name) {
+                            translated
+                        } else {
+                            verse_ref.book_name.clone()
+                        };
+
                     // Find the chapter - optimize by searching more efficiently
                     let bible = match view_state.with(|state| state.get_bible().cloned()) {
                         Some(bible) => bible,
                         None => return Vec::new(), // No Bible data available
                     };
                     let mut found_chapter = None;
-                    
+
                     // First try exact book name match
                     for book in &bible.books {
-                        if book.name.to_lowercase() == book_name_to_search.to_lowercase() 
-                            || book.name.to_lowercase() == verse_ref.book_name.to_lowercase() {
-                            found_chapter = book.chapters.iter().find(|c| c.chapter == verse_ref.chapter);
+                        if book.name.to_lowercase() == book_name_to_search.to_lowercase()
+                            || book.name.to_lowercase() == verse_ref.book_name.to_lowercase()
+                        {
+                            found_chapter = book
+                                .chapters
+                                .iter()
+                                .find(|c| c.chapter == verse_ref.chapter);
                             break;
                         }
                     }
-                    
+
                     // If no exact match, try partial match (but limit to avoid full scan)
                     if found_chapter.is_none() {
-                        for book in bible.books.iter().take(20) { // Limit search to first 20 books
-                            if book.name.to_lowercase().contains(&book_name_to_search.to_lowercase()) 
-                                || book.name.to_lowercase().contains(&verse_ref.book_name) {
-                                found_chapter = book.chapters.iter().find(|c| c.chapter == verse_ref.chapter);
+                        for book in bible.books.iter().take(20) {
+                            // Limit search to first 20 books
+                            if book
+                                .name
+                                .to_lowercase()
+                                .contains(&book_name_to_search.to_lowercase())
+                                || book.name.to_lowercase().contains(&verse_ref.book_name)
+                            {
+                                found_chapter = book
+                                    .chapters
+                                    .iter()
+                                    .find(|c| c.chapter == verse_ref.chapter);
                                 break;
                             }
                         }
                     }
-                    
+
                     if let Some(chapter) = found_chapter {
                         match verse_ref.verse {
                             Some(verse_num) => {
@@ -592,7 +754,7 @@ pub fn CommandPalette(
                                                 verse_number: verse.verse,
                                                 verse_text: verse.text.clone(),
                                             },
-                                            score
+                                            score,
                                         ));
                                     }
                                 }
@@ -606,7 +768,7 @@ pub fn CommandPalette(
                                             verse_number: verse.verse,
                                             verse_text: verse.text.clone(),
                                         },
-                                        900 // High score for chapter verse suggestions
+                                        900, // High score for chapter verse suggestions
                                     ));
                                 }
                             }
@@ -615,96 +777,103 @@ pub fn CommandPalette(
                 }
             }
         }
-        
+
         // Optimized chapter search - limit scope and avoid expensive operations for short queries
         let mut chapter_results: Vec<(SearchResult, usize)> = Vec::new();
-        
+
         // Only do expensive chapter search if query is at least 2 characters
         if query.len() >= 2 {
             if let Some(bible) = view_state.with(|state| state.get_bible().cloned()) {
                 let mut found_count = 0;
                 'outer: for book in &bible.books {
-                for chapter in &book.chapters {
-                    // Early exit if we have enough results
-                    if found_count >= 20 {
-                        break 'outer;
-                    }
-                    
-                    let original_name = chapter.name.to_lowercase();
-                    let original_score = fuzzy_score(&original_name, &query);
-                    
-                    // Only compute expensive translation if original name doesn't match well
-                    let score = if original_score > 0 {
-                        original_score
-                    } else {
-                        let translated_name = chapter.name.to_lowercase();
-                        fuzzy_score(&translated_name, &query)
-                    };
-                    
-                    if score > 0 {
-                        chapter_results.push((SearchResult::Chapter(chapter.clone()), score));
-                        found_count += 1;
+                    for chapter in &book.chapters {
+                        // Early exit if we have enough results
+                        if found_count >= 20 {
+                            break 'outer;
+                        }
+
+                        let original_name = chapter.name.to_lowercase();
+                        let original_score = fuzzy_score(&original_name, &query);
+
+                        // Only compute expensive translation if original name doesn't match well
+                        let score = if original_score > 0 {
+                            original_score
+                        } else {
+                            let translated_name = chapter.name.to_lowercase();
+                            fuzzy_score(&translated_name, &query)
+                        };
+
+                        if score > 0 {
+                            chapter_results.push((SearchResult::Chapter(chapter.clone()), score));
+                            found_count += 1;
+                        }
                     }
                 }
             }
         }
-        }
-            
+
         results.extend(chapter_results);
 
         // If no results and query is at least 3 characters, do global Bible search
-        if results.is_empty() && query.len() >= 3 && !query.starts_with(':') && !query.starts_with('>') {
+        if results.is_empty()
+            && query.len() >= 3
+            && !query.starts_with(':')
+            && !query.starts_with('>')
+        {
             let mut verse_matches: Vec<(SearchResult, usize)> = Vec::new();
             let mut search_count = 0;
-            
+
             // Normalize query once outside the loop for performance
             let query_normalized = normalize_text_for_search(&query);
-            
+
             if let Some(bible) = view_state.with(|state| state.get_bible().cloned()) {
                 'global_search: for book in &bible.books {
-                for chapter in &book.chapters {
-                    for verse in &chapter.verses {
-                        // Early exit if we have enough results
-                        if search_count >= 50 {
-                            break 'global_search;
-                        }
-                        
-                        // Normalize verse text for search (no cache needed for real-time search)
-                        let verse_text_normalized = normalize_text_for_search(&verse.text);
-                        if verse_text_normalized.contains(&query_normalized) {
-                            // Score based on how early the match appears in the verse
-                            let match_position = verse_text_normalized.find(&query_normalized).unwrap_or(verse_text_normalized.len());
-                            let score = if verse_text_normalized.starts_with(&query_normalized) {
-                                1000 // Starts with query
-                            } else if match_position < 10 {
-                                800 // Match near beginning
-                            } else if match_position < 30 {
-                                600 // Match in first part
-                            } else {
-                                400 // Match later in verse
-                            };
-                            
-                            verse_matches.push((
-                                SearchResult::Verse {
-                                    chapter: chapter.clone(),
-                                    verse_number: verse.verse,
-                                    verse_text: verse.text.clone(),
-                                },
-                                score
-                            ));
-                            search_count += 1;
+                    for chapter in &book.chapters {
+                        for verse in &chapter.verses {
+                            // Early exit if we have enough results
+                            if search_count >= 50 {
+                                break 'global_search;
+                            }
+
+                            // Normalize verse text for search (no cache needed for real-time search)
+                            let verse_text_normalized = normalize_text_for_search(&verse.text);
+                            if verse_text_normalized.contains(&query_normalized) {
+                                // Score based on how early the match appears in the verse
+                                let match_position = verse_text_normalized
+                                    .find(&query_normalized)
+                                    .unwrap_or(verse_text_normalized.len());
+                                let score = if verse_text_normalized.starts_with(&query_normalized)
+                                {
+                                    1000 // Starts with query
+                                } else if match_position < 10 {
+                                    800 // Match near beginning
+                                } else if match_position < 30 {
+                                    600 // Match in first part
+                                } else {
+                                    400 // Match later in verse
+                                };
+
+                                verse_matches.push((
+                                    SearchResult::Verse {
+                                        chapter: chapter.clone(),
+                                        verse_number: verse.verse,
+                                        verse_text: verse.text.clone(),
+                                    },
+                                    score,
+                                ));
+                                search_count += 1;
+                            }
                         }
                     }
                 }
-                }
             }
-            
+
             results.extend(verse_matches);
         }
 
         // Sort by score (higher is better)
         results.sort_by(|a, b| b.1.cmp(&a.1));
-        
+
         results
             .into_iter()
             .take(10)
@@ -714,7 +883,9 @@ pub fn CommandPalette(
     // Handle NextPaletteResult navigation signal
     Effect::new(move |_| {
         if view_state.with(|state| state.next_palette_result_trigger) {
-            view_state.update(|state| { state.execute(&Instruction::NextPaletteResult); }); // This handles the trigger reset
+            view_state.update(|state| {
+                state.execute(&Instruction::NextPaletteResult);
+            }); // This handles the trigger reset
             let results = filtered_results.get();
             if !results.is_empty() {
                 let current = selected_index.get();
@@ -724,7 +895,7 @@ pub fn CommandPalette(
                     current + 1
                 };
                 set_selected_index.set(next);
-                
+
                 // Keep focus on input field for continued typing
                 // VoiceOver will use aria-activedescendant to announce the selected result
             }
@@ -734,7 +905,9 @@ pub fn CommandPalette(
     // Handle PreviousPaletteResult navigation signal
     Effect::new(move |_| {
         if view_state.with(|state| state.previous_palette_result_trigger) {
-            view_state.update(|state| { state.execute(&Instruction::PreviousPaletteResult); }); // This handles the trigger reset
+            view_state.update(|state| {
+                state.execute(&Instruction::PreviousPaletteResult);
+            }); // This handles the trigger reset
             let results = filtered_results.get();
             if !results.is_empty() {
                 let current = selected_index.get();
@@ -744,7 +917,7 @@ pub fn CommandPalette(
                     current - 1
                 };
                 set_selected_index.set(next);
-                
+
                 // Keep focus on input field for continued typing
                 // VoiceOver will use aria-activedescendant to announce the selected result
             }
@@ -755,16 +928,18 @@ pub fn CommandPalette(
     Effect::new(move |_| {
         let current_index = selected_index.get();
         let results = filtered_results.get();
-        
+
         // Only scroll if we have results and palette is open
         if !results.is_empty() && view_state.with(|state| state.is_command_palette_open) {
             // Use a timeout to ensure the DOM has been updated
             spawn_local(async move {
                 gloo_timers::future::TimeoutFuture::new(10).await;
-                
+
                 if let Some(window) = leptos::web_sys::window() {
                     if let Some(document) = window.document() {
-                        if let Some(element) = document.get_element_by_id(&format!("palette-result-{}", current_index)) {
+                        if let Some(element) =
+                            document.get_element_by_id(&format!("palette-result-{}", current_index))
+                        {
                             // Use scrollIntoView with 'nearest' block behavior to avoid aggressive scrolling
                             element.scroll_into_view_with_bool(false); // false = use 'nearest' instead of 'start'
                         }
@@ -782,7 +957,9 @@ pub fn CommandPalette(
             let handle_keydown = move |e: KeyboardEvent| {
                 match e.key().as_str() {
                     "Escape" => {
-                        view_state.update(|state| { state.execute(&Instruction::CloseCommandPalette); });
+                        view_state.update(|state| {
+                            state.execute(&Instruction::CloseCommandPalette);
+                        });
                         set_search_query.set(String::new());
                         set_selected_index.set(0);
                     }
@@ -800,21 +977,27 @@ pub fn CommandPalette(
                                 match result {
                                     SearchResult::Instruction { name, .. } => {
                                         // Execute the instruction
-                                        if let Some(instruction) = instruction_name_to_instruction(name) {
+                                        if let Some(instruction) =
+                                            instruction_name_to_instruction(name)
+                                        {
                                             set_execute_instruction.set(Some(instruction));
                                         }
                                         // Close the palette
-                                        view_state.update(|state| { state.execute(&Instruction::CloseCommandPalette); });
+                                        view_state.update(|state| {
+                                            state.execute(&Instruction::CloseCommandPalette);
+                                        });
                                         set_search_query.set(String::new());
                                         set_selected_index.set(0);
                                     }
                                     _ => {
                                         // For chapters and verses, navigate
                                         set_navigate_to.set(Some(result.to_path()));
-                                        
+
                                         // Close palette immediately
-                                        view_state.update(|state| { state.execute(&Instruction::CloseCommandPalette); });
-                                        
+                                        view_state.update(|state| {
+                                            state.execute(&Instruction::CloseCommandPalette);
+                                        });
+
                                         // Reset search state after a small delay to avoid race conditions
                                         spawn_local(async move {
                                             gloo_timers::future::TimeoutFuture::new(50).await;
@@ -829,7 +1012,7 @@ pub fn CommandPalette(
                     _ => {}
                 }
             };
-            
+
             let cleanup = window_event_listener(leptos::ev::keydown, handle_keydown);
             on_cleanup(move || {
                 // Explicitly clean up when palette closes
@@ -843,7 +1026,7 @@ pub fn CommandPalette(
         search_query.track();
         set_selected_index.set(0);
     });
-    
+
     // Reset selected index when palette opens
     Effect::new(move |_| {
         if view_state.with(|state| state.is_command_palette_open) {
@@ -858,13 +1041,16 @@ pub fn CommandPalette(
             // Debug log to track navigation
             #[cfg(target_arch = "wasm32")]
             web_sys::console::log_1(&format!("Command palette navigating to: {}", path).into());
-            
+
             // Force navigation by using replace: false to ensure verse parameters are handled
-            navigate(&path, NavigateOptions { 
-                scroll: false, 
-                replace: false,
-                ..Default::default() 
-            });
+            navigate(
+                &path,
+                NavigateOptions {
+                    scroll: false,
+                    replace: false,
+                    ..Default::default()
+                },
+            );
             set_navigate_to.set(None);
         }
     });
@@ -879,17 +1065,15 @@ pub fn CommandPalette(
         }
     });
 
-
-
     view! {
         <Show when=move || is_mounted.get() && view_state.with(|state| state.is_command_palette_open) fallback=|| ()>
             // Backdrop
-            <div 
+            <div
                 class="fixed inset-0 bg-black bg-opacity-50 z-[9999] flex items-start justify-center pt-20"
                 on:click=move |_| view_state.update(|state| { state.execute(&Instruction::CloseCommandPalette); })
             >
                 // Command Palette Modal
-                <div 
+                <div
                     class="rounded-lg shadow-xl w-full max-w-lg mx-4 max-h-96 flex flex-col"
                     style="background-color: var(--theme-palette-background); border: 1px solid var(--theme-palette-border)"
                     on:click=move |e| e.stop_propagation()
@@ -937,8 +1121,8 @@ pub fn CommandPalette(
                                         </div>
                                     </div>
                                 </Show>
-                                
-                                <div 
+
+                                <div
                                     id="palette-results-listbox"
                                     class="max-h-64 overflow-y-auto"
                                     role="listbox"
@@ -947,24 +1131,24 @@ pub fn CommandPalette(
                                     {move || {
                                         let results = filtered_results.get();
                                         let current_selected = selected_index.get();
-                                        let bounded_selected = if results.is_empty() { 
-                                            0 
-                                        } else { 
-                                            current_selected.min(results.len() - 1) 
+                                        let bounded_selected = if results.is_empty() {
+                                            0
+                                        } else {
+                                            current_selected.min(results.len() - 1)
                                         };
-                                        
+
                                         results.into_iter().enumerate().map(|(index, (result, _score))| {
                                             let is_selected = index == bounded_selected;
                                             let result_path = result.to_path();
                                             let display_name = result.get_display_name();
-                                            
+
                                             view! {
-                                                <div 
+                                                <div
                                                     id=format!("palette-result-{}", index)
-                                                    class=if is_selected { 
-                                                        "px-4 py-3 cursor-pointer flex items-center border-b palette-result-selected" 
-                                                    } else { 
-                                                        "px-4 py-3 cursor-pointer flex items-center border-b palette-result-item" 
+                                                    class=if is_selected {
+                                                        "px-4 py-3 cursor-pointer flex items-center border-b palette-result-selected"
+                                                    } else {
+                                                        "px-4 py-3 cursor-pointer flex items-center border-b palette-result-item"
                                                     }
                                                     style=if is_selected {
                                                         "background-color: var(--theme-palette-highlight-background); color: var(--theme-palette-highlight); border-color: var(--theme-palette-highlight)"
@@ -976,11 +1160,11 @@ pub fn CommandPalette(
                                                     aria-label={
                                                         match &result {
                                                             SearchResult::Verse { verse_text, .. } => {
-                                                                format!("{}, verse text: {}", display_name, 
-                                                                    if verse_text.len() > 100 { 
-                                                                        format!("{}...", &verse_text[..100]) 
-                                                                    } else { 
-                                                                        verse_text.clone() 
+                                                                format!("{}, verse text: {}", display_name,
+                                                                    if verse_text.len() > 100 {
+                                                                        format!("{}...", &verse_text[..100])
+                                                                    } else {
+                                                                        verse_text.clone()
                                                                     }
                                                                 )
                                                             }
@@ -1011,10 +1195,10 @@ pub fn CommandPalette(
                                                                 _ => {
                                                                     // Navigate for chapters and verses
                                                                     set_navigate_to.set(Some(path.clone()));
-                                                                    
-                                                                    // Close palette and reset state immediately  
+
+                                                                    // Close palette and reset state immediately
                                                                     view_state.update(|state| { state.execute(&Instruction::CloseCommandPalette); });
-                                                                    
+
                                                                     // Reset search state after a small delay to avoid race conditions
                                                                     spawn_local(async move {
                                                                         gloo_timers::future::TimeoutFuture::new(50).await;
@@ -1121,7 +1305,8 @@ fn normalize_text_for_search(text: &str) -> String {
             'Ç' => 'C',
             'Ñ' => 'N',
             // Remove punctuation characters - replace with space to maintain word boundaries
-            ',' | '.' | ';' | ':' | '!' | '?' | '"' | '\'' | '(' | ')' | '[' | ']' | '-' | '—' | '–' | '/' | '\\' | '«' | '»' => ' ',
+            ',' | '.' | ';' | ':' | '!' | '?' | '"' | '\'' | '(' | ')' | '[' | ']' | '-' | '—'
+            | '–' | '/' | '\\' | '«' | '»' => ' ',
             // Keep other characters as-is
             _ => c,
         })
@@ -1157,17 +1342,17 @@ fn fuzzy_score(text: &str, query: &str) -> usize {
     if query.is_empty() {
         return 0;
     }
-    
+
     // Normalize both text and query for better matching
     let text_normalized = normalize_text_for_search(text);
     let query_normalized = normalize_text_for_search(query);
-    
+
     // Try with number/roman numeral conversions
     let text_arabic_to_roman = convert_arabic_to_roman(&text_normalized);
     let text_roman_to_arabic = convert_roman_to_arabic(&text_normalized);
     let query_arabic_to_roman = convert_arabic_to_roman(&query_normalized);
     let query_roman_to_arabic = convert_roman_to_arabic(&query_normalized);
-    
+
     // Calculate scores for all combinations
     let score1 = calculate_fuzzy_score(&text_normalized, &query_normalized);
     let score2 = calculate_fuzzy_score(&text_arabic_to_roman, &query_normalized);
@@ -1176,56 +1361,63 @@ fn fuzzy_score(text: &str, query: &str) -> usize {
     let score5 = calculate_fuzzy_score(&text_normalized, &query_roman_to_arabic);
     let score6 = calculate_fuzzy_score(&text_arabic_to_roman, &query_roman_to_arabic);
     let score7 = calculate_fuzzy_score(&text_roman_to_arabic, &query_arabic_to_roman);
-    
+
     // Return the best score
-    score1.max(score2).max(score3).max(score4).max(score5).max(score6).max(score7)
+    score1
+        .max(score2)
+        .max(score3)
+        .max(score4)
+        .max(score5)
+        .max(score6)
+        .max(score7)
 }
 
 fn calculate_fuzzy_score(text: &str, query: &str) -> usize {
     if query.is_empty() {
         return 0;
     }
-    
+
     let text_words: Vec<&str> = text.split_whitespace().collect();
     let query_words: Vec<&str> = query.split_whitespace().collect();
-    
+
     if query_words.is_empty() {
         return 0;
     }
-    
+
     let mut total_score = 0;
-    
+
     // Try to match each query word against text words
     for (query_word_index, &query_word) in query_words.iter().enumerate() {
         let mut best_word_score = 0;
         let mut found_match = false;
-        
+
         // Check each text word for the best match
         for (text_word_index, &text_word) in text_words.iter().enumerate() {
-            let word_score = score_word_match(text_word, query_word, text_word_index == query_word_index);
+            let word_score =
+                score_word_match(text_word, query_word, text_word_index == query_word_index);
             if word_score > best_word_score {
                 best_word_score = word_score;
                 found_match = true;
             }
         }
-        
+
         if !found_match {
             return 0; // Query word not found
         }
-        
+
         total_score += best_word_score;
     }
-    
+
     // Bonus for matching all words in order
     if query_words.len() == text_words.len() {
         total_score += 50;
     }
-    
+
     // Bonus for exact text match
     if text == query {
         total_score += 100;
     }
-    
+
     total_score
 }
 
@@ -1235,27 +1427,27 @@ fn score_word_match(text_word: &str, query_word: &str, is_positional_match: bool
     if text_word == query_word {
         return if is_positional_match { 100 } else { 80 };
     }
-    
+
     // Check if text word starts with query word (partial match)
     if text_word.starts_with(query_word) {
         let match_ratio = (query_word.len() * 100) / text_word.len();
-        return if is_positional_match { 
-            50 + match_ratio / 2 
-        } else { 
-            30 + match_ratio / 2 
+        return if is_positional_match {
+            50 + match_ratio / 2
+        } else {
+            30 + match_ratio / 2
         };
     }
-    
+
     // Check if query word is contained in text word
     if text_word.contains(query_word) {
         let match_ratio = (query_word.len() * 100) / text_word.len();
-        return if is_positional_match { 
-            20 + match_ratio / 4 
-        } else { 
-            10 + match_ratio / 4 
+        return if is_positional_match {
+            20 + match_ratio / 4
+        } else {
+            10 + match_ratio / 4
         };
     }
-    
+
     // Check for number matching (both are numbers)
     if let (Ok(_), Ok(_)) = (text_word.parse::<u32>(), query_word.parse::<u32>()) {
         if text_word == query_word {
@@ -1266,7 +1458,7 @@ fn score_word_match(text_word: &str, query_word: &str, is_positional_match: bool
             return if is_positional_match { 60 } else { 40 };
         }
     }
-    
+
     // Character-by-character fuzzy matching as fallback
     character_fuzzy_score(text_word, query_word, is_positional_match)
 }
@@ -1275,14 +1467,14 @@ fn score_word_match(text_word: &str, query_word: &str, is_positional_match: bool
 fn character_fuzzy_score(text: &str, query: &str, is_positional_match: bool) -> usize {
     let text_chars: Vec<char> = text.chars().collect();
     let query_chars: Vec<char> = query.chars().collect();
-    
+
     let mut score = 0;
     let mut text_index = 0;
     let mut consecutive_matches = 0;
-    
+
     for &query_char in &query_chars {
         let mut found = false;
-        
+
         while text_index < text_chars.len() {
             if text_chars[text_index] == query_char {
                 found = true;
@@ -1295,17 +1487,17 @@ fn character_fuzzy_score(text: &str, query: &str, is_positional_match: bool) ->
                 text_index += 1;
             }
         }
-        
+
         if !found {
             return 0; // Query character not found
         }
     }
-    
+
     // Apply positional bonus
     if is_positional_match {
         score = score * 3 / 2;
     }
-    
+
     score
 }
 
@@ -1317,10 +1509,10 @@ mod tests {
     fn test_normalize_text_for_search() {
         // Test Dutch character normalization
         assert_eq!(normalize_text_for_search("Matteüs"), "matteus");
-        assert_eq!(normalize_text_for_search("Jesaja"), "jesaja");  
+        assert_eq!(normalize_text_for_search("Jesaja"), "jesaja");
         assert_eq!(normalize_text_for_search("Ezechiël"), "ezechiel");
         assert_eq!(normalize_text_for_search("Daniël"), "daniel");
-        
+
         // Test mixed case
         assert_eq!(normalize_text_for_search("MATTEÜS"), "matteus");
         assert_eq!(normalize_text_for_search("Matteüs"), "matteus");
@@ -1332,7 +1524,7 @@ mod tests {
         assert_eq!(convert_arabic_to_roman("1 samuel"), "i samuel");
         assert_eq!(convert_arabic_to_roman("2 samuel"), "ii samuel");
         assert_eq!(convert_arabic_to_roman("3 john"), "iii john");
-        
+
         // Test no change for non-numbered books
         assert_eq!(convert_arabic_to_roman("genesis"), "genesis");
         assert_eq!(convert_arabic_to_roman("matthew"), "matthew");
@@ -1340,11 +1532,11 @@ mod tests {
 
     #[test]
     fn test_convert_roman_to_arabic() {
-        // Test Roman to Arabic conversion  
+        // Test Roman to Arabic conversion
         assert_eq!(convert_roman_to_arabic("I samuel"), "1 samuel");
         assert_eq!(convert_roman_to_arabic("II samuel"), "2 samuel");
         assert_eq!(convert_roman_to_arabic("III john"), "3 john");
-        
+
         // Test no change for non-numbered books
         assert_eq!(convert_roman_to_arabic("genesis"), "genesis");
         assert_eq!(convert_roman_to_arabic("matthew"), "matthew");
@@ -1355,13 +1547,13 @@ mod tests {
         // Test that Dutch characters match their normalized equivalents
         let score1 = fuzzy_score("Matteüs", "matteus");
         assert!(score1 > 0, "Should match Dutch characters");
-        
+
         // Test number/roman conversion in search
         let score2 = fuzzy_score("I Samuel", "1 samuel");
         let score3 = fuzzy_score("II Samuel", "2 samuel");
         assert!(score2 > 0, "Should match 1 samuel with I Samuel");
         assert!(score3 > 0, "Should match 2 samuel with II Samuel");
-        
+
         // Test the reverse direction too
         let score4 = fuzzy_score("1 Samuel", "i samuel");
         let score5 = fuzzy_score("2 Samuel", "ii samuel");
@@ -1406,7 +1598,7 @@ mod tests {
         assert_eq!(result.book_name, "gen");
         assert_eq!(result.chapter, 1);
         assert_eq!(result.verse, None); // No specific verse
-        
+
         // Test incomplete with spaces "john 3: "
         let result = parse_verse_reference("john 3: ").unwrap();
         assert_eq!(result.book_name, "john");
@@ -1425,26 +1617,26 @@ mod tests {
         // Test exact match
         assert_eq!(score_verse_number_match(1, 1), 1000);
         assert_eq!(score_verse_number_match(16, 16), 1000);
-        
+
         // Test starts with (1 matches 10, 11, 12)
         assert_eq!(score_verse_number_match(10, 1), 800);
         assert_eq!(score_verse_number_match(11, 1), 800);
         assert_eq!(score_verse_number_match(12, 1), 800);
         assert_eq!(score_verse_number_match(100, 1), 800);
-        
+
         // Test contains (1 matches 21, 31, but not 151 since that starts with 1)
         assert_eq!(score_verse_number_match(21, 1), 600);
         assert_eq!(score_verse_number_match(31, 1), 600);
         assert_eq!(score_verse_number_match(151, 1), 800); // This starts with 1, so gets higher score
-        
+
         // Test reverse starts with (10 matches 1)
         assert_eq!(score_verse_number_match(1, 10), 400);
         assert_eq!(score_verse_number_match(2, 23), 400);
-        
+
         // Test no match
         assert_eq!(score_verse_number_match(2, 3), 0);
         assert_eq!(score_verse_number_match(25, 6), 0);
-        
+
         // Test priorities (exact > starts_with > contains > reverse_starts_with)
         assert!(score_verse_number_match(1, 1) > score_verse_number_match(10, 1));
         assert!(score_verse_number_match(10, 1) > score_verse_number_match(21, 1));
@@ -1456,7 +1648,7 @@ mod tests {
     #[test]
     fn test_search_result_to_path() {
         use crate::core::Chapter;
-        
+
         let chapter = Chapter {
             chapter: 1,
             name: "Genesis 1".to_string(),
@@ -1482,10 +1674,10 @@ mod tests {
         // Test fuzzy search functionality with translated names
         let score = fuzzy_score("numeri 1", "numeri");
         assert!(score > 0, "Should match 'numeri' in 'numeri 1'");
-        
+
         let score2 = fuzzy_score("numeri 1", "numeri 1");
         assert!(score2 > 0, "Should match exact 'numeri 1'");
-        
+
         let score3 = fuzzy_score("numbers 1", "numeri");
         assert_eq!(score3, 0, "Should not match 'numeri' in 'numbers 1'");
     }
@@ -1500,31 +1692,56 @@ mod tests {
     fn test_partial_word_matching() {
         // "ps 9" should match "psalmen 9"
         let score = fuzzy_score("psalmen 9", "ps 9");
-        assert!(score > 0, "ps 9 should match psalmen 9, got score: {}", score);
-        
+        assert!(
+            score > 0,
+            "ps 9 should match psalmen 9, got score: {}",
+            score
+        );
+
         // "gen 3" should match "genesis 3"
         let score = fuzzy_score("genesis 3", "gen 3");
-        assert!(score > 0, "gen 3 should match genesis 3, got score: {}", score);
-        
+        assert!(
+            score > 0,
+            "gen 3 should match genesis 3, got score: {}",
+            score
+        );
+
         // "john 14" should match "johannes 14"
         let score = fuzzy_score("johannes 14", "john 14");
-        assert!(score > 0, "john 14 should match johannes 14, got score: {}", score);
+        assert!(
+            score > 0,
+            "john 14 should match johannes 14, got score: {}",
+            score
+        );
     }
 
     #[test]
     fn test_number_matching() {
         // "ps 90" should match "psalmen 90"
         let score = fuzzy_score("psalmen 90", "ps 90");
-        assert!(score > 0, "ps 90 should match psalmen 90, got score: {}", score);
-        
+        assert!(
+            score > 0,
+            "ps 90 should match psalmen 90, got score: {}",
+            score
+        );
+
         // "9" should match "90" (partial number)
         let score = fuzzy_score("psalmen 90", "ps 9");
-        assert!(score > 0, "ps 9 should partially match psalmen 90, got score: {}", score);
-        
+        assert!(
+            score > 0,
+            "ps 9 should partially match psalmen 90, got score: {}",
+            score
+        );
+
         // Exact number match should score higher than partial
         let exact_score = fuzzy_score("psalmen 9", "ps 9");
         let partial_score = fuzzy_score("psalmen 90", "ps 9");
-        assert!(exact_score > partial_score, "Exact number match should score higher: {} vs {}", exact_score, partial_score);
+        assert!(
+            exact_score > partial_score,
+            "Exact number match should score higher: {} vs {}",
+            exact_score,
+            partial_score
+        );
     }
 
     #[test]
@@ -1536,12 +1753,25 @@ mod tests {
             ("psalmen 19", fuzzy_score("psalmen 19", "ps 9")),
             ("psalm 9", fuzzy_score("psalm 9", "ps 9")),
         ];
-        
+
         // psalmen 9 should score highest (exact number match)
-        let psalmen_9_score = results.iter().find(|(name, _)| *name == "psalmen 9").unwrap().1;
-        let psalmen_90_score = results.iter().find(|(name, _)| *name == "psalmen 90").unwrap().1;
-        
-        assert!(psalmen_9_score > psalmen_90_score, "Exact number match should score higher than partial: {} vs {}", psalmen_9_score, psalmen_90_score);
+        let psalmen_9_score = results
+            .iter()
+            .find(|(name, _)| *name == "psalmen 9")
+            .unwrap()
+            .1;
+        let psalmen_90_score = results
+            .iter()
+            .find(|(name, _)| *name == "psalmen 90")
+            .unwrap()
+            .1;
+
+        assert!(
+            psalmen_9_score > psalmen_90_score,
+            "Exact number match should score higher than partial: {} vs {}",
+            psalmen_9_score,
+            psalmen_90_score
+        );
     }
 
     #[test]
@@ -1559,8 +1789,11 @@ mod tests {
         let score1 = fuzzy_score("Genesis 1", "gen 1");
         let score2 = fuzzy_score("genesis 1", "GEN 1");
         let score3 = fuzzy_score("GENESIS 1", "gen 1");
-        
-        assert!(score1 > 0 && score2 > 0 && score3 > 0, "Should handle mixed case");
+
+        assert!(
+            score1 > 0 && score2 > 0 && score3 > 0,
+            "Should handle mixed case"
+        );
     }
 
     #[test]
@@ -1568,8 +1801,13 @@ mod tests {
         // Words in correct order should score higher
         let correct_order = fuzzy_score("genesis 3", "gen 3");
         let wrong_order = fuzzy_score("3 genesis", "gen 3");
-        
-        assert!(correct_order > wrong_order, "Correct word order should score higher: {} vs {}", correct_order, wrong_order);
+
+        assert!(
+            correct_order > wrong_order,
+            "Correct word order should score higher: {} vs {}",
+            correct_order,
+            wrong_order
+        );
     }
 
     #[test]
@@ -1577,8 +1815,13 @@ mod tests {
         // Word that starts with query should score higher than contains
         let starts_with_score = fuzzy_score("genesis 1", "gen");
         let contains_score = fuzzy_score("regeneration 1", "gen");
-        
-        assert!(starts_with_score > contains_score, "Starts-with should score higher than contains: {} vs {}", starts_with_score, contains_score);
+
+        assert!(
+            starts_with_score > contains_score,
+            "Starts-with should score higher than contains: {} vs {}",
+            starts_with_score,
+            contains_score
+        );
     }
 
     #[test]
@@ -1586,42 +1829,53 @@ mod tests {
         // Test the main use case: searching for "ps 9"
         let test_chapters = vec![
             "psalmen 9",
-            "psalmen 90", 
+            "psalmen 90",
             "psalmen 19",
             "psalm 9",
             "spreuken 9",
             "genesis 9",
         ];
-        
+
         let mut scored_results: Vec<(&str, usize)> = test_chapters
             .iter()
             .map(|&chapter| (chapter, fuzzy_score(chapter, "ps 9")))
             .filter(|(_, score)| *score > 0)
             .collect();
-        
+
         scored_results.sort_by(|a, b| b.1.cmp(&a.1));
-        
+
         // Should have results and prioritize exact number matches
         assert!(!scored_results.is_empty(), "Should find matches for 'ps 9'");
-        
+
         // Both "psalm 9" and "psalmen 9" should be in top results
-        let top_two: Vec<&str> = scored_results.iter().take(2).map(|(name, _)| *name).collect();
-        assert!(top_two.contains(&"psalm 9") || top_two.contains(&"psalmen 9"), 
-                "Top results should include psalm variants, got: {:?}", scored_results);
-        
+        let top_two: Vec<&str> = scored_results
+            .iter()
+            .take(2)
+            .map(|(name, _)| *name)
+            .collect();
+        assert!(
+            top_two.contains(&"psalm 9") || top_two.contains(&"psalmen 9"),
+            "Top results should include psalm variants, got: {:?}",
+            scored_results
+        );
+
         // Should find multiple relevant results
         let psalm_matches: Vec<&str> = scored_results
             .iter()
             .map(|(name, _)| *name)
             .filter(|name| name.starts_with("psalm"))
             .collect();
-        
-        assert!(psalm_matches.len() >= 2, "Should find multiple psalm matches: {:?}", psalm_matches);
+
+        assert!(
+            psalm_matches.len() >= 2,
+            "Should find multiple psalm matches: {:?}",
+            psalm_matches
+        );
     }
-    
+
     // Property tests using proptest
     use proptest::prelude::*;
-    
+
     proptest! {
         #[test]
         fn test_fuzzy_score_properties(
@@ -1630,30 +1884,30 @@ mod tests {
         ) {
             let text = text.trim();
             let query = query.trim();
-            
+
             if text.is_empty() || query.is_empty() {
                 return Ok(());
             }
-            
+
             let score = fuzzy_score(text, query);
-            
+
             // Basic properties
-            
+
             // Exact match should always score higher than partial match
             if text.to_lowercase() == query.to_lowercase() {
                 prop_assert!(score > 0);
             }
-            
+
             // Empty query should return 0 score
             prop_assert_eq!(fuzzy_score(text, ""), 0);
-            
+
             // Query longer than text should still work
             if query.len() > text.len() {
                 let _long_query_score = fuzzy_score(text, query);
                 // Query longer than text should still work
             }
         }
-        
+
         #[test]
         fn test_fuzzy_score_monotonicity(
             text in "[a-zA-Z0-9 ]{3,30}",
@@ -1661,19 +1915,19 @@ mod tests {
         ) {
             let text = text.trim();
             let query_base = query_base.trim();
-            
+
             if text.is_empty() || query_base.is_empty() {
                 return Ok(());
             }
-            
+
             // Longer, more specific queries should generally score higher if they match
             let _short_query_score = fuzzy_score(text, query_base);
             let long_query = format!("{} {}", query_base, query_base);
             let _long_query_score = fuzzy_score(text, &long_query);
-            
+
             // If both queries match, the relationship depends on the content
         }
-        
+
         #[test]
         fn test_score_word_match_properties(
             text_word in "[a-zA-Z0-9]{1,20}",
@@ -1681,28 +1935,28 @@ mod tests {
         ) {
             let text_word = text_word.trim();
             let query_word = query_word.trim();
-            
+
             if text_word.is_empty() || query_word.is_empty() {
                 return Ok(());
             }
-            
+
             let positional_score = score_word_match(text_word, query_word, true);
             let non_positional_score = score_word_match(text_word, query_word, false);
-            
+
             // Basic properties
-            
+
             // Positional matches should score higher than non-positional
             if positional_score > 0 && non_positional_score > 0 {
                 prop_assert!(positional_score >= non_positional_score);
             }
-            
+
             // Exact match should always score higher
             if text_word.to_lowercase() == query_word.to_lowercase() {
                 prop_assert!(positional_score > 0);
                 prop_assert!(non_positional_score > 0);
             }
         }
-        
+
         #[test]
         fn test_character_fuzzy_score_properties(
             text in "[a-zA-Z0-9]{1,30}",
@@ -1710,24 +1964,24 @@ mod tests {
         ) {
             let text = text.trim();
             let query = query.trim();
-            
+
             if text.is_empty() || query.is_empty() {
                 return Ok(());
             }
-            
+
             let positional_score = character_fuzzy_score(text, query, true);
             let non_positional_score = character_fuzzy_score(text, query, false);
-            
+
             // Basic properties
-            
+
             // Positional should score higher than non-positional when both match
             if positional_score > 0 && non_positional_score > 0 {
                 prop_assert!(positional_score >= non_positional_score);
             }
-            
+
             // If query is longer than text, it might still partially match
         }
-        
+
         #[test]
         fn test_fuzzy_score_case_insensitive(
             text in "[a-zA-Z ]{3,20}",
@@ -1735,24 +1989,24 @@ mod tests {
         ) {
             let text = text.trim();
             let query = query.trim();
-            
+
             if text.is_empty() || query.is_empty() {
                 return Ok(());
             }
-            
+
             let lower_score = fuzzy_score(&text.to_lowercase(), &query.to_lowercase());
             let upper_score = fuzzy_score(&text.to_uppercase(), &query.to_uppercase());
             let mixed_score = fuzzy_score(text, &query.to_lowercase());
-            
+
             // Case should not significantly affect scoring
-            
+
             // All should produce similar results (allowing for some variance)
             if lower_score > 0 {
                 prop_assert!(upper_score > 0);
                 prop_assert!(mixed_score > 0);
             }
         }
-        
+
         #[test]
         fn test_number_matching_properties(
             base_num in 1u32..999,
@@ -1760,21 +2014,21 @@ mod tests {
         ) {
             let text = format!("Book {}", base_num);
             let query = format!("Book {}", query_num);
-            
+
             let score = fuzzy_score(&text, &query);
-            
+
             // Should get some score for book name match (at least partial match on "Book")
-            
+
             // Test that "Book" prefix always matches
             let book_prefix_score = fuzzy_score(&text, "Book");
             prop_assert!(book_prefix_score > 0);
-            
+
             // Exact number match should score higher than book prefix alone
             if base_num == query_num {
                 let exact_score = score;
                 prop_assert!(exact_score > book_prefix_score);
             }
-            
+
             // Test partial number matching
             let base_str = base_num.to_string();
             let query_str = query_num.to_string();
@@ -1783,7 +2037,7 @@ mod tests {
                 prop_assert!(partial_num_score > 0);
             }
         }
-        
+
         #[test]
         fn test_word_order_sensitivity_property(
             word1 in "[a-zA-Z]{2,10}",
@@ -1793,20 +2047,20 @@ mod tests {
             let word1 = word1.trim();
             let word2 = word2.trim();
             let word3 = word3.trim();
-            
+
             if word1.is_empty() || word2.is_empty() || word3.is_empty() {
                 return Ok(());
             }
-            
+
             let correct_order = format!("{} {} {}", word1, word2, word3);
             let wrong_order = format!("{} {} {}", word3, word1, word2);
             let query = format!("{} {}", word1, word2);
-            
+
             let correct_score = fuzzy_score(&correct_order, &query);
             let wrong_score = fuzzy_score(&wrong_order, &query);
-            
+
             // Both should match since the words are present
-            
+
             // Correct order should typically score higher
             if correct_score > 0 && wrong_score > 0 {
                 // This is a tendency, not a strict rule due to fuzzy matching
@@ -1814,7 +2068,7 @@ mod tests {
                 prop_assert!(wrong_score > 0);
             }
         }
-        
+
         #[test]
         fn test_prefix_matching_advantage(
             prefix in "[a-zA-Z]{2,8}",
@@ -1822,21 +2076,21 @@ mod tests {
         ) {
             let prefix = prefix.trim();
             let suffix = suffix.trim();
-            
+
             if prefix.is_empty() || suffix.is_empty() {
                 return Ok(());
             }
-            
+
             let prefix_text = format!("{}{}", prefix, suffix);
             let contains_text = format!("xyz{}abc", prefix);
-            
+
             let prefix_score = fuzzy_score(&prefix_text, prefix);
             let contains_score = fuzzy_score(&contains_text, prefix);
-            
+
             // Both should match
             prop_assert!(prefix_score > 0);
             prop_assert!(contains_score > 0);
-            
+
             // Prefix match should score higher than contains match
             prop_assert!(prefix_score > contains_score);
         }
diff --git a/site/src/components/cross_references_sidebar.rs b/site/src/components/cross_references_sidebar.rs
index d89e983..64abba6 100644
--- a/site/src/components/cross_references_sidebar.rs
+++ b/site/src/components/cross_references_sidebar.rs
@@ -1,26 +1,28 @@
-use crate::core::{load_cross_references};
-use crate::core::types::{References, Reference, VerseId};
+use crate::core::load_cross_references;
+use crate::core::types::Language;
+use crate::core::types::{Reference, References, VerseId};
 use crate::instructions::types::Instruction;
 use crate::storage::translations::get_current_translation;
-use crate::core::types::Language;
 use crate::translation_map::translation::Translation;
 use crate::utils::is_mobile_screen;
 use crate::view_state::ViewStateSignal;
+use leptos::ev;
 use leptos::prelude::*;
+use leptos::wasm_bindgen::JsCast;
+use leptos::web_sys::KeyboardEvent;
 use leptos_router::hooks::use_navigate;
 use leptos_router::NavigateOptions;
-use urlencoding::encode;
 use std::sync::OnceLock;
-use leptos::ev;
-use leptos::web_sys::KeyboardEvent;
-use leptos::wasm_bindgen::JsCast;
+use urlencoding::encode;
 
 // Global cross-references cache (already optimized with your compile-time system)
 static CROSS_REFERENCES: OnceLock<References> = OnceLock::new();
 
 fn get_cross_references() -> &'static References {
     CROSS_REFERENCES.get_or_init(|| {
-        web_sys::console::log_1(&"Loading cross-references data for first time (panel opened)".into());
+        web_sys::console::log_1(
+            &"Loading cross-references data for first time (panel opened)".into(),
+        );
         load_cross_references().unwrap_or_else(|_| References(std::collections::HashMap::new()))
     })
 }
@@ -47,12 +49,12 @@ fn get_canonical_book_name(display_name: &str) -> String {
         "I John" => "1 John".to_string(),
         "II John" => "2 John".to_string(),
         "III John" => "3 John".to_string(),
-        
+
         // Alternative book names to canonical English names
         "Revelation of John" => "Revelation".to_string(),
         "The Revelation" => "Revelation".to_string(),
         "The Revelation of John" => "Revelation".to_string(),
-        
+
         // Dutch translations back to English
         "I Samuël" => "1 Samuel".to_string(),
         "II Samuël" => "2 Samuel".to_string(),
@@ -75,7 +77,7 @@ fn get_canonical_book_name(display_name: &str) -> String {
         "Haggaï" => "Haggai".to_string(),
         "Zacharia" => "Zechariah".to_string(),
         "Maleachi" => "Malachi".to_string(),
-        
+
         // New Testament Dutch translations
         "Matteüs" => "Matthew".to_string(),
         "Marcus" => "Mark".to_string(),
@@ -105,14 +107,12 @@ fn get_canonical_book_name(display_name: &str) -> String {
         "Judas" => "Jude".to_string(),
         "Openbaring" => "Revelation".to_string(),
         "Openbaringen" => "Revelation".to_string(),
-        
+
         // If no translation found, return as-is (might already be English)
         _ => display_name.to_string(),
     }
 }
 
-
-
 fn get_ui_text(key: &str) -> String {
     if let Some(current_translation) = get_current_translation() {
         if let Some(first_language) = current_translation.languages.first() {
@@ -143,27 +143,33 @@ fn get_translated_book_name(book_name: &str) -> String {
     if let Some(current_translation) = get_current_translation() {
         if let Some(first_language) = current_translation.languages.first() {
             let translation = Translation::from_language(*first_language);
-            
+
             // Convert book name to lowercase and replace spaces with underscores for lookup
             let lookup_key = book_name.to_lowercase().replace(' ', "_");
-            
+
             if let Some(translated_name) = translation.get(&lookup_key) {
                 return translated_name;
             }
         }
     }
-    
+
     // Return original book name if no translation found
     book_name.to_string()
 }
 
 fn format_reference_text(reference: &Reference) -> String {
     let translated_book = get_translated_book_name(&reference.to_book_name);
-    
+
     if let Some(end_verse) = reference.to_verse_end {
-        format!("{} {}:{}-{}", translated_book, reference.to_chapter, reference.to_verse_start, end_verse)
+        format!(
+            "{} {}:{}-{}",
+            translated_book, reference.to_chapter, reference.to_verse_start, end_verse
+        )
     } else {
-        format!("{} {}:{}", translated_book, reference.to_chapter, reference.to_verse_start)
+        format!(
+            "{} {}:{}",
+            translated_book, reference.to_chapter, reference.to_verse_start
+        )
     }
 }
 
@@ -171,14 +177,17 @@ fn reference_to_url(reference: &Reference) -> String {
     // Convert canonical book name back to display book name used in the Bible
     let display_book_name = get_display_book_name(&reference.to_book_name);
     let encoded_book = encode(&display_book_name);
-    
+
     // Ensure chapter and verse are valid positive numbers
     let chapter = reference.to_chapter.max(1);
     let verse_start = reference.to_verse_start.max(1);
-    
+
     if let Some(end_verse) = reference.to_verse_end {
         let verse_end = end_verse.max(verse_start);
-        format!("/{}/{}?verses={}-{}", encoded_book, chapter, verse_start, verse_end)
+        format!(
+            "/{}/{}?verses={}-{}",
+            encoded_book, chapter, verse_start, verse_end
+        )
     } else {
         format!("/{}/{}?verses={}", encoded_book, chapter, verse_start)
     }
@@ -186,28 +195,39 @@ fn reference_to_url(reference: &Reference) -> String {
 
 fn get_verse_content_for_reference(reference: &Reference) -> String {
     use crate::core::get_bible;
-    
+
     // Safe verse content retrieval with error handling
     match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
         // Convert canonical book name (Arabic numerals) to display format (Roman numerals)
         // that the Bible data uses. E.g., "1 Samuel" -> "I Samuel"
         let bible_book_name = get_display_book_name(&reference.to_book_name);
-        
+
         // Try to get the verse content for the reference
         if let Ok(bible) = get_bible().get_chapter(&bible_book_name, reference.to_chapter) {
-            if let Some(verse) = bible.verses.iter().find(|v| v.verse == reference.to_verse_start) {
+            if let Some(verse) = bible
+                .verses
+                .iter()
+                .find(|v| v.verse == reference.to_verse_start)
+            {
                 return verse.text.to_string(); // More explicit than clone for strings
             }
         }
-        
+
         // Fallback if verse content not found
         "Verse content not available".to_string()
     })) {
         Ok(content) => content,
         Err(_) => {
-            web_sys::console::warn_1(&format!("Failed to get verse content for {} {}:{} (converted to {})", 
-                reference.to_book_name, reference.to_chapter, reference.to_verse_start, 
-                get_display_book_name(&reference.to_book_name)).into());
+            web_sys::console::warn_1(
+                &format!(
+                    "Failed to get verse content for {} {}:{} (converted to {})",
+                    reference.to_book_name,
+                    reference.to_chapter,
+                    reference.to_verse_start,
+                    get_display_book_name(&reference.to_book_name)
+                )
+                .into(),
+            );
             "Verse content unavailable".to_string()
         }
     }
@@ -246,7 +266,7 @@ fn get_display_book_name(canonical_name: &str) -> String {
         "1 John" => "I John".to_string(),
         "2 John" => "II John".to_string(),
         "3 John" => "III John".to_string(),
-        
+
         // For all other books, return the canonical name as-is
         _ => canonical_name.to_string(),
     }
@@ -264,28 +284,39 @@ pub fn CrossReferencesSidebar(
     let (is_navigating, set_is_navigating) = signal(false);
     let (_sidebar_has_focus, set_sidebar_has_focus) = signal(false);
     let navigate = use_navigate();
-    
+
     // Use a simple Arc<AtomicBool> for disposal tracking that doesn't rely on reactive system
     use std::sync::atomic::{AtomicBool, Ordering};
     use std::sync::Arc;
     let is_disposed = Arc::new(AtomicBool::new(false));
-    
-    // Convert display book name (e.g. "I Samuël") to canonical English name (e.g. "1 Samuel") 
+
+    // Convert display book name (e.g. "I Samuël") to canonical English name (e.g. "1 Samuel")
     // for cross-reference lookup
     let canonical_book_name = get_canonical_book_name(&book_name);
-    
+
     // Debug logging to track the conversion and lookup process
-    web_sys::console::log_1(&format!("Cross-reference lookup: '{}' -> '{}' {}:{}", 
-        book_name, canonical_book_name, chapter, verse).into());
-    
+    web_sys::console::log_1(
+        &format!(
+            "Cross-reference lookup: '{}' -> '{}' {}:{}",
+            book_name, canonical_book_name, chapter, verse
+        )
+        .into(),
+    );
+
     // Create the optimized verse ID for lookup (now used only for validation)
     let _verse_id = match VerseId::from_book_name(&canonical_book_name, chapter, verse) {
         Some(id) => {
             web_sys::console::log_1(&format!("VerseId created successfully: {:?}", id).into());
             id
-        },
+        }
         None => {
-            web_sys::console::log_1(&format!("Failed to create VerseId for book: '{}'", canonical_book_name).into());
+            web_sys::console::log_1(
+                &format!(
+                    "Failed to create VerseId for book: '{}'",
+                    canonical_book_name
+                )
+                .into(),
+            );
             // Unknown book - show no references
             return view! {
                 <div class="cross-references-sidebar">
@@ -302,11 +333,16 @@ pub fn CrossReferencesSidebar(
             };
         }
     };
-    
+
     // Debug logging for the chapter-based approach
-    web_sys::console::log_1(&format!("Loading references for entire chapter: {} {}", 
-        canonical_book_name, chapter).into());
-    
+    web_sys::console::log_1(
+        &format!(
+            "Loading references for entire chapter: {} {}",
+            canonical_book_name, chapter
+        )
+        .into(),
+    );
+
     // Load all references for the current chapter at once (performance optimization)
     // This memo only recalculates when book_name or chapter changes, NOT when verse changes
     // NOTE: References are only loaded when this component is actually rendered (panel is open)
@@ -314,16 +350,24 @@ pub fn CrossReferencesSidebar(
         let canonical_book_name = canonical_book_name.clone();
         move |_| {
             let mut chapter_refs = std::collections::HashMap::new();
-            
+
             // Only load references if the panel is actually open (this component exists)
             let references = get_cross_references();
-            
-            web_sys::console::log_1(&format!("Pre-loading references for chapter: {} {} (panel open)", 
-                canonical_book_name, chapter).into());
-            
+
+            web_sys::console::log_1(
+                &format!(
+                    "Pre-loading references for chapter: {} {} (panel open)",
+                    canonical_book_name, chapter
+                )
+                .into(),
+            );
+
             // Load all verses in the chapter at once to prevent per-verse lookups during fast scrolling
-            for verse_num in 1..=200 { // Conservative upper bound for verses in a chapter
-                if let Some(verse_id) = VerseId::from_book_name(&canonical_book_name, chapter, verse_num) {
+            for verse_num in 1..=200 {
+                // Conservative upper bound for verses in a chapter
+                if let Some(verse_id) =
+                    VerseId::from_book_name(&canonical_book_name, chapter, verse_num)
+                {
                     if let Some(refs) = references.0.get(&verse_id) {
                         // Sort in-place without cloning the entire vector
                         let mut sorted = refs.to_vec(); // More explicit than clone
@@ -332,14 +376,21 @@ pub fn CrossReferencesSidebar(
                     }
                 }
             }
-            
-            web_sys::console::log_1(&format!("Pre-loaded references for {} verses in chapter {} {} (panel open)", 
-                chapter_refs.len(), canonical_book_name, chapter).into());
-            
+
+            web_sys::console::log_1(
+                &format!(
+                    "Pre-loaded references for {} verses in chapter {} {} (panel open)",
+                    chapter_refs.len(),
+                    canonical_book_name,
+                    chapter
+                )
+                .into(),
+            );
+
             chapter_refs
         }
     });
-    
+
     // Get references for current verse from the pre-loaded chapter data
     // This is now extremely fast - just a HashMap lookup, no reactive recalculation per verse
     // Throttled to prevent excessive updates during rapid scrolling
@@ -347,14 +398,14 @@ pub fn CrossReferencesSidebar(
         let chapter_data = chapter_references.get();
         chapter_data.get(&verse).cloned()
     });
-    
+
     // Reset selection when references change - with debouncing
     Effect::new(move |_| {
         let _refs = sorted_references.get();
         // Always reset to 0 when references change to prevent out-of-bounds
         set_selected_reference_index.set(0);
     });
-    
+
     // Keyboard navigation for references - with comprehensive safety checks and debouncing
     let is_disposed_clone = is_disposed.clone();
     let _component_book_name = book_name.clone();
@@ -365,13 +416,12 @@ pub fn CrossReferencesSidebar(
         if is_disposed_clone.load(Ordering::Relaxed) {
             return;
         }
-        
-        
+
         // Don't handle navigation when command palette is open (let palette handle it)
         if view_state.with(|state| state.is_command_palette_open) {
             return;
         }
-        
+
         // Safe access to sorted_references with disposal check
         let refs = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
             sorted_references.get()
@@ -379,18 +429,20 @@ pub fn CrossReferencesSidebar(
             Ok(Some(refs)) if !refs.is_empty() => refs,
             _ => return, // Component is disposed or no references available
         };
-        
+
         // Only handle specific keys: Ctrl+J, Ctrl+K for navigation, or Enter for selection
-        if !matches!((e.key().as_str(), e.ctrl_key()), ("j", true) | ("k", true) | ("Enter", false)) {
+        if !matches!(
+            (e.key().as_str(), e.ctrl_key()),
+            ("j", true) | ("k", true) | ("Enter", false)
+        ) {
             return;
         }
-        
+
         // Prevent rapid-fire navigation that can cause memory issues
         if is_navigating.get() {
             return; // Skip if already processing navigation
         }
-        
-        
+
         // Bounds check current selection before processing with recovery
         let current = selected_reference_index.get();
         if current >= refs.len() {
@@ -398,38 +450,50 @@ pub fn CrossReferencesSidebar(
             set_selected_reference_index.set(0);
             return;
         }
-        
+
         // Additional safety: check if we're in a valid state for navigation
         if refs.is_empty() || current >= refs.len() {
             return;
         }
-        
+
         // Set navigation flag to prevent rapid firing
         set_is_navigating.set(true);
-        
+
         match (e.key().as_str(), e.ctrl_key(), e.shift_key()) {
             ("j", true, false) => {
                 // Ctrl+J: Next reference
                 e.prevent_default();
-                let next = if current + 1 < refs.len() { current + 1 } else { 0 };
+                let next = if current + 1 < refs.len() {
+                    current + 1
+                } else {
+                    0
+                };
                 set_selected_reference_index.set(next);
                 set_is_navigating.set(false); // Clear navigation flag
-                    
+
                 // Safe focus and announce for screen readers with bounds checking
                 if let Some(window) = web_sys::window() {
                     if let Some(document) = window.document() {
-                        if let Some(element) = document.get_element_by_id(&format!("reference-{}", next)) {
+                        if let Some(element) =
+                            document.get_element_by_id(&format!("reference-{}", next))
+                        {
                             if let Some(html_element) = element.dyn_ref::<web_sys::HtmlElement>() {
                                 let _ = html_element.focus();
-                                
+
                                 // Safe access to reference data with bounds checking
                                 if let Some(reference) = refs.get(next) {
                                     // Create a screen reader announcement with verse content
                                     let reference_text = format_reference_text(reference);
                                     let verse_content = get_verse_content_for_reference(reference);
-                                    let _announcement = format!("{} of {}: {}, {}, {}", 
-                                        next + 1, refs.len(), reference_text, format_votes_with_emoji(reference.votes), verse_content);
-                                    
+                                    let _announcement = format!(
+                                        "{} of {}: {}, {}, {}",
+                                        next + 1,
+                                        refs.len(),
+                                        reference_text,
+                                        format_votes_with_emoji(reference.votes),
+                                        verse_content
+                                    );
+
                                     // For now, we rely on focus changes for screen reader announcements
                                     // The aria-label and focus will provide the accessibility
                                 }
@@ -441,25 +505,37 @@ pub fn CrossReferencesSidebar(
             ("k", true, false) => {
                 // Ctrl+K: Previous reference
                 e.prevent_default();
-                let prev = if current > 0 { current - 1 } else { refs.len() - 1 };
+                let prev = if current > 0 {
+                    current - 1
+                } else {
+                    refs.len() - 1
+                };
                 set_selected_reference_index.set(prev);
                 set_is_navigating.set(false); // Clear navigation flag
-                
+
                 // Safe focus and announce for screen readers with bounds checking
                 if let Some(window) = web_sys::window() {
                     if let Some(document) = window.document() {
-                        if let Some(element) = document.get_element_by_id(&format!("reference-{}", prev)) {
+                        if let Some(element) =
+                            document.get_element_by_id(&format!("reference-{}", prev))
+                        {
                             if let Some(html_element) = element.dyn_ref::<web_sys::HtmlElement>() {
                                 let _ = html_element.focus();
-                                
+
                                 // Safe access to reference data with bounds checking
                                 if let Some(reference) = refs.get(prev) {
                                     // Create a screen reader announcement with verse content
                                     let reference_text = format_reference_text(reference);
                                     let verse_content = get_verse_content_for_reference(reference);
-                                    let _announcement = format!("{} of {}: {}, {}, {}", 
-                                        prev + 1, refs.len(), reference_text, format_votes_with_emoji(reference.votes), verse_content);
-                                    
+                                    let _announcement = format!(
+                                        "{} of {}: {}, {}, {}",
+                                        prev + 1,
+                                        refs.len(),
+                                        reference_text,
+                                        format_votes_with_emoji(reference.votes),
+                                        verse_content
+                                    );
+
                                     // For now, we rely on focus changes for screen reader announcements
                                     // The aria-label and focus will provide the accessibility
                                 }
@@ -471,14 +547,29 @@ pub fn CrossReferencesSidebar(
             ("Enter", false, false) => {
                 // Enter: Navigate to selected reference with bounds checking
                 e.prevent_default();
-                web_sys::console::log_1(&format!("Enter pressed, current index: {}, refs length: {}", current, refs.len()).into());
+                web_sys::console::log_1(
+                    &format!(
+                        "Enter pressed, current index: {}, refs length: {}",
+                        current,
+                        refs.len()
+                    )
+                    .into(),
+                );
                 if let Some(reference) = refs.get(current) {
                     let reference_url = reference_to_url(reference);
                     web_sys::console::log_1(&format!("Navigating to: {}", reference_url).into());
-                    navigate(&reference_url, NavigateOptions { scroll: false, ..Default::default() });
+                    navigate(
+                        &reference_url,
+                        NavigateOptions {
+                            scroll: false,
+                            ..Default::default()
+                        },
+                    );
                     // Close sidebar on mobile when reference is selected
                     if is_mobile_screen() {
-                        view_state.update(|state| { state.execute(&Instruction::CloseRightSidebar); });
+                        view_state.update(|state| {
+                            state.execute(&Instruction::CloseRightSidebar);
+                        });
                     }
                 } else {
                     web_sys::console::warn_1(&format!("Attempted to navigate to reference at invalid index: {} (refs.len: {})", current, refs.len()).into());
@@ -490,7 +581,7 @@ pub fn CrossReferencesSidebar(
             }
         }
     };
-    
+
     // Add keyboard event listener - with proper cleanup to prevent disposed reactive value access
     let _cleanup = window_event_listener(ev::keydown, handle_keydown);
     on_cleanup(move || {
@@ -499,9 +590,9 @@ pub fn CrossReferencesSidebar(
         // Cleanup is handled automatically when _cleanup is dropped
         drop(_cleanup);
     });
-    
+
     view! {
-        <div 
+        <div
             class="cross-references-sidebar"
             tabindex="0"
             on:focus=move |_| set_sidebar_has_focus.set(true)
@@ -515,7 +606,7 @@ pub fn CrossReferencesSidebar(
                     {get_translated_book_name(&book_name)} " " {chapter} ":" {verse}
                 </div>
             </div>
-            
+
             <Show
                 when=move || sorted_references.get().is_some()
                 fallback=move || view! {
@@ -537,7 +628,7 @@ pub fn CrossReferencesSidebar(
                             let is_selected = Memo::new(move |_| selected_reference_index.get() == index);
                             let reference_id = format!("reference-{}", index);
                             view! {
-                                <ReferenceItem 
+                                <ReferenceItem
                                     reference=reference
                                     is_selected=is_selected
                                     view_state=view_state
@@ -547,7 +638,7 @@ pub fn CrossReferencesSidebar(
                         }
                     />
                 </div>
-                
+
                 // Live preview section for selected reference
                 <Show when=move || sorted_references.get().is_some_and(|refs| !refs.is_empty())>
                     <div class="mt-4 border-t pt-4" style="border-color: var(--theme-sidebar-border)">
@@ -618,7 +709,7 @@ fn ReferenceItem(
     let reference_text = format_reference_text(&reference);
     let reference_url = reference_to_url(&reference);
     let votes_text = format_votes_with_emoji(reference.votes);
-    
+
     view! {
         <div class="reference-item">
             <button
@@ -698,11 +789,14 @@ mod tests {
             to_verse_end: None,
             votes: 51,
         };
-        
+
         // Test single verse format: "Book Chapter:Verse"
-        let expected_single = format!("{} {}:{}", reference.to_book_name, reference.to_chapter, reference.to_verse_start);
+        let expected_single = format!(
+            "{} {}:{}",
+            reference.to_book_name, reference.to_chapter, reference.to_verse_start
+        );
         assert_eq!(expected_single, "Isaiah 51:16");
-        
+
         let range_reference = Reference {
             to_book_name: "Romans".to_string(),
             to_chapter: 1,
@@ -710,11 +804,12 @@ mod tests {
             to_verse_end: Some(20),
             votes: 50,
         };
-        
+
         // Test range format: "Book Chapter:Start-End"
-        let expected_range = format!("{} {}:{}-{}", 
-            range_reference.to_book_name, 
-            range_reference.to_chapter, 
+        let expected_range = format!(
+            "{} {}:{}-{}",
+            range_reference.to_book_name,
+            range_reference.to_chapter,
             range_reference.to_verse_start,
             range_reference.to_verse_end.unwrap()
         );
@@ -730,9 +825,9 @@ mod tests {
             to_verse_end: None,
             votes: 51,
         };
-        
+
         assert_eq!(reference_to_url(&reference), "/Isaiah/51?verses=16");
-        
+
         let range_reference = Reference {
             to_book_name: "Romans".to_string(),
             to_chapter: 1,
@@ -740,7 +835,7 @@ mod tests {
             to_verse_end: Some(20),
             votes: 50,
         };
-        
+
         assert_eq!(reference_to_url(&range_reference), "/Romans/1?verses=19-20");
     }
 
@@ -754,29 +849,32 @@ mod tests {
         assert_eq!(get_canonical_book_name("I Corinthians"), "1 Corinthians");
         assert_eq!(get_canonical_book_name("II Corinthians"), "2 Corinthians");
         assert_eq!(get_canonical_book_name("III John"), "3 John");
-        
+
         // Test Revelation alternative names
         assert_eq!(get_canonical_book_name("Revelation of John"), "Revelation");
         assert_eq!(get_canonical_book_name("The Revelation"), "Revelation");
-        assert_eq!(get_canonical_book_name("The Revelation of John"), "Revelation");
-        
+        assert_eq!(
+            get_canonical_book_name("The Revelation of John"),
+            "Revelation"
+        );
+
         // Test Dutch to English conversion for numbered books
         assert_eq!(get_canonical_book_name("I Samuël"), "1 Samuel");
         assert_eq!(get_canonical_book_name("II Samuël"), "2 Samuel");
         assert_eq!(get_canonical_book_name("I Koningen"), "1 Kings");
         assert_eq!(get_canonical_book_name("II Koningen"), "2 Kings");
-        
+
         // Test other Dutch translations
         assert_eq!(get_canonical_book_name("Psalmen"), "Psalms");
         assert_eq!(get_canonical_book_name("Prediker"), "Ecclesiastes");
         assert_eq!(get_canonical_book_name("Openbaring"), "Revelation");
         assert_eq!(get_canonical_book_name("Openbaringen"), "Revelation");
-        
+
         // Test that Arabic numeral English names pass through unchanged
         assert_eq!(get_canonical_book_name("1 Samuel"), "1 Samuel");
         assert_eq!(get_canonical_book_name("Genesis"), "Genesis");
         assert_eq!(get_canonical_book_name("Revelation"), "Revelation");
-        
+
         // Test unknown names pass through unchanged
         assert_eq!(get_canonical_book_name("Unknown Book"), "Unknown Book");
     }
@@ -785,15 +883,18 @@ mod tests {
     fn test_revelation_verse_id_creation() {
         // Test that "Revelation of John" can successfully create a VerseId
         use crate::core::types::VerseId;
-        
+
         let canonical_name = get_canonical_book_name("Revelation of John");
         assert_eq!(canonical_name, "Revelation");
-        
+
         let verse_id = VerseId::from_book_name(&canonical_name, 22, 1);
-        assert!(verse_id.is_some(), "Should be able to create VerseId for Revelation 22:1");
-        
+        assert!(
+            verse_id.is_some(),
+            "Should be able to create VerseId for Revelation 22:1"
+        );
+
         if let Some(id) = verse_id {
-            // Verify the VerseId was created correctly  
+            // Verify the VerseId was created correctly
             // Book ID 66 for Revelation, chapter 22, verse 1
             assert_eq!(id.0, 0x42016001); // 66 << 24 | 22 << 12 | 1
         }
@@ -803,30 +904,36 @@ mod tests {
     fn test_revelation_cross_references_lookup() {
         // Test that we can actually find cross-references for "Revelation of John" 22:1
         use crate::core::types::VerseId;
-        
+
         let canonical_name = get_canonical_book_name("Revelation of John");
         let verse_id = VerseId::from_book_name(&canonical_name, 22, 1).unwrap();
-        
+
         let references = get_cross_references();
         let verse_references = references.0.get(&verse_id);
-        
+
         // We know from the data file that Rev.22.1 has many cross-references
-        assert!(verse_references.is_some(), "Revelation 22:1 should have cross-references");
-        
+        assert!(
+            verse_references.is_some(),
+            "Revelation 22:1 should have cross-references"
+        );
+
         if let Some(refs) = verse_references {
-            assert!(!refs.is_empty(), "Revelation 22:1 should have at least one cross-reference");
-            
+            assert!(
+                !refs.is_empty(),
+                "Revelation 22:1 should have at least one cross-reference"
+            );
+
             // Check for some specific references we know exist from the data
             let has_rev_7_17 = refs.iter().any(|r| {
                 r.to_book_name == "Revelation" && r.to_chapter == 7 && r.to_verse_start == 17
             });
-            
-            let has_john_4_14 = refs.iter().any(|r| {
-                r.to_book_name == "John" && r.to_chapter == 4 && r.to_verse_start == 14
-            });
-            
+
+            let has_john_4_14 = refs
+                .iter()
+                .any(|r| r.to_book_name == "John" && r.to_chapter == 4 && r.to_verse_start == 14);
+
             // At least one of these should exist based on our cross-reference data
-            assert!(has_rev_7_17 || has_john_4_14, 
+            assert!(has_rev_7_17 || has_john_4_14,
                 "Should find at least one expected cross-reference for Revelation 22:1. Found {} references", 
                 refs.len());
         }
@@ -836,7 +943,7 @@ mod tests {
     fn test_book_name_conversion_for_bible_lookup() {
         // Test that the book name conversion works correctly for Arabic -> Roman numeral conversion
         // This tests the fix for the cross-references verse content lookup issue
-        
+
         // Cross-references use Arabic numerals
         assert_eq!(get_display_book_name("1 Samuel"), "I Samuel");
         assert_eq!(get_display_book_name("2 Samuel"), "II Samuel");
@@ -855,12 +962,12 @@ mod tests {
         assert_eq!(get_display_book_name("1 John"), "I John");
         assert_eq!(get_display_book_name("2 John"), "II John");
         assert_eq!(get_display_book_name("3 John"), "III John");
-        
+
         // Books without numbers remain unchanged
         assert_eq!(get_display_book_name("Genesis"), "Genesis");
         assert_eq!(get_display_book_name("Matthew"), "Matthew");
         assert_eq!(get_display_book_name("Psalms"), "Psalms");
-        
+
         // Revelation has a special case
         assert_eq!(get_display_book_name("Revelation"), "Revelation of John");
     }
@@ -870,7 +977,7 @@ mod tests {
         // Test that verse content retrieval correctly converts book names
         // This is a mock test since we can't easily test the actual Bible data loading
         use crate::core::types::Reference;
-        
+
         // Create a reference with Arabic numeral book name (as stored in cross-references)
         let reference = Reference {
             to_book_name: "1 Samuel".to_string(),
@@ -879,16 +986,16 @@ mod tests {
             to_verse_end: None,
             votes: 10,
         };
-        
+
         // The function should convert "1 Samuel" to "I Samuel" for Bible lookup
         // Since we can't test the actual Bible data loading without complex setup,
         // we'll just test that the conversion function is being called correctly
         let converted_name = get_display_book_name(&reference.to_book_name);
         assert_eq!(converted_name, "I Samuel");
-        
+
         // Test that this would work for verse content retrieval
         // (The actual retrieval is tested indirectly through the integration)
         assert_eq!(get_display_book_name("1 Samuel"), "I Samuel");
         assert_eq!(get_display_book_name("2 Samuel"), "II Samuel");
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/components/custom_translation_import.rs b/site/src/components/custom_translation_import.rs
index d667cd6..2dc74fa 100644
--- a/site/src/components/custom_translation_import.rs
+++ b/site/src/components/custom_translation_import.rs
@@ -1,16 +1,16 @@
-use leptos::prelude::*;
-use leptos::html::Input;
-use web_sys::{FileReader, Event, HtmlInputElement};
-use wasm_bindgen::{JsCast, closure::Closure};
-use wasm_bindgen_futures::spawn_local;
-use gloo_storage::{LocalStorage, Storage};
-use serde::{Deserialize, Serialize};
-use crate::core::Bible;
 use crate::core::types::Language;
+use crate::core::Bible;
 use crate::storage::{
-    BibleTranslation, add_downloaded_translation, set_selected_translation,
-    switch_bible_translation, save_translation_to_cache
+    add_downloaded_translation, save_translation_to_cache, set_selected_translation,
+    switch_bible_translation, BibleTranslation,
 };
+use gloo_storage::{LocalStorage, Storage};
+use leptos::html::Input;
+use leptos::prelude::*;
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::{closure::Closure, JsCast};
+use wasm_bindgen_futures::spawn_local;
+use web_sys::{Event, FileReader, HtmlInputElement};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct CustomTranslation {
@@ -24,16 +24,20 @@ pub fn get_custom_translations() -> Vec<BibleTranslation> {
     LocalStorage::get::<Vec<BibleTranslation>>(CUSTOM_TRANSLATIONS_KEY).unwrap_or_default()
 }
 
-pub fn add_custom_translation(translation: &BibleTranslation) -> Result<(), gloo_storage::errors::StorageError> {
+pub fn add_custom_translation(
+    translation: &BibleTranslation,
+) -> Result<(), gloo_storage::errors::StorageError> {
     let mut custom_translations = get_custom_translations();
-    
+
     custom_translations.retain(|t| t.short_name != translation.short_name);
     custom_translations.push(translation.clone());
-    
+
     LocalStorage::set(CUSTOM_TRANSLATIONS_KEY, &custom_translations)
 }
 
-pub fn _remove_custom_translation(short_name: &str) -> Result<(), gloo_storage::errors::StorageError> {
+pub fn _remove_custom_translation(
+    short_name: &str,
+) -> Result<(), gloo_storage::errors::StorageError> {
     let mut custom_translations = get_custom_translations();
     custom_translations.retain(|t| t.short_name != short_name);
     LocalStorage::set(CUSTOM_TRANSLATIONS_KEY, &custom_translations)
@@ -55,12 +59,12 @@ pub fn CustomTranslationImport(
     let (show_import_modal, set_show_import_modal) = signal(false);
     let (import_error, set_import_error) = signal::<Option<String>>(None);
     let (is_importing, set_is_importing) = signal(false);
-    
+
     let (translation_name, set_translation_name) = signal(String::new());
     let (release_year, set_release_year) = signal(String::new());
     let (_file_selected, set_file_selected) = signal(false);
     let (file_content, set_file_content) = signal::<Option<String>>(None);
-    
+
     let file_input_ref = NodeRef::<Input>::new();
 
     let reset_form = move || {
@@ -75,17 +79,19 @@ pub fn CustomTranslationImport(
     };
 
     let on_file_change = move |ev: Event| {
-        let input = ev.target().and_then(|t| t.dyn_into::<HtmlInputElement>().ok());
+        let input = ev
+            .target()
+            .and_then(|t| t.dyn_into::<HtmlInputElement>().ok());
         if let Some(input) = input {
             if let Some(files) = input.files() {
                 if files.length() > 0 {
                     if let Some(file) = files.get(0) {
                         set_file_selected.set(true);
                         set_import_error.set(None);
-                        
+
                         let file_reader = FileReader::new().unwrap();
                         let file_reader_clone = file_reader.clone();
-                        
+
                         let onload = Closure::wrap(Box::new(move |_: Event| {
                             if let Some(result) = file_reader_clone.result().ok() {
                                 if let Some(text) = result.as_string() {
@@ -93,10 +99,10 @@ pub fn CustomTranslationImport(
                                 }
                             }
                         }) as Box<dyn FnMut(_)>);
-                        
+
                         file_reader.set_onload(Some(onload.as_ref().unchecked_ref()));
                         onload.forget();
-                        
+
                         let _ = file_reader.read_as_text(&file);
                     }
                 }
@@ -130,12 +136,16 @@ pub fn CustomTranslationImport(
             let name = translation_name.get();
             let lang = selected_language.get();
             let success_callback = on_success.clone();
-            
+
             spawn_local(async move {
                 match serde_json::from_str::<Bible>(&text) {
                     Ok(bible) => {
-                        let short_name = format!("custom_{}", js_sys::Math::random().to_string().replace("0.", "")[..8].to_lowercase());
-                        
+                        let short_name = format!(
+                            "custom_{}",
+                            js_sys::Math::random().to_string().replace("0.", "")[..8]
+                                .to_lowercase()
+                        );
+
                         let translation = BibleTranslation {
                             name: name,
                             short_name: short_name.clone(),
@@ -153,28 +163,33 @@ pub fn CustomTranslationImport(
                                 }
 
                                 if let Err(e) = add_downloaded_translation(&short_name) {
-                                    set_import_error.set(Some(format!("Fout bij registreren: {}", e)));
+                                    set_import_error
+                                        .set(Some(format!("Fout bij registreren: {}", e)));
                                     set_is_importing.set(false);
                                     return;
                                 }
 
                                 let _ = set_selected_translation(&short_name);
-                                
+
                                 if let Err(e) = switch_bible_translation(&short_name).await {
-                                    leptos::logging::error!("Failed to switch to imported translation: {}", e);
+                                    leptos::logging::error!(
+                                        "Failed to switch to imported translation: {}",
+                                        e
+                                    );
                                 }
 
                                 set_is_importing.set(false);
                                 set_show_import_modal.set(false);
                                 reset_form();
                                 success_callback();
-                            },
+                            }
                             Err(e) => {
-                                set_import_error.set(Some(format!("Fout bij opslaan naar cache: {}", e)));
+                                set_import_error
+                                    .set(Some(format!("Fout bij opslaan naar cache: {}", e)));
                                 set_is_importing.set(false);
                             }
                         }
-                    },
+                    }
                     Err(e) => {
                         set_import_error.set(Some(format!("Ongeldig JSON formaat: {}", e)));
                         set_is_importing.set(false);
@@ -316,4 +331,4 @@ pub fn CustomTranslationImport(
             </Show>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/components/mod.rs b/site/src/components/mod.rs
index 8148a44..929148b 100644
--- a/site/src/components/mod.rs
+++ b/site/src/components/mod.rs
@@ -2,22 +2,22 @@
 // Core interface components for the Bible application
 
 pub mod command_palette;
-pub mod sidebar;
-pub mod theme_switcher;
-pub mod theme_sidebar;
-pub mod translation_switcher;
 pub mod cross_references_sidebar;
-pub mod pdf_loading_progress;
 pub mod custom_translation_import;
+pub mod pdf_loading_progress;
+pub mod sidebar;
+pub mod theme_sidebar;
+pub mod theme_switcher;
 pub mod translation_comparison;
+pub mod translation_switcher;
 
 // === Component Exports ===
 // Re-export all public components for easy importing
 
 pub use command_palette::*;
-pub use sidebar::*;
-pub use theme_sidebar::*;
 pub use cross_references_sidebar::*;
-pub use pdf_loading_progress::*;
 pub use custom_translation_import::*;
-pub use translation_comparison::*;
\ No newline at end of file
+pub use pdf_loading_progress::*;
+pub use sidebar::*;
+pub use theme_sidebar::*;
+pub use translation_comparison::*;
diff --git a/site/src/components/pdf_loading_progress.rs b/site/src/components/pdf_loading_progress.rs
index 1efdd02..75711d4 100644
--- a/site/src/components/pdf_loading_progress.rs
+++ b/site/src/components/pdf_loading_progress.rs
@@ -13,13 +13,15 @@ pub fn PdfLoadingProgress(
     // Debug: Log when visibility changes
     Effect::new(move |_| {
         let visible = is_visible.get();
-        web_sys::console::log_1(&format!("📊 PDF Progress Component visibility: {}", visible).into());
+        web_sys::console::log_1(
+            &format!("📊 PDF Progress Component visibility: {}", visible).into(),
+        );
     });
 
     view! {
         <Show when=move || is_visible.get()>
-            <div 
-                class="fixed inset-0 flex items-center justify-center" 
+            <div
+                class="fixed inset-0 flex items-center justify-center"
                 style="background: rgba(0,0,0,0.8); z-index: 9999; top: 0; left: 0; width: 100vw; height: 100vh;"
             >
                 <div class="bg-white dark:bg-gray-800 rounded-lg shadow-xl p-6 w-96 max-w-full mx-4" style="background: white; border: 2px solid red;">
@@ -28,44 +30,44 @@ pub fn PdfLoadingProgress(
                         <h3 class="text-lg font-semibold text-gray-900 dark:text-gray-100 mb-4">
                             "Exporting PDF"
                         </h3>
-                        
+
                         // Progress Bar
                         <div class="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-3 mb-4">
-                            <div 
+                            <div
                                 class="bg-blue-600 h-3 rounded-full transition-all duration-300 ease-out"
                                 style:width=move || format!("{}%", (progress.get() * 100.0) as u32)
                             ></div>
                         </div>
-                        
+
                         // Progress Percentage
                         <div class="text-sm font-medium text-blue-600 dark:text-blue-400 mb-2">
                             {move || format!("{}%", (progress.get() * 100.0) as u32)}
                         </div>
-                        
+
                         // Status Message
                         <div class="text-sm text-gray-600 dark:text-gray-400 mb-4">
                             {move || status_message.get()}
                         </div>
-                        
+
                         // Animated Spinner
                         <div class="flex items-center justify-center">
-                            <svg 
-                                class="animate-spin h-5 w-5 text-blue-600 dark:text-blue-400" 
-                                xmlns="http://www.w3.org/2000/svg" 
-                                fill="none" 
+                            <svg
+                                class="animate-spin h-5 w-5 text-blue-600 dark:text-blue-400"
+                                xmlns="http://www.w3.org/2000/svg"
+                                fill="none"
                                 viewBox="0 0 24 24"
                             >
-                                <circle 
-                                    class="opacity-25" 
-                                    cx="12" 
-                                    cy="12" 
-                                    r="10" 
-                                    stroke="currentColor" 
+                                <circle
+                                    class="opacity-25"
+                                    cx="12"
+                                    cy="12"
+                                    r="10"
+                                    stroke="currentColor"
                                     stroke-width="4"
                                 ></circle>
-                                <path 
-                                    class="opacity-75" 
-                                    fill="currentColor" 
+                                <path
+                                    class="opacity-75"
+                                    fill="currentColor"
                                     d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
                                 ></path>
                             </svg>
@@ -78,4 +80,4 @@ pub fn PdfLoadingProgress(
             </div>
         </Show>
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/components/theme_sidebar.rs b/site/src/components/theme_sidebar.rs
index 3352664..fa3c2ab 100644
--- a/site/src/components/theme_sidebar.rs
+++ b/site/src/components/theme_sidebar.rs
@@ -1,12 +1,12 @@
-use leptos::prelude::*;
-use leptos::ev;
-use leptos::web_sys::KeyboardEvent;
-use leptos::wasm_bindgen::JsCast;
 use crate::instructions::types::Instruction;
-use crate::themes::{get_themes, Theme};
 use crate::storage::save_selected_theme;
+use crate::themes::{get_themes, Theme};
 use crate::utils::is_mobile_screen;
 use crate::view_state::ViewStateSignal;
+use leptos::ev;
+use leptos::prelude::*;
+use leptos::wasm_bindgen::JsCast;
+use leptos::web_sys::KeyboardEvent;
 
 #[component]
 pub fn ThemeSidebar(
@@ -16,54 +16,61 @@ pub fn ThemeSidebar(
 ) -> impl IntoView {
     let themes = get_themes();
     let themes_len = themes.len();
-    
+
     // Track selected theme index for keyboard navigation
     let (selected_theme_index, set_selected_theme_index) = signal(0usize);
-    
+
     // Update selected index when current theme changes
     let themes_for_effect = themes.clone();
     Effect::new(move |_| {
         let current_theme_id = current_theme.get().id;
-        if let Some(index) = themes_for_effect.iter().position(|t| t.id == current_theme_id) {
+        if let Some(index) = themes_for_effect
+            .iter()
+            .position(|t| t.id == current_theme_id)
+        {
             set_selected_theme_index.set(index);
         }
     });
-    
+
     // Keyboard navigation handler
     let themes_for_keydown = themes.clone();
     let handle_keydown = move |e: KeyboardEvent| {
         if themes_len == 0 {
             return;
         }
-        
+
         // Don't handle navigation when command palette is open (let palette handle it)
         if view_state.with(|state| state.is_command_palette_open) {
             return;
         }
-        
+
         match (e.key().as_str(), e.ctrl_key()) {
             ("j", true) => {
                 // Ctrl+J: Next theme and apply it instantly
                 e.prevent_default();
                 let current_index = selected_theme_index.get();
-                let next_index = if current_index + 1 < themes_len { 
-                    current_index + 1 
-                } else { 
-                    0 
+                let next_index = if current_index + 1 < themes_len {
+                    current_index + 1
+                } else {
+                    0
                 };
                 set_selected_theme_index.set(next_index);
-                
+
                 // Apply the theme instantly
                 if let Some(selected_theme) = themes_for_keydown.get(next_index) {
                     set_current_theme.set(selected_theme.clone());
                     save_selected_theme(&selected_theme.id);
                 }
-                
+
                 // Focus the selected theme button
                 if let Some(window) = leptos::web_sys::window() {
                     if let Some(document) = window.document() {
-                        if let Some(element) = document.get_element_by_id(&format!("theme-{}", next_index)) {
-                            if let Some(html_element) = element.dyn_ref::<leptos::web_sys::HtmlElement>() {
+                        if let Some(element) =
+                            document.get_element_by_id(&format!("theme-{}", next_index))
+                        {
+                            if let Some(html_element) =
+                                element.dyn_ref::<leptos::web_sys::HtmlElement>()
+                            {
                                 let _ = html_element.focus();
                             }
                         }
@@ -74,24 +81,28 @@ pub fn ThemeSidebar(
                 // Ctrl+K: Previous theme and apply it instantly
                 e.prevent_default();
                 let current_index = selected_theme_index.get();
-                let prev_index = if current_index > 0 { 
-                    current_index - 1 
-                } else { 
-                    themes_len - 1 
+                let prev_index = if current_index > 0 {
+                    current_index - 1
+                } else {
+                    themes_len - 1
                 };
                 set_selected_theme_index.set(prev_index);
-                
+
                 // Apply the theme instantly
                 if let Some(selected_theme) = themes_for_keydown.get(prev_index) {
                     set_current_theme.set(selected_theme.clone());
                     save_selected_theme(&selected_theme.id);
                 }
-                
+
                 // Focus the selected theme button
                 if let Some(window) = leptos::web_sys::window() {
                     if let Some(document) = window.document() {
-                        if let Some(element) = document.get_element_by_id(&format!("theme-{}", prev_index)) {
-                            if let Some(html_element) = element.dyn_ref::<leptos::web_sys::HtmlElement>() {
+                        if let Some(element) =
+                            document.get_element_by_id(&format!("theme-{}", prev_index))
+                        {
+                            if let Some(html_element) =
+                                element.dyn_ref::<leptos::web_sys::HtmlElement>()
+                            {
                                 let _ = html_element.focus();
                             }
                         }
@@ -101,10 +112,10 @@ pub fn ThemeSidebar(
             _ => {}
         }
     };
-    
+
     // Add keyboard event listener
     let _cleanup = window_event_listener(ev::keydown, handle_keydown);
-    
+
     view! {
         <div class="theme-sidebar h-full flex flex-col">
             <div class="flex items-center justify-between mb-4 pb-4 border-b" style="border-color: var(--theme-sidebar-border)">
@@ -132,7 +143,7 @@ pub fn ThemeSidebar(
                     </svg>
                 </button>
             </div>
-            
+
             <div class="flex-1 space-y-3" role="listbox" aria-label="Available themes">
                 {themes.into_iter().enumerate().map(|(index, theme)| {
                     let theme_clone = theme.clone();
@@ -142,7 +153,7 @@ pub fn ThemeSidebar(
                     let theme_name = theme.name.clone();
                     let current_theme_id = move || current_theme.get().id.clone();
                     let is_selected = move || selected_theme_index.get() == index;
-                    
+
                     view! {
                         <button
                             id=format!("theme-{}", index)
@@ -170,7 +181,7 @@ pub fn ThemeSidebar(
                             on:click=move |_| {
                                 set_current_theme.set(theme_clone.clone());
                                 save_selected_theme(&theme_id_for_click);
-                                
+
                                 // Close sidebar on mobile after selection
                                 if is_mobile_screen() {
                                     view_state.update(|state| { state.execute(&Instruction::CloseThemeSidebar); });
@@ -182,22 +193,22 @@ pub fn ThemeSidebar(
                                     <h3 class="font-semibold text-base">{theme_name.clone()}</h3>
                                     <div class="mt-2 flex space-x-2">
                                         // Color preview circles
-                                        <div 
+                                        <div
                                             class="w-4 h-4 rounded-full border"
                                             style=format!("background-color: {}; border-color: var(--theme-sidebar-border)", theme.colors.background)
                                             title="Background color"
                                         />
-                                        <div 
+                                        <div
                                             class="w-4 h-4 rounded-full border"
                                             style=format!("background-color: {}; border-color: var(--theme-sidebar-border)", theme.colors.text.primary)
                                             title="Text color"
                                         />
-                                        <div 
+                                        <div
                                             class="w-4 h-4 rounded-full border"
                                             style=format!("background-color: {}; border-color: var(--theme-sidebar-border)", theme.colors.sidebar.background)
                                             title="Sidebar color"
                                         />
-                                        <div 
+                                        <div
                                             class="w-4 h-4 rounded-full border"
                                             style=format!("background-color: {}; border-color: var(--theme-sidebar-border)", theme.colors.buttons.primary.background)
                                             title="Accent color"
@@ -226,11 +237,11 @@ pub fn ThemeSidebar(
                     }
                 }).collect_view()}
             </div>
-            
+
             <div class="mt-4 pt-4 border-t" style="border-color: var(--theme-sidebar-border)">
                 <div class="space-y-1">
                     <p class="text-xs opacity-75" style="color: var(--theme-text-muted)">
-                        "Navigate & Apply: " 
+                        "Navigate & Apply: "
                         <kbd class="px-1.5 py-0.5 rounded text-xs font-mono border" style="background-color: var(--theme-sidebar-background); border-color: var(--theme-sidebar-border)">
                             "Ctrl+J"
                         </kbd>
@@ -249,4 +260,4 @@ pub fn ThemeSidebar(
             </div>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/components/theme_switcher.rs b/site/src/components/theme_switcher.rs
index 7e21002..fd41239 100644
--- a/site/src/components/theme_switcher.rs
+++ b/site/src/components/theme_switcher.rs
@@ -1,6 +1,6 @@
-use leptos::prelude::*;
-use crate::themes::{get_themes, Theme};
 use crate::storage::save_selected_theme;
+use crate::themes::{get_themes, Theme};
+use leptos::prelude::*;
 
 #[component]
 pub fn ThemeSwitcher(
@@ -62,7 +62,7 @@ pub fn ThemeSwitcher(
                             let theme_id_for_show = theme.id.clone();
                             let theme_name = theme.name.clone();
                             let current_theme_id = move || current_theme.get().id.clone();
-                            
+
                             view! {
                                 <button
                                     class="w-full px-3 py-2 text-left hover:bg-gray-50 transition-colors flex items-center justify-between"
@@ -110,4 +110,4 @@ pub fn ThemeSwitcher(
             </Show>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/components/translation_comparison.rs b/site/src/components/translation_comparison.rs
index 9399535..66fe947 100644
--- a/site/src/components/translation_comparison.rs
+++ b/site/src/components/translation_comparison.rs
@@ -1,10 +1,10 @@
 /*!
  * Translation Comparison Component
- * 
+ *
  * This component provides side-by-side comparison of Bible verses across
  * different translations. Users can select multiple translations and view
  * the current verse(s) displayed in parallel.
- * 
+ *
  * Features:
  * - Multi-translation selection via checkboxes
  * - Automatic verse context from current URL
@@ -13,19 +13,18 @@
  * - Keyboard shortcuts (Escape to close)
  */
 
-use leptos::prelude::*;
 use leptos::ev;
+use leptos::prelude::*;
 use leptos::web_sys::KeyboardEvent;
 use wasm_bindgen_futures::spawn_local;
 
 // Core types and utilities
-use crate::core::{VerseRange, parse_verse_ranges_from_url, Verse};
+use crate::core::{parse_verse_ranges_from_url, Verse, VerseRange};
 use crate::instructions::types::Instruction;
-use crate::storage::{get_downloaded_translations, load_downloaded_translation};
 use crate::storage::translations::get_translations;
+use crate::storage::{get_downloaded_translations, load_downloaded_translation};
 use crate::view_state::ViewStateSignal;
 
-
 /// Internal state for tracking comparison data
 #[derive(Debug, Clone)]
 struct ComparisonData {
@@ -37,7 +36,7 @@ struct ComparisonData {
 
 /**
  * Main Translation Comparison Component
- * 
+ *
  * Renders a right-side panel that allows users to compare verses across
  * multiple Bible translations. The panel includes:
  * - Header with close button
@@ -55,28 +54,26 @@ pub fn TranslationComparison(
     view_state: ViewStateSignal,
 ) -> impl IntoView {
     // === State Management ===
-    
+
     // List of translation keys selected for comparison
     let (selected_translations, set_selected_translations) = signal::<Vec<String>>(Vec::new());
-    
+
     // Processed comparison data with translation names and verses
     let (comparison_data, set_comparison_data) = signal::<Vec<ComparisonData>>(Vec::new());
-    
+
     // Loading state for async operations
     let (loading, set_loading) = signal(false);
-    
+
     // List of downloaded translations available for selection
     let (downloaded_translations, set_downloaded_translations) = signal::<Vec<String>>(Vec::new());
 
     // === Computed Values ===
-    
+
     // Get the current verse ranges from the URL parameters
-    let current_verse_ranges = Memo::new(move |_| {
-        parse_verse_ranges_from_url()
-    });
+    let current_verse_ranges = Memo::new(move |_| parse_verse_ranges_from_url());
 
     // === Effects ===
-    
+
     // Load available translations when panel opens
     // This effect runs whenever the panel is opened and populates
     // the list of available translations for comparison.
@@ -92,23 +89,25 @@ pub fn TranslationComparison(
     // and loads the corresponding verses for comparison.
     Effect::new(move |_| {
         let selected = selected_translations.get();
-        
+
         if !selected.is_empty() && view_state.with(|state| state.is_translation_comparison_open) {
             let book = current_book.get();
             let chapter = current_chapter.get();
             let verse_ranges = current_verse_ranges.get();
-            
+
             set_loading.set(true);
-            
+
             spawn_local(async move {
                 let mut comparison_results = Vec::new();
-                
+
                 // Load each selected translation
                 for translation_key in selected {
                     if let Ok(bible) = load_downloaded_translation(&translation_key).await {
                         if let Ok(chapter_data) = bible.get_chapter(&book, chapter) {
                             // Filter verses based on current selection
-                            let filtered_verses: Vec<Verse> = chapter_data.verses.iter()
+                            let filtered_verses: Vec<Verse> = chapter_data
+                                .verses
+                                .iter()
                                 .filter(|verse| {
                                     verse_ranges.iter().any(|range| {
                                         verse.verse >= range.start && verse.verse <= range.end
@@ -116,13 +115,14 @@ pub fn TranslationComparison(
                                 })
                                 .cloned()
                                 .collect();
-                            
+
                             // Get user-friendly translation name
-                            let translation_name = get_translations().iter()
+                            let translation_name = get_translations()
+                                .iter()
                                 .find(|t| t.short_name == translation_key)
                                 .map(|t| t.name.clone())
                                 .unwrap_or_else(|| translation_key.clone());
-                            
+
                             comparison_results.push(ComparisonData {
                                 translation_name,
                                 verses: filtered_verses,
@@ -130,7 +130,7 @@ pub fn TranslationComparison(
                         }
                     }
                 }
-                
+
                 set_comparison_data.set(comparison_results);
                 set_loading.set(false);
             });
@@ -141,24 +141,26 @@ pub fn TranslationComparison(
     });
 
     // === Event Handlers ===
-    
+
     // Close panel on Escape key press
     // Global keyboard listener that closes the comparison panel
     // when the user presses the Escape key.
     window_event_listener(ev::keydown, move |evt: KeyboardEvent| {
         if evt.key() == "Escape" && view_state.with(|state| state.is_translation_comparison_open) {
             evt.prevent_default();
-            view_state.update(|state| { state.execute(&Instruction::CloseTranslationComparison); });
+            view_state.update(|state| {
+                state.execute(&Instruction::CloseTranslationComparison);
+            });
         }
     });
 
     // === Render Component ===
-    
+
     view! {
         <Show when=move || view_state.with(|state| state.is_translation_comparison_open) fallback=|| view! { <></> }>
             {/* Main Panel Container */}
             <div class="fixed inset-y-0 right-0 w-96 bg-white shadow-lg z-30 flex flex-col border-l border-gray-200">
-                
+
                 {/* Panel Header */}
                 <div class="flex items-center justify-between p-4 border-b border-gray-200">
                     <h2 class="text-lg font-semibold text-gray-800">Translation Comparison</h2>
@@ -201,10 +203,10 @@ pub fn TranslationComparison(
                 <div class="p-4 border-t border-gray-200 bg-gray-50">
                     <div class="text-xs text-gray-500 text-center">
                         <p>
-                            Press 
-                            <kbd class="px-1 py-0.5 bg-gray-200 rounded text-xs">Esc</kbd> 
-                            or 
-                            <kbd class="px-1 py-0.5 bg-gray-200 rounded text-xs">C</kbd> 
+                            Press
+                            <kbd class="px-1 py-0.5 bg-gray-200 rounded text-xs">Esc</kbd>
+                            or
+                            <kbd class="px-1 py-0.5 bg-gray-200 rounded text-xs">C</kbd>
                             to close
                         </p>
                     </div>
@@ -216,7 +218,7 @@ pub fn TranslationComparison(
 
 /**
  * Render a translation selection checkbox
- * 
+ *
  * Creates a checkbox for selecting/deselecting a translation
  * for comparison. Includes the translation name and short code.
  */
@@ -226,17 +228,16 @@ fn render_translation_checkbox(
     set_selected_translations: WriteSignal<Vec<String>>,
 ) -> impl IntoView {
     let translation_clone = translation.clone();
-    
+
     // Get display name for the translation
-    let translation_display = get_translations().iter()
+    let translation_display = get_translations()
+        .iter()
         .find(|t| t.short_name == translation)
         .map(|t| format!("{} ({})", t.name, t.short_name))
         .unwrap_or_else(|| translation.clone());
-    
+
     // Check if this translation is currently selected
-    let is_selected = Memo::new(move |_| {
-        selected_translations.get().contains(&translation)
-    });
+    let is_selected = Memo::new(move |_| selected_translations.get().contains(&translation));
 
     view! {
         <label class="flex items-center space-x-2 cursor-pointer">
@@ -263,7 +264,7 @@ fn render_translation_checkbox(
 
 /**
  * Render the comparison results section
- * 
+ *
  * Shows either a loading state, empty state, or the actual
  * verse comparisons based on the current state.
  */
@@ -290,7 +291,7 @@ fn render_comparison_results(
 
 /**
  * Render the actual comparison content
- * 
+ *
  * Shows either the verse comparisons or an empty state message.
  */
 fn render_comparison_content(
@@ -334,7 +335,7 @@ fn render_empty_state(current_verse_ranges: Memo<Vec<VerseRange>>) -> impl IntoV
 
 /**
  * Render verses for a single translation
- * 
+ *
  * Creates a card showing the translation name and its verses.
  */
 fn render_translation_verses(data: ComparisonData) -> impl IntoView {
@@ -367,12 +368,13 @@ fn render_translation_verses(data: ComparisonData) -> impl IntoView {
 
 /**
  * Format verse ranges for display
- * 
+ *
  * Converts a list of verse ranges into a human-readable string.
  * Examples: "5", "1-3", "1-3, 5, 10-12"
  */
 fn format_verse_ranges(ranges: &[VerseRange]) -> String {
-    ranges.iter()
+    ranges
+        .iter()
         .map(|range| {
             if range.start == range.end {
                 range.start.to_string()
@@ -382,4 +384,4 @@ fn format_verse_ranges(ranges: &[VerseRange]) -> String {
         })
         .collect::<Vec<_>>()
         .join(", ")
-}
\ No newline at end of file
+}
diff --git a/site/src/components/translation_switcher.rs b/site/src/components/translation_switcher.rs
index a15ae5c..67087ff 100644
--- a/site/src/components/translation_switcher.rs
+++ b/site/src/components/translation_switcher.rs
@@ -1,43 +1,47 @@
-use leptos::prelude::*;
 use crate::storage::{
-    get_selected_translation, get_downloaded_translations,
-    switch_bible_translation, set_selected_translation,
-    get_translations
+    get_downloaded_translations, get_selected_translation, get_translations,
+    set_selected_translation, switch_bible_translation,
 };
+use leptos::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 
 #[component]
 pub fn TranslationSwitcher() -> impl IntoView {
     let downloaded_translations = get_downloaded_translations();
-    
+
     // Only show if there are multiple downloaded translations
     if downloaded_translations.len() <= 1 {
         return view! { <></> }.into_any();
     }
-    
+
     let (is_open, set_is_open) = signal(false);
     let (is_switching, set_is_switching) = signal(false);
-    let current_translation = signal(get_selected_translation().unwrap_or_else(|| "sv".to_string())).0;
-    
+    let current_translation =
+        signal(get_selected_translation().unwrap_or_else(|| "sv".to_string())).0;
+
     // Get translation details
     let all_translations = get_translations();
-    let available_translations = signal(all_translations
-        .into_iter()
-        .filter(|t| downloaded_translations.contains(&t.short_name))
-        .collect::<Vec<_>>()).0;
-    
-    let current_translation_name = available_translations.get()
+    let available_translations = signal(
+        all_translations
+            .into_iter()
+            .filter(|t| downloaded_translations.contains(&t.short_name))
+            .collect::<Vec<_>>(),
+    )
+    .0;
+
+    let current_translation_name = available_translations
+        .get()
         .iter()
         .find(|t| t.short_name == current_translation.get())
         .map(|t| t.name.clone())
         .unwrap_or_else(|| "Unknown".to_string());
-    
+
     let handle_translation_switch = move |translation_short_name: String| {
         set_is_switching.set(true);
         set_is_open.set(false);
-        
+
         let _ = set_selected_translation(&translation_short_name);
-        
+
         spawn_local(async move {
             if let Err(e) = switch_bible_translation(&translation_short_name).await {
                 leptos::logging::error!("Failed to switch translation: {}", e);
@@ -45,7 +49,7 @@ pub fn TranslationSwitcher() -> impl IntoView {
             set_is_switching.set(false);
         });
     };
-    
+
     view! {
         <div class="relative">
             <button
@@ -63,7 +67,7 @@ pub fn TranslationSwitcher() -> impl IntoView {
                     <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path>
                 </svg>
             </button>
-            
+
             <Show
                 when=move || is_open.get()
                 fallback=|| view! { <></> }
@@ -79,7 +83,7 @@ pub fn TranslationSwitcher() -> impl IntoView {
                             children=move |translation| {
                                 let is_current = translation.short_name == current_translation.get();
                                 let short_name = translation.short_name.clone();
-                                
+
                                 view! {
                                     <button
                                         class=if is_current { "w-full text-left px-3 py-2 text-sm bg-blue-50 text-blue-700" } else { "w-full text-left px-3 py-2 text-sm hover:bg-gray-100 transition-colors text-gray-700" }
@@ -119,17 +123,17 @@ pub fn TranslationSwitcher() -> impl IntoView {
                     </div>
                 </div>
             </Show>
-            
+
             // Click outside to close
             <Show
                 when=move || is_open.get()
                 fallback=|| view! { <></> }
             >
-                <div 
+                <div
                     class="fixed inset-0 z-40"
                     on:click=move |_| set_is_open.set(false)
                 />
             </Show>
         </div>
     }.into_any()
-}
\ No newline at end of file
+}
diff --git a/site/src/core/bible_core.rs b/site/src/core/bible_core.rs
index c0bf83c..9920a26 100644
--- a/site/src/core/bible_core.rs
+++ b/site/src/core/bible_core.rs
@@ -1,10 +1,10 @@
+use crate::core::types::Language;
+use crate::translation_map::translation::Translation;
 use leptos::prelude::*;
 use leptos_router::hooks::{use_location, use_params_map};
 use serde::{Deserialize, Serialize};
 use std::sync::OnceLock;
 use urlencoding::{decode, encode};
-use crate::core::types::Language;
-use crate::translation_map::translation::Translation;
 
 pub static BIBLE: OnceLock<Bible> = OnceLock::new();
 static CURRENT_BIBLE_SIGNAL: OnceLock<RwSignal<Option<Bible>>> = OnceLock::new();
@@ -54,28 +54,28 @@ impl Bible {
     /// Apply name translations to all books and chapters based on the specified language
     pub fn translate_names(mut self, language: Language) -> Self {
         let translation = Translation::from_language(language);
-        
+
         for book in &mut self.books {
             // Translate book names by trying the lowercase underscore version first
             let lookup_key = book.name.to_lowercase().replace(' ', "_");
             if let Some(translated_book_name) = translation.get_book(&lookup_key) {
                 book.name = translated_book_name.to_string();
             }
-            
+
             // Update chapter names to match the new book names
             for chapter in &mut book.chapters {
                 // Extract the chapter number from the current name
                 let chapter_number = chapter.chapter;
                 // Update the chapter name to use the translated book name
                 chapter.name = format!("{} {}", book.name, chapter_number);
-                
+
                 // Also update verse names to match
                 for verse in &mut chapter.verses {
                     verse.name = chapter.name.clone();
                 }
             }
         }
-        
+
         self
     }
 }
@@ -413,8 +413,8 @@ impl Bible {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use proptest::prelude::*;
     use crate::core::types::Language;
+    use proptest::prelude::*;
 
     #[test]
     fn test_verse_range_from_string() {
@@ -784,49 +784,41 @@ mod tests {
             books: vec![
                 Book {
                     name: "Genesis".to_string(),
-                    chapters: vec![
-                        Chapter {
+                    chapters: vec![Chapter {
+                        chapter: 1,
+                        name: "Genesis 1".to_string(),
+                        verses: vec![Verse {
+                            verse: 1,
                             chapter: 1,
                             name: "Genesis 1".to_string(),
-                            verses: vec![
-                                Verse {
-                                    verse: 1,
-                                    chapter: 1,
-                                    name: "Genesis 1".to_string(),
-                                    text: "In the beginning...".to_string(),
-                                }
-                            ]
-                        }
-                    ]
+                            text: "In the beginning...".to_string(),
+                        }],
+                    }],
                 },
                 Book {
                     name: "Matthew".to_string(),
-                    chapters: vec![
-                        Chapter {
+                    chapters: vec![Chapter {
+                        chapter: 1,
+                        name: "Matthew 1".to_string(),
+                        verses: vec![Verse {
+                            verse: 1,
                             chapter: 1,
                             name: "Matthew 1".to_string(),
-                            verses: vec![
-                                Verse {
-                                    verse: 1,
-                                    chapter: 1,
-                                    name: "Matthew 1".to_string(),
-                                    text: "The book of the generation...".to_string(),
-                                }
-                            ]
-                        }
-                    ]
-                }
-            ]
+                            text: "The book of the generation...".to_string(),
+                        }],
+                    }],
+                },
+            ],
         };
 
         // Test Dutch translation
         let dutch_bible = bible.clone().translate_names(Language::Dutch);
-        
+
         // Genesis should become "Genesis" (already matches Dutch)
         assert_eq!(dutch_bible.books[0].name, "Genesis");
         assert_eq!(dutch_bible.books[0].chapters[0].name, "Genesis 1");
         assert_eq!(dutch_bible.books[0].chapters[0].verses[0].name, "Genesis 1");
-        
+
         // Matthew should become "Matteüs"
         assert_eq!(dutch_bible.books[1].name, "Matteüs");
         assert_eq!(dutch_bible.books[1].chapters[0].name, "Matteüs 1");
@@ -834,7 +826,7 @@ mod tests {
 
         // Test English translation
         let english_bible = bible.translate_names(Language::English);
-        
+
         // Names should remain the same for English
         assert_eq!(english_bible.books[0].name, "Genesis");
         assert_eq!(english_bible.books[1].name, "Matthew");
diff --git a/site/src/core/cross_references.rs b/site/src/core/cross_references.rs
index 32f6d40..1e25c70 100644
--- a/site/src/core/cross_references.rs
+++ b/site/src/core/cross_references.rs
@@ -6,34 +6,31 @@ pub fn load_cross_references() -> Result<crate::core::types::References, &'stati
     Ok(get_compiled_cross_references().clone())
 }
 
-
-
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::core::types::{VerseId};
+    use crate::core::types::VerseId;
 
     #[test]
     fn test_load_compiled_cross_references() {
         // This test verifies we can load the compile-time parsed cross-references
         let references = load_cross_references().unwrap();
-        
+
         // The file should have many references
         assert!(!references.0.is_empty());
-        
+
         // Check that Genesis 1:1 has references (should be one of the most referenced verses)
         let gen_1_1_key = VerseId::from_book_name("Genesis", 1, 1).unwrap();
-        
+
         if let Some(gen_1_1_refs) = references.0.get(&gen_1_1_key) {
             assert!(!gen_1_1_refs.is_empty());
-            
+
             // Verify at least one reference has proper structure
             let first_ref = &gen_1_1_refs[0];
             assert!(!first_ref.to_book_name.is_empty());
             assert!(first_ref.to_chapter > 0);
             assert!(first_ref.to_verse_start > 0);
-            
+
             // Genesis 1:1 should have many popular cross-references
             println!("Genesis 1:1 has {} cross-references", gen_1_1_refs.len());
             assert!(gen_1_1_refs.len() > 10); // Should have many references
@@ -46,61 +43,64 @@ mod tests {
     fn test_compile_time_performance() {
         // Test that accessing cross-references is fast (binary deserialization)
         use std::time::Instant;
-        
+
         let start = Instant::now();
         let references = load_cross_references().unwrap();
         let duration = start.elapsed();
-        
+
         // Should be much faster than text parsing (binary deserialization vs text parsing)
         assert!(duration.as_millis() < 500); // Should take less than 500ms
         assert!(!references.0.is_empty());
-        
+
         println!("Binary cross-references loaded in {:?}", duration);
-        
+
         // Test subsequent access should be even faster (cached)
         let start2 = Instant::now();
         let _references2 = load_cross_references().unwrap();
         let duration2 = start2.elapsed();
-        
+
         // Subsequent accesses should be faster due to OnceLock caching
         assert!(duration2.as_millis() < 50);
         println!("Cached cross-references loaded in {:?}", duration2);
     }
 
-    #[test] 
+    #[test]
     fn test_cross_references_data_integrity() {
         let references = load_cross_references().unwrap();
-        
+
         // Test a few known cross-references to ensure data integrity
         let gen_1_1_key = VerseId::from_book_name("Genesis", 1, 1).unwrap();
-        
+
         if let Some(gen_1_1_refs) = references.0.get(&gen_1_1_key) {
             // Should contain references to John 1:1-3 (one of the most popular)
-            let has_john_ref = gen_1_1_refs.iter().any(|r| {
-                r.to_book_name == "John" && r.to_chapter == 1 && r.to_verse_start == 1
-            });
-            
+            let has_john_ref = gen_1_1_refs
+                .iter()
+                .any(|r| r.to_book_name == "John" && r.to_chapter == 1 && r.to_verse_start == 1);
+
             // Should contain references to Hebrews 11:3
             let has_hebrews_ref = gen_1_1_refs.iter().any(|r| {
                 r.to_book_name == "Hebrews" && r.to_chapter == 11 && r.to_verse_start == 3
             });
-            
+
             if has_john_ref {
                 println!("✓ Found John 1:1 cross-reference for Genesis 1:1");
             }
             if has_hebrews_ref {
                 println!("✓ Found Hebrews 11:3 cross-reference for Genesis 1:1");
             }
-            
+
             // At least one of these popular cross-references should exist
-            assert!(has_john_ref || has_hebrews_ref, "Missing expected cross-references for Genesis 1:1");
+            assert!(
+                has_john_ref || has_hebrews_ref,
+                "Missing expected cross-references for Genesis 1:1"
+            );
         }
     }
 
     #[test]
     fn test_numbered_books_cross_references() {
         let references = load_cross_references().unwrap();
-        
+
         // Test 1 Samuel 1:10 specifically (from the example data provided)
         // 1Sam.1.10    2Kgs.20.3    3
         // 1Sam.1.10    Job.9.18    3
@@ -108,39 +108,43 @@ mod tests {
         // 1Sam.1.10    Gen.50.10    1
         // 1Sam.1.10    Job.10.1    10
         let samuel_1_1_10_key = VerseId::from_book_name("1 Samuel", 1, 10).unwrap();
-        
+
         println!("Testing cross-references for 1 Samuel 1:10...");
         println!("VerseId key: {:?}", samuel_1_1_10_key);
-        
+
         if let Some(samuel_refs) = references.0.get(&samuel_1_1_10_key) {
-            println!("Found {} cross-references for 1 Samuel 1:10:", samuel_refs.len());
-            
+            println!(
+                "Found {} cross-references for 1 Samuel 1:10:",
+                samuel_refs.len()
+            );
+
             for (i, ref_) in samuel_refs.iter().enumerate() {
-                println!("  {}. {} {}:{}", 
-                    i + 1, 
-                    ref_.to_book_name, 
-                    ref_.to_chapter, 
+                println!(
+                    "  {}. {} {}:{}",
+                    i + 1,
+                    ref_.to_book_name,
+                    ref_.to_chapter,
                     ref_.to_verse_start
                 );
             }
-            
+
             // Check for expected cross-references from the example data
             let has_2_kings_20_3 = samuel_refs.iter().any(|r| {
                 r.to_book_name == "2 Kings" && r.to_chapter == 20 && r.to_verse_start == 3
             });
-            
-            let has_job_9_18 = samuel_refs.iter().any(|r| {
-                r.to_book_name == "Job" && r.to_chapter == 9 && r.to_verse_start == 18
-            });
-            
-            let has_luke_22_44 = samuel_refs.iter().any(|r| {
-                r.to_book_name == "Luke" && r.to_chapter == 22 && r.to_verse_start == 44
-            });
-            
+
+            let has_job_9_18 = samuel_refs
+                .iter()
+                .any(|r| r.to_book_name == "Job" && r.to_chapter == 9 && r.to_verse_start == 18);
+
+            let has_luke_22_44 = samuel_refs
+                .iter()
+                .any(|r| r.to_book_name == "Luke" && r.to_chapter == 22 && r.to_verse_start == 44);
+
             let has_genesis_50_10 = samuel_refs.iter().any(|r| {
                 r.to_book_name == "Genesis" && r.to_chapter == 50 && r.to_verse_start == 10
             });
-            
+
             if has_2_kings_20_3 {
                 println!("✓ Found 2 Kings 20:3 cross-reference");
             }
@@ -153,48 +157,52 @@ mod tests {
             if has_genesis_50_10 {
                 println!("✓ Found Genesis 50:10 cross-reference");
             }
-            
+
             // At least one of these expected cross-references should exist
             assert!(
                 has_2_kings_20_3 || has_job_9_18 || has_luke_22_44 || has_genesis_50_10,
                 "Missing expected cross-references for 1 Samuel 1:10. Expected at least one of: 2 Kings 20:3, Job 9:18, Luke 22:44, Genesis 50:10"
             );
-            
         } else {
             panic!("No cross-references found for 1 Samuel 1:10! This indicates the numbered book parsing is broken.");
         }
-        
+
         // Also test 1 Samuel 1:11 from the example data
         // 1Sam.1.11    Ps.25.18    5
         // 1Sam.1.11    Eccl.5.4    8
         // 1Sam.1.11    Gen.28.20    5
         let samuel_1_1_11_key = VerseId::from_book_name("1 Samuel", 1, 11).unwrap();
-        
+
         println!("\nTesting cross-references for 1 Samuel 1:11...");
-        
+
         if let Some(samuel_refs_11) = references.0.get(&samuel_1_1_11_key) {
-            println!("Found {} cross-references for 1 Samuel 1:11:", samuel_refs_11.len());
-            
+            println!(
+                "Found {} cross-references for 1 Samuel 1:11:",
+                samuel_refs_11.len()
+            );
+
             let has_psalm_25_18 = samuel_refs_11.iter().any(|r| {
                 r.to_book_name == "Psalms" && r.to_chapter == 25 && r.to_verse_start == 18
             });
-            
+
             let has_ecclesiastes_5_4 = samuel_refs_11.iter().any(|r| {
                 r.to_book_name == "Ecclesiastes" && r.to_chapter == 5 && r.to_verse_start == 4
             });
-            
+
             if has_psalm_25_18 {
                 println!("✓ Found Psalms 25:18 cross-reference");
             }
             if has_ecclesiastes_5_4 {
                 println!("✓ Found Ecclesiastes 5:4 cross-reference");
             }
-            
+
             // Should have at least some cross-references
-            assert!(!samuel_refs_11.is_empty(), "1 Samuel 1:11 should have cross-references");
-            
+            assert!(
+                !samuel_refs_11.is_empty(),
+                "1 Samuel 1:11 should have cross-references"
+            );
         } else {
             println!("⚠ No cross-references found for 1 Samuel 1:11 (this might be expected if not in the data)");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/core/mod.rs b/site/src/core/mod.rs
index 776481e..b4fb773 100644
--- a/site/src/core/mod.rs
+++ b/site/src/core/mod.rs
@@ -1,7 +1,7 @@
 pub mod bible_core;
-pub mod types;
 pub mod cross_references;
+pub mod types;
 
 pub use bible_core::*;
 pub use cross_references::*;
-// pub use types::{ParamParseError};
\ No newline at end of file
+// pub use types::{ParamParseError};
diff --git a/site/src/core/types.rs b/site/src/core/types.rs
index a46ad31..39a24bf 100644
--- a/site/src/core/types.rs
+++ b/site/src/core/types.rs
@@ -27,7 +27,6 @@ pub struct Verse {
     pub text: String,
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct BibleTranslation {
     pub name: String,
@@ -48,10 +47,6 @@ pub enum Language {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct References(pub HashMap<VerseId, Vec<Reference>>);
 
-
-
-
-
 /// Highly optimized verse identifier using a single u32
 /// Format: book_id (8 bits) | chapter (12 bits) | verse (12 bits)
 /// Supports: 256 books, 4096 chapters, 4096 verses
@@ -64,27 +59,26 @@ impl VerseId {
         let packed = ((book_id as u32) << 24) | ((chapter & 0xFFF) << 12) | (verse & 0xFFF);
         VerseId(packed)
     }
-    
+
     pub fn from_book_name(book_name: &str, chapter: u32, verse: u32) -> Option<Self> {
         let book_id = book_name_to_id(book_name)?;
         Some(Self::new(book_id, chapter, verse))
     }
-    
+
     /// Extract book_id from packed VerseId
     pub fn book_id(&self) -> u8 {
         ((self.0 >> 24) & 0xFF) as u8
     }
-    
+
     /// Extract chapter from packed VerseId
     pub fn chapter(&self) -> u32 {
         (self.0 >> 12) & 0xFFF
     }
-    
+
     /// Extract verse from packed VerseId
     pub fn verse(&self) -> u32 {
         self.0 & 0xFFF
     }
-    
 }
 
 /// Convert book name to compact ID for faster lookups
@@ -130,7 +124,7 @@ pub fn book_name_to_id(book_name: &str) -> Option<u8> {
         "Haggai" => Some(37),
         "Zechariah" => Some(38),
         "Malachi" => Some(39),
-        
+
         // New Testament
         "Matthew" => Some(40),
         "Mark" => Some(41),
@@ -159,12 +153,11 @@ pub fn book_name_to_id(book_name: &str) -> Option<u8> {
         "3 John" => Some(64),
         "Jude" => Some(65),
         "Revelation" => Some(66),
-        
+
         _ => None,
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -173,7 +166,7 @@ mod tests {
     fn test_verse_id_packing() {
         // Test Genesis 1:1 (book_id=1, chapter=1, verse=1)
         let verse_id = VerseId::new(1, 1, 1);
-        
+
         // Test the packed value is correct
         assert_eq!(verse_id.0, 0x01001001); // Expected packed value
     }
@@ -182,7 +175,7 @@ mod tests {
     fn test_verse_id_from_book_name() {
         // Test creating VerseId from book name
         let verse_id = VerseId::from_book_name("Genesis", 1, 1).unwrap();
-        
+
         // Test the packed value is correct
         assert_eq!(verse_id.0, 0x01001001);
     }
@@ -191,7 +184,7 @@ mod tests {
     fn test_verse_id_large_values() {
         // Test maximum supported values (12 bits = 4095)
         let verse_id = VerseId::new(66, 4095, 4095);
-        
+
         // Test the packed value
         assert_eq!(verse_id.0, 0x42FFFFFF); // book_id=66, chapter=4095, verse=4095
     }
@@ -210,13 +203,13 @@ mod tests {
     fn test_verse_id_hash_performance() {
         // Test that VerseId is much more efficient for hashing
         use std::collections::HashMap;
-        
+
         let mut map: HashMap<VerseId, Vec<Reference>> = HashMap::new();
         let verse_id = VerseId::new(1, 1, 1);
-        
+
         map.insert(verse_id, vec![]);
         assert!(map.contains_key(&verse_id));
-        
+
         // The u32 should be much faster to hash than the old String-based key
         assert_eq!(verse_id.0, 0x01001001); // Expected packed value
     }
@@ -236,5 +229,5 @@ pub struct Reference {
     pub to_chapter: u32,
     pub to_verse_start: u32,
     pub to_verse_end: Option<u32>, // None for single verse, Some for verse ranges
-    pub votes: i32, // Can be negative based on the data
+    pub votes: i32,                // Can be negative based on the data
 }
diff --git a/site/src/instructions/keyboard_map.rs b/site/src/instructions/keyboard_map.rs
index 1526e32..08385f6 100644
--- a/site/src/instructions/keyboard_map.rs
+++ b/site/src/instructions/keyboard_map.rs
@@ -21,7 +21,7 @@ impl KeyCombination {
             alt: e.alt_key(),
         }
     }
-    
+
     pub fn simple(key: &str) -> Self {
         Self {
             key: key.to_string(),
@@ -31,7 +31,7 @@ impl KeyCombination {
             alt: false,
         }
     }
-    
+
     pub fn with_shift(key: &str) -> Self {
         Self {
             key: key.to_string(),
@@ -41,7 +41,7 @@ impl KeyCombination {
             alt: false,
         }
     }
-    
+
     pub fn with_ctrl(key: &str) -> Self {
         Self {
             key: key.to_string(),
@@ -51,7 +51,7 @@ impl KeyCombination {
             alt: false,
         }
     }
-    
+
     pub fn with_meta(key: &str) -> Self {
         Self {
             key: key.to_string(),
@@ -61,7 +61,7 @@ impl KeyCombination {
             alt: false,
         }
     }
-    
+
     pub fn with_ctrl_shift(key: &str) -> Self {
         Self {
             key: key.to_string(),
@@ -71,7 +71,7 @@ impl KeyCombination {
             alt: false,
         }
     }
-    
+
     pub fn with_meta_or_ctrl(key: &str) -> Self {
         // For cross-platform compatibility (Cmd on Mac, Ctrl on others)
         Self {
@@ -96,7 +96,7 @@ impl KeyboardMapper {
                 return Some(Instruction::GoToVerse(verse_id));
             }
         }
-        
+
         match (
             combination.key.as_str(),
             combination.shift,
@@ -109,38 +109,38 @@ impl KeyboardMapper {
             ("ArrowLeft" | "h", false, false, false, false) => Some(Instruction::PreviousChapter),
             ("ArrowDown" | "j", false, false, false, false) => Some(Instruction::NextVerse),
             ("ArrowUp" | "k", false, false, false, false) => Some(Instruction::PreviousVerse),
-            
+
             // Book navigation
             ("H", true, false, false, false) => Some(Instruction::PreviousBook),
             ("L", true, false, false, false) => Some(Instruction::NextBook),
-            
+
             // Chapter jumping
             ("G", true, false, false, false) => Some(Instruction::EndOfChapter),
-            
+
             // Special navigation
             ("s", false, false, false, false) => Some(Instruction::SwitchToPreviousChapter),
-            
+
             // Copy operations
             ("y", false, false, false, false) => Some(Instruction::CopyRawVerse),
             ("Y", true, false, false, false) | ("y", true, false, false, false) => {
                 Some(Instruction::CopyVerseWithReference)
             }
-            
+
             // UI toggles
             ("b", false, true, false, false) => Some(Instruction::ToggleSidebar),
             ("r", false, false, false, false) => Some(Instruction::ToggleCrossReferences),
             ("R", true, true, false, false) => Some(Instruction::ToggleCrossReferences),
             ("c", false, false, false, false) => Some(Instruction::ToggleTranslationComparison),
-            
+
             // Command palette (Cmd/Ctrl+K)
             ("k", false, true, false, false) | ("k", false, false, true, false) => {
                 Some(Instruction::ToggleBiblePallate)
             }
-            
+
             _ => None,
         }
     }
-    
+
     pub fn should_handle_key(combination: &KeyCombination) -> bool {
         KeyboardMapper::map_to_instruction(combination).is_some()
     }
diff --git a/site/src/instructions/logic/event_handlers.rs b/site/src/instructions/logic/event_handlers.rs
index 0c7b5fe..4fbb36c 100644
--- a/site/src/instructions/logic/event_handlers.rs
+++ b/site/src/instructions/logic/event_handlers.rs
@@ -1,9 +1,9 @@
+use crate::instructions::logic::export_handlers::{
+    handle_export_linked_markdown, handle_export_to_markdown, handle_export_to_pdf,
+};
 use leptos::prelude::*;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
-use crate::instructions::logic::export_handlers::{
-    handle_export_to_pdf, handle_export_to_markdown, handle_export_linked_markdown
-};
 
 /// Set up custom event listeners for export functionality
 pub fn setup_export_event_listeners(
@@ -73,4 +73,4 @@ pub fn setup_export_event_listeners(
             linked_markdown_event_handler.forget();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/logic/export_handlers.rs b/site/src/instructions/logic/export_handlers.rs
index ccd3283..c70cd75 100644
--- a/site/src/instructions/logic/export_handlers.rs
+++ b/site/src/instructions/logic/export_handlers.rs
@@ -110,7 +110,8 @@ pub fn handle_export_to_markdown(
         };
 
         web_sys::console::log_1(&"🔄 Starting Markdown generation...".into());
-        match crate::instructions::logic::export_bible_to_markdown(&bible, Some(progress_callback)) {
+        match crate::instructions::logic::export_bible_to_markdown(&bible, Some(progress_callback))
+        {
             Ok(markdown_content) => {
                 web_sys::console::log_1(
                     &format!(
@@ -186,7 +187,10 @@ pub fn handle_export_linked_markdown(
         };
 
         web_sys::console::log_1(&"🔄 Starting Linked Markdown generation...".into());
-        match crate::instructions::logic::export_bible_to_linked_markdown(&bible, Some(progress_callback)) {
+        match crate::instructions::logic::export_bible_to_linked_markdown(
+            &bible,
+            Some(progress_callback),
+        ) {
             Ok(linked_export) => {
                 web_sys::console::log_1(
                     &format!(
@@ -217,7 +221,10 @@ pub fn handle_export_linked_markdown(
                 web_sys::console::log_1(&format!("📁 Generated filename: {}", filename).into());
 
                 web_sys::console::log_1(&"🔽 Triggering Linked Markdown download...".into());
-                crate::instructions::logic::trigger_linked_markdown_download(linked_export, &filename);
+                crate::instructions::logic::trigger_linked_markdown_download(
+                    linked_export,
+                    &filename,
+                );
             }
             Err(e) => {
                 web_sys::console::log_1(
@@ -228,4 +235,4 @@ pub fn handle_export_linked_markdown(
         }
         set_is_pdf_exporting.set(false);
     });
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/logic/linked_markdown_export.rs b/site/src/instructions/logic/linked_markdown_export.rs
index f0d2ddc..3b38410 100644
--- a/site/src/instructions/logic/linked_markdown_export.rs
+++ b/site/src/instructions/logic/linked_markdown_export.rs
@@ -1,27 +1,34 @@
 use crate::core::bible_core::Bible;
 use crate::storage::translations::get_current_translation;
 use crate::translation_map::translation::Translation;
-use web_sys::console;
 use std::collections::HashMap;
 use wasm_bindgen::prelude::*;
-
+use web_sys::console;
 
 /// Get translated book name based on current translation
 fn get_translated_book_name(book_name: &str) -> String {
-    console::log_1(&format!("🔄 Translating book name for linked markdown: {}", book_name).into());
-    
+    console::log_1(
+        &format!(
+            "🔄 Translating book name for linked markdown: {}",
+            book_name
+        )
+        .into(),
+    );
+
     if let Some(current_translation) = get_current_translation() {
         if let Some(first_language) = current_translation.languages.first() {
             let translation = Translation::from_language(*first_language);
             let key = book_name.to_lowercase();
-            
+
             if let Some(translated_name) = translation.get(&key) {
-                console::log_1(&format!("✅ Found translation: {} → {}", book_name, translated_name).into());
+                console::log_1(
+                    &format!("✅ Found translation: {} → {}", book_name, translated_name).into(),
+                );
                 return translated_name;
             }
         }
     }
-    
+
     // Return original name if no translation found
     book_name.to_string()
 }
@@ -34,126 +41,189 @@ pub struct LinkedMarkdownExport {
 }
 
 /// Core Linked Markdown export business logic
-pub fn export_bible_to_linked_markdown<F>(bible: &Bible, progress_callback: Option<F>) -> Result<LinkedMarkdownExport, Box<dyn std::error::Error>>
+pub fn export_bible_to_linked_markdown<F>(
+    bible: &Bible,
+    progress_callback: Option<F>,
+) -> Result<LinkedMarkdownExport, Box<dyn std::error::Error>>
 where
     F: Fn(f32, String) + Clone + 'static,
 {
     console::log_1(&"🚀 Starting Linked Markdown export process".into());
     console::log_1(&format!("📖 Bible has {} books", bible.books.len()).into());
-    
+
     // Report initial progress
     if let Some(ref callback) = progress_callback {
         callback(0.0, "Initializing Linked Markdown export...".to_string());
     }
-    
+
     let translation_info = get_current_translation().unwrap_or_else(|| {
         console::log_1(&"⚠️ No current translation found, using default".into());
         crate::storage::translation_storage::BibleTranslation {
             name: "Unknown Bible".to_string(),
-            short_name: "unknown".to_string(), 
+            short_name: "unknown".to_string(),
             release_year: 2024,
             languages: vec![],
             iagon: "".to_string(),
         }
     });
-    
+
     console::log_1(&format!("📚 Using translation: {}", translation_info.name).into());
-    
+
     let folder_name = translation_info.name.to_lowercase().replace(" ", "_");
     let short_name = &translation_info.short_name;
     let mut files = HashMap::new();
-    
+
     if let Some(ref callback) = progress_callback {
         callback(0.05, "Creating index file...".to_string());
     }
-    
+
     // Create main index file (e.g., "statenvertaling.md")
     let main_filename = format!("{}.md", folder_name);
     let mut main_content = String::new();
-    
+
     // Add metadata
     main_content.push_str(&format!("# {}\n\n", translation_info.name));
-    main_content.push_str(&format!("**Published:** {}\n", translation_info.release_year));
-    main_content.push_str(&format!("**Release Year:** {}\n", translation_info.release_year));
+    main_content.push_str(&format!(
+        "**Published:** {}\n",
+        translation_info.release_year
+    ));
+    main_content.push_str(&format!(
+        "**Release Year:** {}\n",
+        translation_info.release_year
+    ));
     main_content.push_str("\n## Book Index\n\n");
-    
+
     // Add book index with links
     for book in &bible.books {
         let translated_book_name = get_translated_book_name(&book.name);
-        let book_filename = format!("{} {}", translated_book_name.to_lowercase().replace(" ", "_"), short_name);
+        let book_filename = format!(
+            "{} {}",
+            translated_book_name.to_lowercase().replace(" ", "_"),
+            short_name
+        );
         main_content.push_str(&format!("- [[{}]]\n", book_filename));
     }
-    
+
     files.insert(main_filename, main_content);
-    
+
     if let Some(ref callback) = progress_callback {
         callback(0.1, "Processing books and chapters...".to_string());
     }
-    
+
     let mut book_count = 0;
     let mut chapter_count = 0;
     let mut verse_count = 0;
-    
+
     // Process each book
     for book in &bible.books {
         book_count += 1;
-        console::log_1(&format!("📖 Processing book {}/{}: {}", book_count, bible.books.len(), book.name).into());
-        
+        console::log_1(
+            &format!(
+                "📖 Processing book {}/{}: {}",
+                book_count,
+                bible.books.len(),
+                book.name
+            )
+            .into(),
+        );
+
         // Report progress for current book (10% to 90% of total progress)
         let book_progress = 0.1 + (book_count as f32 / bible.books.len() as f32) * 0.8;
         if let Some(ref callback) = progress_callback {
-            callback(book_progress, format!("Processing {} ({}/{})", book.name, book_count, bible.books.len()));
+            callback(
+                book_progress,
+                format!(
+                    "Processing {} ({}/{})",
+                    book.name,
+                    book_count,
+                    bible.books.len()
+                ),
+            );
         }
-        
+
         let translated_book_name = get_translated_book_name(&book.name);
-        let book_filename = format!("{} {}.md", translated_book_name.to_lowercase().replace(" ", "_"), short_name);
-        
+        let book_filename = format!(
+            "{} {}.md",
+            translated_book_name.to_lowercase().replace(" ", "_"),
+            short_name
+        );
+
         // Create book index file
         let mut book_content = String::new();
         book_content.push_str(&format!("# {}\n\n", translated_book_name));
         book_content.push_str("## Chapter Index\n\n");
-        
+
         // Add chapter links
         for chapter in &book.chapters {
-            let chapter_filename = format!("{} {} {}", translated_book_name.to_lowercase().replace(" ", "_"), chapter.chapter, short_name);
+            let chapter_filename = format!(
+                "{} {} {}",
+                translated_book_name.to_lowercase().replace(" ", "_"),
+                chapter.chapter,
+                short_name
+            );
             book_content.push_str(&format!("- [[{}]]\n", chapter_filename));
         }
-        
+
         files.insert(book_filename, book_content);
-        
+
         // Process each chapter
         for (chapter_index, chapter) in book.chapters.iter().enumerate() {
             chapter_count += 1;
-            
-            let chapter_filename = format!("{} {} {}.md", translated_book_name.to_lowercase().replace(" ", "_"), chapter.chapter, short_name);
+
+            let chapter_filename = format!(
+                "{} {} {}.md",
+                translated_book_name.to_lowercase().replace(" ", "_"),
+                chapter.chapter,
+                short_name
+            );
             let mut chapter_content = String::new();
-            
+
             // Chapter title
-            chapter_content.push_str(&format!("# {} {}\n\n", translated_book_name, chapter.chapter));
-            
+            chapter_content.push_str(&format!(
+                "# {} {}\n\n",
+                translated_book_name, chapter.chapter
+            ));
+
             // Navigation links
             // Handle previous link
             if chapter_index > 0 {
                 // Previous chapter in same book
-                let prev_chapter_filename = format!("{} {} {}", translated_book_name.to_lowercase().replace(" ", "_"), book.chapters[chapter_index - 1].chapter, short_name);
+                let prev_chapter_filename = format!(
+                    "{} {} {}",
+                    translated_book_name.to_lowercase().replace(" ", "_"),
+                    book.chapters[chapter_index - 1].chapter,
+                    short_name
+                );
                 chapter_content.push_str(&format!("previous: [[{}]]\n", prev_chapter_filename));
             } else {
                 // First chapter of this book, try to link to last chapter of previous book
-                if book_count > 1 { // book_count is 1-based, so > 1 means there's a previous book
+                if book_count > 1 {
+                    // book_count is 1-based, so > 1 means there's a previous book
                     let prev_book = &bible.books[book_count - 2]; // book_count - 2 gets previous book (0-indexed)
                     let prev_book_translated = get_translated_book_name(&prev_book.name);
                     if !prev_book.chapters.is_empty() {
                         let last_chapter = prev_book.chapters.last().unwrap();
-                        let prev_chapter_filename = format!("{} {} {}", prev_book_translated.to_lowercase().replace(" ", "_"), last_chapter.chapter, short_name);
-                        chapter_content.push_str(&format!("previous: [[{}]]\n", prev_chapter_filename));
+                        let prev_chapter_filename = format!(
+                            "{} {} {}",
+                            prev_book_translated.to_lowercase().replace(" ", "_"),
+                            last_chapter.chapter,
+                            short_name
+                        );
+                        chapter_content
+                            .push_str(&format!("previous: [[{}]]\n", prev_chapter_filename));
                     }
                 }
             }
-            
+
             // Handle next link
             if chapter_index < book.chapters.len() - 1 {
                 // Next chapter in same book
-                let next_chapter_filename = format!("{} {} {}", translated_book_name.to_lowercase().replace(" ", "_"), book.chapters[chapter_index + 1].chapter, short_name);
+                let next_chapter_filename = format!(
+                    "{} {} {}",
+                    translated_book_name.to_lowercase().replace(" ", "_"),
+                    book.chapters[chapter_index + 1].chapter,
+                    short_name
+                );
                 chapter_content.push_str(&format!("next: [[{}]]\n", next_chapter_filename));
             } else {
                 // Last chapter of this book, try to link to first chapter of next book
@@ -161,35 +231,43 @@ where
                     let next_book = &bible.books[book_count]; // book_count is 1-based, so this gets next book
                     let next_book_translated = get_translated_book_name(&next_book.name);
                     if !next_book.chapters.is_empty() {
-                        let next_chapter_filename = format!("{} {} {}", next_book_translated.to_lowercase().replace(" ", "_"), next_book.chapters[0].chapter, short_name);
+                        let next_chapter_filename = format!(
+                            "{} {} {}",
+                            next_book_translated.to_lowercase().replace(" ", "_"),
+                            next_book.chapters[0].chapter,
+                            short_name
+                        );
                         chapter_content.push_str(&format!("next: [[{}]]\n", next_chapter_filename));
                     }
                 }
             }
-            
+
             chapter_content.push_str("\n");
-            
+
             // Add verses
             for verse in &chapter.verses {
                 verse_count += 1;
                 chapter_content.push_str(&format!("{} {}\n", verse.verse, verse.text));
             }
-            
+
             files.insert(chapter_filename, chapter_content);
         }
     }
-    
-    console::log_1(&format!("📊 Linked Markdown export complete! Processed {} books, {} chapters, {} verses", book_count, chapter_count, verse_count).into());
+
+    console::log_1(
+        &format!(
+            "📊 Linked Markdown export complete! Processed {} books, {} chapters, {} verses",
+            book_count, chapter_count, verse_count
+        )
+        .into(),
+    );
     console::log_1(&format!("📁 Created {} files", files.len()).into());
-    
+
     if let Some(ref callback) = progress_callback {
         callback(1.0, "Linked Markdown export complete!".to_string());
     }
-    
-    Ok(LinkedMarkdownExport {
-        files,
-        folder_name,
-    })
+
+    Ok(LinkedMarkdownExport { files, folder_name })
 }
 
 /// Convenience function for exporting linked markdown without progress tracking
@@ -198,12 +276,12 @@ where
 /// Trigger Linked Markdown ZIP download in the browser
 pub fn trigger_linked_markdown_download(export: LinkedMarkdownExport, filename: &str) {
     use web_sys::window;
-    
+
     console::log_1(&"🔽 Starting Linked Markdown ZIP export process".into());
     console::log_1(&format!("📁 Folder name: {}", export.folder_name).into());
     console::log_1(&format!("📄 Number of files: {}", export.files.len()).into());
     console::log_1(&format!("📦 ZIP filename: {}", filename).into());
-    
+
     let _window = match window() {
         Some(w) => {
             console::log_1(&"✅ Window object obtained".into());
@@ -214,55 +292,70 @@ pub fn trigger_linked_markdown_download(export: LinkedMarkdownExport, filename:
             return;
         }
     };
-    
-    
+
     // Sort files for consistent ordering
     let mut sorted_files: Vec<_> = export.files.iter().collect();
     sorted_files.sort_by_key(|(filename, _)| *filename);
-    
+
     // Create a JavaScript object with all file data
     console::log_1(&"🗜️ Preparing files for ZIP creation...".into());
     console::log_1(&format!("🔍 Total files to process: {}", sorted_files.len()).into());
-    
+
     let files_obj = js_sys::Object::new();
-    
+
     for (i, (filename, content)) in sorted_files.iter().enumerate() {
         let file_path = format!("{}/{}", export.folder_name, filename);
-        console::log_1(&format!("📄 [{}/{}] Processing file: {}", i + 1, sorted_files.len(), file_path).into());
+        console::log_1(
+            &format!(
+                "📄 [{}/{}] Processing file: {}",
+                i + 1,
+                sorted_files.len(),
+                file_path
+            )
+            .into(),
+        );
         let preview = if content.len() > 50 {
             match content.char_indices().nth(50) {
                 Some((idx, _)) => &content[..idx],
-                None => content
+                None => content,
             }
         } else {
             content
         };
         console::log_1(&format!("📄 Content preview: {}...", preview).into());
-        
+
         // Convert content to Uint8Array
         let content_bytes = content.as_bytes();
         let uint8_array = js_sys::Uint8Array::new_with_length(content_bytes.len() as u32);
         uint8_array.copy_from(content_bytes);
-        
-        match js_sys::Reflect::set(&files_obj, &JsValue::from_str(&file_path), &uint8_array.into()) {
+
+        match js_sys::Reflect::set(
+            &files_obj,
+            &JsValue::from_str(&file_path),
+            &uint8_array.into(),
+        ) {
             Ok(_) => {
-                console::log_1(&format!("✅ Added file: {} ({} bytes)", file_path, content.len()).into());
+                console::log_1(
+                    &format!("✅ Added file: {} ({} bytes)", file_path, content.len()).into(),
+                );
             }
             Err(e) => {
                 console::log_1(&format!("❌ Failed to add file {}: {:?}", file_path, e).into());
             }
         }
     }
-    
+
     console::log_1(&format!("📦 Prepared {} files for ZIP creation", sorted_files.len()).into());
-    
+
     console::log_1(&"📦 Creating ZIP using JavaScript...".into());
-    
+
     // Call JavaScript function to create ZIP and download
     match create_and_download_zip(files_obj, filename) {
         Ok(_) => {
             console::log_1(&format!("🎉 ZIP creation successful! File: {}", filename).into());
-            console::log_1(&"📝 Extract the ZIP file to get individual markdown files for Obsidian.".into());
+            console::log_1(
+                &"📝 Extract the ZIP file to get individual markdown files for Obsidian.".into(),
+            );
         }
         Err(e) => {
             console::log_1(&format!("❌ Failed to create ZIP: {:?}", e).into());
@@ -274,4 +367,4 @@ pub fn trigger_linked_markdown_download(export: LinkedMarkdownExport, filename:
 extern "C" {
     #[wasm_bindgen(catch)]
     fn create_and_download_zip(files: js_sys::Object, filename: &str) -> Result<(), JsValue>;
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/logic/markdown_export.rs b/site/src/instructions/logic/markdown_export.rs
index 8802e95..6adddd1 100644
--- a/site/src/instructions/logic/markdown_export.rs
+++ b/site/src/instructions/logic/markdown_export.rs
@@ -3,24 +3,31 @@ use crate::storage::translations::get_current_translation;
 use crate::translation_map::translation::Translation;
 use web_sys::console;
 
-
 /// Get translated book name based on current translation
 fn get_translated_book_name(book_name: &str) -> String {
     console::log_1(&format!("🔄 Translating book name for markdown: {}", book_name).into());
-    
+
     if let Some(current_translation) = get_current_translation() {
-        console::log_1(&format!("📚 Current translation: {} ({:?})", current_translation.name, current_translation.languages).into());
-        
+        console::log_1(
+            &format!(
+                "📚 Current translation: {} ({:?})",
+                current_translation.name, current_translation.languages
+            )
+            .into(),
+        );
+
         if let Some(first_language) = current_translation.languages.first() {
             console::log_1(&format!("🌍 Using language: {:?}", first_language).into());
             let translation = Translation::from_language(*first_language);
-            
+
             // Convert book name to lowercase for mapping
             let key = book_name.to_lowercase();
             console::log_1(&format!("🔑 Looking up key: '{}'", key).into());
-            
+
             if let Some(translated_name) = translation.get(&key) {
-                console::log_1(&format!("✅ Found translation: {} → {}", book_name, translated_name).into());
+                console::log_1(
+                    &format!("✅ Found translation: {} → {}", book_name, translated_name).into(),
+                );
                 return translated_name;
             } else {
                 console::log_1(&format!("❌ No translation found for key: '{}'", key).into());
@@ -29,97 +36,138 @@ fn get_translated_book_name(book_name: &str) -> String {
     } else {
         console::log_1(&"❌ No current translation available".into());
     }
-    
+
     console::log_1(&format!("⏭️ Using original name: {}", book_name).into());
     // Return original name if no translation found
     book_name.to_string()
 }
 
 /// Core Markdown export business logic
-pub fn export_bible_to_markdown<F>(bible: &Bible, progress_callback: Option<F>) -> Result<String, Box<dyn std::error::Error>>
+pub fn export_bible_to_markdown<F>(
+    bible: &Bible,
+    progress_callback: Option<F>,
+) -> Result<String, Box<dyn std::error::Error>>
 where
     F: Fn(f32, String) + Clone + 'static,
 {
     console::log_1(&"🚀 Starting Markdown export process".into());
     console::log_1(&format!("📖 Bible has {} books", bible.books.len()).into());
-    
+
     // Report initial progress
     if let Some(ref callback) = progress_callback {
         callback(0.0, "Initializing Markdown export...".to_string());
     }
-    
+
     let translation_info = get_current_translation().unwrap_or_else(|| {
         console::log_1(&"⚠️ No current translation found, using default".into());
         crate::storage::translation_storage::BibleTranslation {
             name: "Unknown Bible".to_string(),
-            short_name: "unknown".to_string(), 
+            short_name: "unknown".to_string(),
             release_year: 2024,
             languages: vec![],
             iagon: "".to_string(),
         }
     });
-    
+
     console::log_1(&format!("📚 Using translation: {}", translation_info.name).into());
-    
+
     if let Some(ref callback) = progress_callback {
         callback(0.05, "Creating document structure...".to_string());
     }
-    
+
     let mut markdown = String::new();
-    
+
     if let Some(ref callback) = progress_callback {
         callback(0.1, "Processing books...".to_string());
     }
-    
+
     let mut book_count = 0;
     let mut chapter_count = 0;
     let mut verse_count = 0;
-    
+
     // Export all books, chapters, and verses
-    console::log_1(&format!("📖 Processing {} books for Markdown export...", bible.books.len()).into());
-    
+    console::log_1(
+        &format!(
+            "📖 Processing {} books for Markdown export...",
+            bible.books.len()
+        )
+        .into(),
+    );
+
     for book in &bible.books {
         book_count += 1;
-        console::log_1(&format!("📖 Processing book {}/{}: {}", book_count, bible.books.len(), book.name).into());
-        
+        console::log_1(
+            &format!(
+                "📖 Processing book {}/{}: {}",
+                book_count,
+                bible.books.len(),
+                book.name
+            )
+            .into(),
+        );
+
         // Report progress for current book (10% to 90% of total progress)
         let book_progress = 0.1 + (book_count as f32 / bible.books.len() as f32) * 0.8;
         if let Some(ref callback) = progress_callback {
-            callback(book_progress, format!("Processing {} ({}/{})", book.name, book_count, bible.books.len()));
+            callback(
+                book_progress,
+                format!(
+                    "Processing {} ({}/{})",
+                    book.name,
+                    book_count,
+                    bible.books.len()
+                ),
+            );
         }
-        
+
         // Book title - use translated name as # heading
         let translated_book_name = get_translated_book_name(&book.name);
         console::log_1(&format!("📖 Book: {} → {}", book.name, translated_book_name).into());
-        
+
         markdown.push_str(&format!("# {}\n\n", translated_book_name.to_lowercase()));
-        
+
         for chapter in &book.chapters {
             chapter_count += 1;
-            
+
             // Chapter title as ## heading with book name
-            markdown.push_str(&format!("## {} {}\n\n", translated_book_name.to_lowercase(), chapter.chapter));
-            
+            markdown.push_str(&format!(
+                "## {} {}\n\n",
+                translated_book_name.to_lowercase(),
+                chapter.chapter
+            ));
+
             // Render verses with verse numbers at the start
             for verse in &chapter.verses {
                 verse_count += 1;
-                
+
                 // Simple format: verse number followed by verse text, single line break
                 markdown.push_str(&format!("{} {}\n", verse.verse, verse.text));
             }
-            
+
             // Add double line break after chapter
             markdown.push_str("\n");
         }
     }
-    
-    console::log_1(&format!("📊 Markdown content complete! Processed {} books, {} chapters, {} verses", book_count, chapter_count, verse_count).into());
-    
+
+    console::log_1(
+        &format!(
+            "📊 Markdown content complete! Processed {} books, {} chapters, {} verses",
+            book_count, chapter_count, verse_count
+        )
+        .into(),
+    );
+
     if let Some(ref callback) = progress_callback {
         callback(1.0, "Markdown export complete!".to_string());
     }
-    
-    console::log_1(&format!("✅ Markdown export successful! Generated {} characters", markdown.len()).into());
+
+    console::log_1(
+        &format!(
+            "✅ Markdown export successful! Generated {} characters",
+            markdown.len()
+        )
+        .into(),
+    );
     Ok(markdown)
 }
 
@@ -128,13 +176,13 @@ where
 
 /// Trigger Markdown download in the browser
 pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
-    use web_sys::{window, Blob, Url, HtmlAnchorElement};
     use wasm_bindgen::JsCast;
-    
+    use web_sys::{window, Blob, HtmlAnchorElement, Url};
+
     console::log_1(&"🔽 Starting Markdown download process".into());
     console::log_1(&format!("📄 Markdown size: {} characters", markdown_content.len()).into());
     console::log_1(&format!("📝 Filename: {}", filename).into());
-    
+
     let window = match window() {
         Some(w) => {
             console::log_1(&"✅ Window object obtained".into());
@@ -145,7 +193,7 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
             return;
         }
     };
-    
+
     let document = match window.document() {
         Some(d) => {
             console::log_1(&"✅ Document object obtained".into());
@@ -156,22 +204,28 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
             return;
         }
     };
-    
+
     // Create blob from markdown content
     console::log_1(&"🔄 Creating Uint8Array from Markdown content...".into());
     let content_bytes = markdown_content.as_bytes();
     let uint8_array = js_sys::Uint8Array::new_with_length(content_bytes.len() as u32);
     uint8_array.copy_from(content_bytes);
-    console::log_1(&format!("✅ Uint8Array created with length: {}", uint8_array.length()).into());
-    
+    console::log_1(
+        &format!(
+            "✅ Uint8Array created with length: {}",
+            uint8_array.length()
+        )
+        .into(),
+    );
+
     console::log_1(&"📦 Creating JS Array for blob...".into());
     let array = js_sys::Array::new();
     array.push(&uint8_array);
-    
+
     console::log_1(&"🔄 Creating Markdown blob...".into());
     let blob_options = web_sys::BlobPropertyBag::new();
     blob_options.set_type("text/markdown");
-    
+
     let blob = match Blob::new_with_u8_array_sequence_and_options(&array, &blob_options) {
         Ok(b) => {
             console::log_1(&format!("✅ Blob created successfully, size: {}", b.size()).into());
@@ -182,7 +236,7 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
             return;
         }
     };
-    
+
     // Create download URL
     console::log_1(&"🔗 Creating object URL for blob...".into());
     let url = match Url::create_object_url_with_blob(&blob) {
@@ -195,14 +249,16 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
             return;
         }
     };
-    
+
     // Create anchor element for download
     console::log_1(&"⚓ Creating anchor element...".into());
     let anchor = match document
         .create_element("a")
         .map_err(|e| e)
-        .and_then(|elem| elem.dyn_into::<HtmlAnchorElement>().map_err(|_| wasm_bindgen::JsValue::from_str("Failed to cast to HtmlAnchorElement")))
-    {
+        .and_then(|elem| {
+            elem.dyn_into::<HtmlAnchorElement>()
+                .map_err(|_| wasm_bindgen::JsValue::from_str("Failed to cast to HtmlAnchorElement"))
+        }) {
         Ok(a) => {
             console::log_1(&"✅ Anchor element created".into());
             a
@@ -212,12 +268,19 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
             return;
         }
     };
-    
+
     console::log_1(&"🔧 Setting anchor attributes...".into());
     anchor.set_href(&url);
     anchor.set_download(filename);
-    console::log_1(&format!("✅ Anchor configured - href: {}, download: {}", anchor.href(), anchor.download()).into());
-    
+    console::log_1(
+        &format!(
+            "✅ Anchor configured - href: {}, download: {}",
+            anchor.href(),
+            anchor.download()
+        )
+        .into(),
+    );
+
     // Add the anchor to the document and trigger download
     console::log_1(&"📎 Adding anchor to document body...".into());
     let body = match document.body() {
@@ -230,24 +293,24 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
             return;
         }
     };
-    
+
     if let Err(e) = body.append_child(&anchor) {
         console::log_1(&format!("❌ Failed to append anchor to body: {:?}", e).into());
         return;
     }
     console::log_1(&"✅ Anchor added to document".into());
-    
+
     console::log_1(&"🖱️ Triggering download click...".into());
     anchor.click();
     console::log_1(&"✅ Download click triggered".into());
-    
+
     console::log_1(&"🧹 Cleaning up anchor element...".into());
     if let Err(e) = body.remove_child(&anchor) {
         console::log_1(&format!("⚠️ Failed to remove anchor from body: {:?}", e).into());
     } else {
         console::log_1(&"✅ Anchor removed from document".into());
     }
-    
+
     // Clean up
     console::log_1(&"🗑️ Revoking object URL...".into());
     if let Err(e) = Url::revoke_object_url(&url) {
@@ -255,6 +318,6 @@ pub fn trigger_markdown_download(markdown_content: String, filename: &str) {
     } else {
         console::log_1(&"✅ Object URL revoked".into());
     }
-    
+
     console::log_1(&format!("🎉 Markdown download process completed! File: {}", filename).into());
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/logic/mod.rs b/site/src/instructions/logic/mod.rs
index 585f931..ddd446e 100644
--- a/site/src/instructions/logic/mod.rs
+++ b/site/src/instructions/logic/mod.rs
@@ -1,15 +1,17 @@
+pub mod event_handlers;
 pub mod export_handlers;
-pub mod ui_toggles;
+pub mod linked_markdown_export;
+pub mod markdown_export;
 pub mod navigation_handlers;
-pub mod event_handlers;
 pub mod pdf_export;
-pub mod markdown_export;
-pub mod linked_markdown_export;
+pub mod ui_toggles;
 
 // Re-export only the functions that are actually used
 pub use navigation_handlers::update_view_state_from_url;
 
 // Re-export business logic functions
-pub use pdf_export::{export_bible_to_pdf, trigger_pdf_download};
+pub use linked_markdown_export::{
+    export_bible_to_linked_markdown, trigger_linked_markdown_download,
+};
 pub use markdown_export::{export_bible_to_markdown, trigger_markdown_download};
-pub use linked_markdown_export::{export_bible_to_linked_markdown, trigger_linked_markdown_download};
\ No newline at end of file
+pub use pdf_export::{export_bible_to_pdf, trigger_pdf_download};
diff --git a/site/src/instructions/logic/navigation_handlers.rs b/site/src/instructions/logic/navigation_handlers.rs
index 6676441..20313d6 100644
--- a/site/src/instructions/logic/navigation_handlers.rs
+++ b/site/src/instructions/logic/navigation_handlers.rs
@@ -1,16 +1,22 @@
+use crate::instructions::{Instruction, InstructionProcessor};
+use crate::view_state::ViewStateSignal;
 use leptos::prelude::*;
 use leptos_router::location::Location;
 use leptos_router::NavigateOptions;
-use crate::instructions::{Instruction, InstructionProcessor};
-use crate::view_state::ViewStateSignal;
 
 /// Helper function to update view state from URL
-pub fn update_view_state_from_url(view_state: ViewStateSignal, pathname: &str, search: &str) -> bool {
+pub fn update_view_state_from_url(
+    view_state: ViewStateSignal,
+    pathname: &str,
+    search: &str,
+) -> bool {
     let path_parts: Vec<&str> = pathname.trim_start_matches('/').split('/').collect();
     if path_parts.len() == 2 {
         let book_name = path_parts[0].replace('_', " ");
         if let Ok(chapter_num) = path_parts[1].parse::<u32>() {
-            if let Ok(current_chapter) = crate::core::get_bible().get_chapter(&book_name, chapter_num) {
+            if let Ok(current_chapter) =
+                crate::core::get_bible().get_chapter(&book_name, chapter_num)
+            {
                 view_state.update(|state| {
                     state.set_current_chapter(Some(current_chapter));
                     state.set_search_params(search.to_string());
@@ -81,4 +87,4 @@ pub fn handle_previous_palette_result(view_state: ViewStateSignal) {
         // Command palette is open, trigger navigation in palette
         view_state.update(|state| state.trigger_previous_palette_result());
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/logic/pdf_export.rs b/site/src/instructions/logic/pdf_export.rs
index 331b817..715f10c 100644
--- a/site/src/instructions/logic/pdf_export.rs
+++ b/site/src/instructions/logic/pdf_export.rs
@@ -5,9 +5,13 @@ use printpdf::*;
 use std::io::BufWriter;
 use web_sys::console;
 
-
 /// Add book header to the top of a page
-fn add_book_header_to_page(layer: &PdfLayerReference, book_name: &str, margin_left: Mm, italic_font: &IndirectFontRef) {
+fn add_book_header_to_page(
+    layer: &PdfLayerReference,
+    book_name: &str,
+    margin_left: Mm,
+    italic_font: &IndirectFontRef,
+) {
     layer.use_text(
         book_name,
         9.0,
@@ -20,20 +24,28 @@ fn add_book_header_to_page(layer: &PdfLayerReference, book_name: &str, margin_le
 /// Get translated book name based on current translation
 fn get_translated_book_name(book_name: &str) -> String {
     console::log_1(&format!("🔄 Translating book name: {}", book_name).into());
-    
+
     if let Some(current_translation) = get_current_translation() {
-        console::log_1(&format!("📚 Current translation: {} ({:?})", current_translation.name, current_translation.languages).into());
-        
+        console::log_1(
+            &format!(
+                "📚 Current translation: {} ({:?})",
+                current_translation.name, current_translation.languages
+            )
+            .into(),
+        );
+
         if let Some(first_language) = current_translation.languages.first() {
             console::log_1(&format!("🌍 Using language: {:?}", first_language).into());
             let translation = Translation::from_language(*first_language);
-            
+
             // Convert book name to lowercase for mapping
             let key = book_name.to_lowercase();
             console::log_1(&format!("🔑 Looking up key: '{}'", key).into());
-            
+
             if let Some(translated_name) = translation.get(&key) {
-                console::log_1(&format!("✅ Found translation: {} → {}", book_name, translated_name).into());
+                console::log_1(
+                    &format!("✅ Found translation: {} → {}", book_name, translated_name).into(),
+                );
                 return translated_name;
             } else {
                 console::log_1(&format!("❌ No translation found for key: '{}'", key).into());
@@ -42,45 +54,48 @@ fn get_translated_book_name(book_name: &str) -> String {
     } else {
         console::log_1(&"❌ No current translation available".into());
     }
-    
+
     console::log_1(&format!("⏭️ Using original name: {}", book_name).into());
     // Return original name if no translation found
     book_name.to_string()
 }
 
 /// Core PDF export business logic
-pub fn export_bible_to_pdf<F>(bible: &Bible, progress_callback: Option<F>) -> Result<Vec<u8>, Box<dyn std::error::Error>>
+pub fn export_bible_to_pdf<F>(
+    bible: &Bible,
+    progress_callback: Option<F>,
+) -> Result<Vec<u8>, Box<dyn std::error::Error>>
 where
     F: Fn(f32, String) + Clone + 'static,
 {
     console::log_1(&"🚀 Starting PDF export process".into());
     console::log_1(&format!("📖 Bible has {} books", bible.books.len()).into());
-    
+
     // Report initial progress
     if let Some(ref callback) = progress_callback {
         callback(0.0, "Initializing PDF export...".to_string());
     }
-    
+
     let translation_info = get_current_translation().unwrap_or_else(|| {
         console::log_1(&"⚠️ No current translation found, using default".into());
         crate::storage::translation_storage::BibleTranslation {
             name: "Unknown Bible".to_string(),
-            short_name: "unknown".to_string(), 
+            short_name: "unknown".to_string(),
             release_year: 2024,
             languages: vec![],
             iagon: "".to_string(),
         }
     });
-    
+
     console::log_1(&format!("📚 Using translation: {}", translation_info.name).into());
-    
+
     // Create PDF document
     console::log_1(&"📄 Creating PDF document...".into());
     if let Some(ref callback) = progress_callback {
         callback(0.05, "Creating PDF document...".to_string());
     }
     let (doc, page1, layer1) = PdfDocument::new("Bible Export", Mm(210.0), Mm(297.0), "Layer 1");
-    
+
     // Load font
     console::log_1(&"🔤 Loading fonts...".into());
     if let Some(ref callback) = progress_callback {
@@ -90,16 +105,16 @@ where
     let bold_font = doc.add_builtin_font(BuiltinFont::TimesBold)?;
     let italic_font = doc.add_builtin_font(BuiltinFont::TimesItalic)?;
     console::log_1(&"✅ Fonts loaded successfully".into());
-    
+
     let current_layer = doc.get_page(page1).get_layer(layer1);
-    
+
     let mut current_y = Mm(270.0);
     let margin_left = Mm(20.0);
     let _margin_right = Mm(190.0);
     let line_height = Mm(5.0);
     let _page_height = Mm(297.0);
     let page_bottom_margin = Mm(20.0);
-    
+
     // Add title page
     console::log_1(&"📝 Adding title page...".into());
     if let Some(ref callback) = progress_callback {
@@ -112,9 +127,9 @@ where
         current_y,
         &bold_font,
     );
-    
+
     current_y -= line_height * 2.0;
-    
+
     current_layer.use_text(
         format!("Published: {}", translation_info.release_year),
         12.0,
@@ -122,35 +137,57 @@ where
         current_y,
         &italic_font,
     );
-    
+
     current_y -= line_height * 4.0;
-    
+
     let mut current_page;
     let mut current_layer_ref = current_layer;
     let mut current_book_name; // Track current book for headers
-    
+
     // Export all books, chapters, and verses
-    console::log_1(&format!("📖 Processing {} books for PDF export...", bible.books.len()).into());
-    
+    console::log_1(
+        &format!(
+            "📖 Processing {} books for PDF export...",
+            bible.books.len()
+        )
+        .into(),
+    );
+
     let mut book_count = 0;
     let mut chapter_count = 0;
     let mut verse_count = 0;
-    
+
     for book in &bible.books {
         book_count += 1;
-        console::log_1(&format!("📖 Processing book {}/{}: {}", book_count, bible.books.len(), book.name).into());
-        
+        console::log_1(
+            &format!(
+                "📖 Processing book {}/{}: {}",
+                book_count,
+                bible.books.len(),
+                book.name
+            )
+            .into(),
+        );
+
         // Report progress for current book (20% to 90% of total progress)
         let book_progress = 0.2 + (book_count as f32 / bible.books.len() as f32) * 0.7;
         if let Some(ref callback) = progress_callback {
-            callback(book_progress, format!("Processing {} ({}/{})", book.name, book_count, bible.books.len()));
+            callback(
+                book_progress,
+                format!(
+                    "Processing {} ({}/{})",
+                    book.name,
+                    book_count,
+                    bible.books.len()
+                ),
+            );
         }
-        
+
         // Book title - use translated name
         let translated_book_name = get_translated_book_name(&book.name);
         console::log_1(&format!("📖 Book: {} → {}", book.name, translated_book_name).into());
         current_book_name = translated_book_name.clone(); // Update current book for headers
-        
+
         // Check if we need a new page for the book
         if current_y < page_bottom_margin + line_height * 10.0 {
             console::log_1(&"📄 Adding new page for book".into());
@@ -159,10 +196,15 @@ where
             current_layer_ref = doc.get_page(current_page).get_layer(new_layer);
             current_y = Mm(270.0);
         }
-        
+
         // Add book header to current page
-        add_book_header_to_page(&current_layer_ref, &translated_book_name, margin_left, &italic_font);
-        
+        add_book_header_to_page(
+            &current_layer_ref,
+            &translated_book_name,
+            margin_left,
+            &italic_font,
+        );
+
         current_layer_ref.use_text(
             &translated_book_name,
             18.0,
@@ -170,12 +212,12 @@ where
             current_y,
             &bold_font,
         );
-        
+
         current_y -= line_height * 2.0;
-        
+
         for chapter in &book.chapters {
             chapter_count += 1;
-            
+
             // Check if we need a new page for the chapter
             if current_y < page_bottom_margin + line_height * 20.0 {
                 console::log_1(&"📄 Adding new page for chapter".into());
@@ -184,71 +226,64 @@ where
                 current_layer_ref = doc.get_page(current_page).get_layer(new_layer);
                 current_y = Mm(270.0);
                 // Add book header to the new page
-                add_book_header_to_page(&current_layer_ref, &current_book_name, margin_left, &italic_font);
+                add_book_header_to_page(
+                    &current_layer_ref,
+                    &current_book_name,
+                    margin_left,
+                    &italic_font,
+                );
             }
-            
+
             // Chapter title - centered format like "-- 1 --"
             let chapter_title = format!("-- {} --", chapter.chapter);
             let title_width = 14.0 * chapter_title.len() as f32 * 0.6; // Rough character width estimation
             let centered_x = (margin_left + Mm(170.0)) / 2.0 - Mm(title_width / 2.0); // Center between margins
-            
-            current_layer_ref.use_text(
-                &chapter_title,
-                14.0,
-                centered_x,
-                current_y,
-                &bold_font,
-            );
-            
+
+            current_layer_ref.use_text(&chapter_title, 14.0, centered_x, current_y, &bold_font);
+
             current_y -= line_height * 2.0;
-            
+
             // Render verses with subscript verse numbers and continuous flow
             let max_chars_per_line = 85;
             let mut current_line = String::new();
             let mut first_verse_in_chapter = true;
-            
+
             for verse in &chapter.verses {
                 verse_count += 1;
-                
+
                 // Add space before verse number if not first verse in chapter
                 if !first_verse_in_chapter {
                     current_line.push(' ');
                 }
-                
+
                 // Add verse number (we'll handle subscript rendering separately)
                 let verse_marker = format!("⁽{}⁾ ", verse.verse); // Use superscript-like characters
                 current_line.push_str(&verse_marker);
-                
+
                 first_verse_in_chapter = false;
-                
+
                 // Add verse text
                 current_line.push_str(&verse.text);
                 current_line.push(' '); // Space between verses
             }
-            
+
             // Split the continuous text into lines that fit the page width
             let words: Vec<&str> = current_line.split_whitespace().collect();
             let mut line_buffer = String::new();
-            
+
             for word in words {
                 let test_line = if line_buffer.is_empty() {
                     word.to_string()
                 } else {
                     format!("{} {}", line_buffer, word)
                 };
-                
+
                 // Check if this line would be too long
                 if test_line.len() > max_chars_per_line && !line_buffer.is_empty() {
                     // Render the current line and start a new one
-                    current_layer_ref.use_text(
-                        &line_buffer,
-                        11.0,
-                        margin_left,
-                        current_y,
-                        &font,
-                    );
+                    current_layer_ref.use_text(&line_buffer, 11.0, margin_left, current_y, &font);
                     current_y -= line_height;
-                    
+
                     // Check if we need a new page
                     if current_y < page_bottom_margin + line_height {
                         console::log_1(&"📄 Adding new page for chapter text".into());
@@ -256,11 +291,16 @@ where
                         current_page = new_page;
                         current_layer_ref = doc.get_page(current_page).get_layer(new_layer);
                         current_y = Mm(270.0);
-                        
+
                         // Add book header to new page
-                        add_book_header_to_page(&current_layer_ref, &current_book_name, margin_left, &italic_font);
+                        add_book_header_to_page(
+                            &current_layer_ref,
+                            &current_book_name,
+                            margin_left,
+                            &italic_font,
+                        );
                     }
-                    
+
                     // Start new line with current word
                     line_buffer = word.to_string();
                 } else {
@@ -268,30 +308,30 @@ where
                     line_buffer = test_line;
                 }
             }
-            
+
             // Render any remaining text
             if !line_buffer.is_empty() {
-                current_layer_ref.use_text(
-                    &line_buffer,
-                    11.0,
-                    margin_left,
-                    current_y,
-                    &font,
-                );
+                current_layer_ref.use_text(&line_buffer, 11.0, margin_left, current_y, &font);
                 current_y -= line_height;
             }
-            
+
             // Move to next line after chapter content
             current_y -= line_height;
-            
+
             current_y -= line_height; // Extra spacing between chapters
         }
-        
+
         current_y -= line_height * 2.0; // Extra spacing between books
     }
-    
-    console::log_1(&format!("📊 PDF content complete! Processed {} books, {} chapters, {} verses", book_count, chapter_count, verse_count).into());
-    
+
+    console::log_1(
+        &format!(
+            "📊 PDF content complete! Processed {} books, {} chapters, {} verses",
+            book_count, chapter_count, verse_count
+        )
+        .into(),
+    );
+
     // Save PDF to bytes
     console::log_1(&"💾 Converting PDF to bytes...".into());
     if let Some(ref callback) = progress_callback {
@@ -302,7 +342,7 @@ where
         let mut writer = BufWriter::new(&mut buf);
         doc.save(&mut writer)?;
     }
-    
+
     if let Some(ref callback) = progress_callback {
         callback(1.0, "PDF export complete!".to_string());
     }
@@ -315,13 +355,13 @@ where
 
 /// Trigger PDF download in the browser
 pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
-    use web_sys::{window, Blob, Url, HtmlAnchorElement};
     use wasm_bindgen::JsCast;
-    
+    use web_sys::{window, Blob, HtmlAnchorElement, Url};
+
     console::log_1(&"🔽 Starting PDF download process".into());
     console::log_1(&format!("📄 PDF size: {} bytes", pdf_bytes.len()).into());
     console::log_1(&format!("📝 Filename: {}", filename).into());
-    
+
     let window = match window() {
         Some(w) => {
             console::log_1(&"✅ Window object obtained".into());
@@ -332,7 +372,7 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
             return;
         }
     };
-    
+
     let document = match window.document() {
         Some(d) => {
             console::log_1(&"✅ Document object obtained".into());
@@ -343,17 +383,23 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
             return;
         }
     };
-    
+
     // Create blob from PDF bytes
     console::log_1(&"🔄 Creating Uint8Array from PDF bytes...".into());
     let uint8_array = js_sys::Uint8Array::new_with_length(pdf_bytes.len() as u32);
     uint8_array.copy_from(&pdf_bytes);
-    console::log_1(&format!("✅ Uint8Array created with length: {}", uint8_array.length()).into());
-    
+    console::log_1(
+        &format!(
+            "✅ Uint8Array created with length: {}",
+            uint8_array.length()
+        )
+        .into(),
+    );
+
     console::log_1(&"📦 Creating JS Array for blob...".into());
     let array = js_sys::Array::new();
     array.push(&uint8_array);
-    
+
     console::log_1(&"🔄 Creating PDF blob...".into());
     let blob = match Blob::new_with_u8_array_sequence(&array) {
         Ok(b) => {
@@ -365,7 +411,7 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
             return;
         }
     };
-    
+
     // Create download URL
     console::log_1(&"🔗 Creating object URL for blob...".into());
     let url = match Url::create_object_url_with_blob(&blob) {
@@ -378,14 +424,16 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
             return;
         }
     };
-    
+
     // Create anchor element for download to Downloads folder
     console::log_1(&"⚓ Creating anchor element...".into());
     let anchor = match document
         .create_element("a")
         .map_err(|e| e)
-        .and_then(|elem| elem.dyn_into::<HtmlAnchorElement>().map_err(|_| wasm_bindgen::JsValue::from_str("Failed to cast to HtmlAnchorElement")))
-    {
+        .and_then(|elem| {
+            elem.dyn_into::<HtmlAnchorElement>()
+                .map_err(|_| wasm_bindgen::JsValue::from_str("Failed to cast to HtmlAnchorElement"))
+        }) {
         Ok(a) => {
             console::log_1(&"✅ Anchor element created".into());
             a
@@ -395,12 +443,19 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
             return;
         }
     };
-    
+
     console::log_1(&"🔧 Setting anchor attributes...".into());
     anchor.set_href(&url);
     anchor.set_download(filename);
-    console::log_1(&format!("✅ Anchor configured - href: {}, download: {}", anchor.href(), anchor.download()).into());
-    
+    console::log_1(
+        &format!(
+            "✅ Anchor configured - href: {}, download: {}",
+            anchor.href(),
+            anchor.download()
+        )
+        .into(),
+    );
+
     // Add the anchor to the document and trigger download
     console::log_1(&"📎 Adding anchor to document body...".into());
     let body = match document.body() {
@@ -413,24 +468,24 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
             return;
         }
     };
-    
+
     if let Err(e) = body.append_child(&anchor) {
         console::log_1(&format!("❌ Failed to append anchor to body: {:?}", e).into());
         return;
     }
     console::log_1(&"✅ Anchor added to document".into());
-    
+
     console::log_1(&"🖱️ Triggering download click...".into());
     anchor.click();
     console::log_1(&"✅ Download click triggered".into());
-    
+
     console::log_1(&"🧹 Cleaning up anchor element...".into());
     if let Err(e) = body.remove_child(&anchor) {
         console::log_1(&format!("⚠️ Failed to remove anchor from body: {:?}", e).into());
     } else {
         console::log_1(&"✅ Anchor removed from document".into());
     }
-    
+
     // Clean up
     console::log_1(&"🗑️ Revoking object URL...".into());
     if let Err(e) = Url::revoke_object_url(&url) {
@@ -438,6 +493,6 @@ pub fn trigger_pdf_download(pdf_bytes: Vec<u8>, filename: &str) {
     } else {
         console::log_1(&"✅ Object URL revoked".into());
     }
-    
+
     console::log_1(&format!("🎉 PDF download process completed! File: {}", filename).into());
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/logic/ui_toggles.rs b/site/src/instructions/logic/ui_toggles.rs
index 714f24f..6007350 100644
--- a/site/src/instructions/logic/ui_toggles.rs
+++ b/site/src/instructions/logic/ui_toggles.rs
@@ -1,11 +1,9 @@
-use leptos::prelude::*;
 use crate::utils::is_mobile_screen;
 use crate::view_state::ViewStateSignal;
+use leptos::prelude::*;
 
 /// Handle toggling the Bible palette
-pub fn handle_toggle_bible_palette(
-    view_state: ViewStateSignal,
-) {
+pub fn handle_toggle_bible_palette(view_state: ViewStateSignal) {
     let is_currently_open = view_state.with(|state| state.is_command_palette_open);
     view_state.update(|state| state.set_command_palette(!is_currently_open));
     // Close sidebar on mobile when command palette opens
@@ -15,9 +13,7 @@ pub fn handle_toggle_bible_palette(
 }
 
 /// Handle toggling the command palette with ">" prefix
-pub fn handle_toggle_command_palette(
-    view_state: ViewStateSignal,
-) {
+pub fn handle_toggle_command_palette(view_state: ViewStateSignal) {
     // Open the command palette with ">" pre-filled
     view_state.update(|state| {
         state.set_initial_search_query(Some(">".to_string()));
@@ -30,9 +26,7 @@ pub fn handle_toggle_command_palette(
 }
 
 /// Handle toggling the verse palette with ":" prefix
-pub fn handle_toggle_verse_palette(
-    view_state: ViewStateSignal,
-) {
+pub fn handle_toggle_verse_palette(view_state: ViewStateSignal) {
     // Open the command palette with ":" pre-filled
     view_state.update(|state| {
         state.set_initial_search_query(Some(":".to_string()));
@@ -74,4 +68,4 @@ pub fn handle_toggle_translation_comparison(view_state: ViewStateSignal) {
 /// Handle toggling verse visibility
 pub fn handle_toggle_verse_visibility(view_state: ViewStateSignal) {
     view_state.update(|state| state.toggle_verse_visibility());
-}
\ No newline at end of file
+}
diff --git a/site/src/instructions/mod.rs b/site/src/instructions/mod.rs
index 33b8d69..2549fde 100644
--- a/site/src/instructions/mod.rs
+++ b/site/src/instructions/mod.rs
@@ -1,43 +1,43 @@
 /*!
  * Instructions Module
- * 
+ *
  * This module provides the complete instruction system for the Bible application.
  * It handles keyboard shortcuts, command processing, and user interface actions.
- * 
+ *
  * # Architecture
- * 
+ *
  * The instruction system follows a multi-layered architecture:
- * 
+ *
  * ## 1. Instruction Types (`types.rs`)
  * Defines all possible user instructions as an enum. Instructions are categorized
  * by functionality (navigation, UI toggles, copy operations, etc.)
- * 
+ *
  * ## 2. Keyboard Mapping System
  * - `keyboard_mappings.json`: JSON configuration for vim-style key bindings
  * - `keyboard_map.rs`: Hardcoded key combinations for complex mappings
  * - `vim_keys.rs`: Vim-style key parser and mapping engine
- * 
+ *
  * ## 3. Instruction Processing (`processor.rs`)
  * Handles the execution of instructions, including context creation and
  * business logic for each instruction type.
- * 
+ *
  * # Key Features
- * 
+ *
  * - **Vim-style navigation**: hjkl keys, gg/G shortcuts, numeric prefixes
  * - **Multiple input methods**: Keyboard shortcuts, command palette, programmatic
  * - **Configurable shortcuts**: JSON-based configuration with fallback to hardcoded
  * - **Multi-key sequences**: Support for sequences like "gg" for beginning of chapter
  * - **Modifier key support**: Ctrl, Alt, Meta, Shift combinations
  * - **Cross-platform compatibility**: Handles Mac Cmd vs Ctrl differences
- * 
+ *
  * # Usage Examples
- * 
+ *
  * ```rust
  * use crate::instructions::{Instruction, VimKeyboardMapper};
- * 
+ *
  * // Create keyboard mapper
  * let mut mapper = VimKeyboardMapper::new();
- * 
+ *
  * // Process keyboard event
  * if let Some((instruction, multiplier)) = mapper.map_to_instruction(&event) {
  *     // Execute the instruction
@@ -67,7 +67,7 @@ pub mod logic;
 
 // === Public Exports ===
 
+pub use logic::*;
+pub use processor::*;
 pub use types::*;
 pub use vim_keys::*;
-pub use processor::*;
-pub use logic::*;
\ No newline at end of file
diff --git a/site/src/instructions/processor.rs b/site/src/instructions/processor.rs
index bbc4f80..c714447 100644
--- a/site/src/instructions/processor.rs
+++ b/site/src/instructions/processor.rs
@@ -151,7 +151,11 @@ where
         }
     }
 
-    fn handle_go_to_verse(&self, context: &AppState, verse_id: crate::core::types::VerseId) -> bool {
+    fn handle_go_to_verse(
+        &self,
+        context: &AppState,
+        verse_id: crate::core::types::VerseId,
+    ) -> bool {
         if let Some(ref current_chapter) = context.current_chapter {
             let verse_num = verse_id.verse();
             if verse_num > 0 && verse_num <= current_chapter.verses.len() as u32 {
diff --git a/site/src/instructions/types.rs b/site/src/instructions/types.rs
index 109087c..6805e71 100644
--- a/site/src/instructions/types.rs
+++ b/site/src/instructions/types.rs
@@ -60,7 +60,7 @@ pub enum Instruction {
     ToggleTranslationComparison, // Added: Toggle translation comparison panel
     ToggleVerseVisibility,
     ToggleVersePallate,
-    
+
     // === UI Close Instructions ===
     // Direct close actions for specific UI elements
     CloseCommandPalette,
@@ -68,7 +68,7 @@ pub enum Instruction {
     CloseRightSidebar,
     CloseThemeSidebar,
     CloseTranslationComparison,
-    
+
     // === Book Selection Instructions ===
     // Book navigation and selection
     SelectBook(String),
diff --git a/site/src/instructions/vim_keys.rs b/site/src/instructions/vim_keys.rs
index 5256aaf..d4be533 100644
--- a/site/src/instructions/vim_keys.rs
+++ b/site/src/instructions/vim_keys.rs
@@ -36,10 +36,10 @@ impl VimKey {
                     "gt" => {
                         key = ">".to_string();
                         shift = true; // ">" requires shift
-                    },
+                    }
                     "/" => {
                         key = "/".to_string();
-                    },
+                    }
                     other => key = other.to_string(),
                 };
             } else if parts.len() == 2 {
@@ -311,7 +311,6 @@ impl VimKeyboardMapper {
         None
     }
 
-
     pub fn clear_buffers(&mut self) {
         self.sequence_buffer.clear();
         self.multiplier_buffer.clear();
@@ -324,11 +323,11 @@ impl VimKeyboardMapper {
     pub fn get_current_input_display(&self) -> String {
         format!("{}{}", self.multiplier_buffer, self.sequence_buffer)
     }
-    
+
     pub fn get_sequence_buffer(&self) -> &str {
         &self.sequence_buffer
     }
-    
+
     pub fn get_multiplier_buffer(&self) -> &str {
         &self.multiplier_buffer
     }
diff --git a/site/src/keyboard_navigation.rs b/site/src/keyboard_navigation.rs
index 86c1ea5..9db9afc 100644
--- a/site/src/keyboard_navigation.rs
+++ b/site/src/keyboard_navigation.rs
@@ -36,14 +36,16 @@ pub fn KeyboardNavigationHandler(view_state: ViewStateSignal) -> impl IntoView {
 
     // Visual display for vim command buffer
     let vim_display = Memo::new(move |_| {
-        vim_mapper.try_with(|mapper| {
-            let display = mapper.get_current_input_display();
-            if display.is_empty() {
-                None
-            } else {
-                Some(display)
-            }
-        }).unwrap_or(None)
+        vim_mapper
+            .try_with(|mapper| {
+                let display = mapper.get_current_input_display();
+                if display.is_empty() {
+                    None
+                } else {
+                    Some(display)
+                }
+            })
+            .unwrap_or(None)
     });
 
     // Set up keyboard event handler
@@ -67,7 +69,9 @@ pub fn KeyboardNavigationHandler(view_state: ViewStateSignal) -> impl IntoView {
         };
 
         // If user is typing in input and palette is open, only intercept specific control keys
-        let palette_open = view_state.try_with(|state| state.is_command_palette_open).unwrap_or(false);
+        let palette_open = view_state
+            .try_with(|state| state.is_command_palette_open)
+            .unwrap_or(false);
         if palette_open && is_typing_in_input {
             let key = e.key();
             let is_control_sequence = e.ctrl_key() && (key == "j" || key == "k" || key == "o")
@@ -84,23 +88,33 @@ pub fn KeyboardNavigationHandler(view_state: ViewStateSignal) -> impl IntoView {
         // Get instruction from vim-style keyboard mapper
         let instruction_result = {
             // Get the current mapper state
-            let mut current_mapper = vim_mapper.try_with_untracked(|mapper| mapper.clone()).unwrap_or_else(|| VimKeyboardMapper::new());
-            
+            let mut current_mapper = vim_mapper
+                .try_with_untracked(|mapper| mapper.clone())
+                .unwrap_or_else(|| VimKeyboardMapper::new());
+
             #[cfg(target_arch = "wasm32")]
-            leptos::web_sys::console::log_1(&format!("🔤 Key pressed: '{}', current sequence: '{}', multiplier: '{}'", 
-                e.key(), 
-                current_mapper.get_sequence_buffer(), 
-                current_mapper.get_multiplier_buffer()
-            ).into());
-            
+            leptos::web_sys::console::log_1(
+                &format!(
+                    "🔤 Key pressed: '{}', current sequence: '{}', multiplier: '{}'",
+                    e.key(),
+                    current_mapper.get_sequence_buffer(),
+                    current_mapper.get_multiplier_buffer()
+                )
+                .into(),
+            );
+
             let result = current_mapper.map_to_instruction(&e);
-            
+
             #[cfg(target_arch = "wasm32")]
-            leptos::web_sys::console::log_1(&format!("🎯 Mapper result: {:?}, new sequence: '{}', new multiplier: '{}'", 
-                result, 
-                current_mapper.get_sequence_buffer(), 
-                current_mapper.get_multiplier_buffer()
-            ).into());
+            leptos::web_sys::console::log_1(
+                &format!(
+                    "🎯 Mapper result: {:?}, new sequence: '{}', new multiplier: '{}'",
+                    result,
+                    current_mapper.get_sequence_buffer(),
+                    current_mapper.get_multiplier_buffer()
+                )
+                .into(),
+            );
 
             // Store the updated mapper back
             let _ = vim_mapper.try_update_untracked(|m| *m = current_mapper);
@@ -109,7 +123,9 @@ pub fn KeyboardNavigationHandler(view_state: ViewStateSignal) -> impl IntoView {
         };
 
         // Handle palette navigation priority when palette is open
-        let palette_open_check = view_state.try_with(|state| state.is_command_palette_open).unwrap_or(false);
+        let palette_open_check = view_state
+            .try_with(|state| state.is_command_palette_open)
+            .unwrap_or(false);
         if palette_open_check {
             if let Some((ref instruction, _)) = instruction_result {
                 match instruction {
@@ -199,26 +215,34 @@ pub fn KeyboardNavigationHandler(view_state: ViewStateSignal) -> impl IntoView {
                     leptos::web_sys::console::log_1(
                         &format!("🔄 Passing to processor: {:?}", instruction).into(),
                     );
-                    
+
                     // Create processor and try to handle the instruction
                     let processor = crate::instructions::processor::InstructionProcessor::new(
                         |path: &str, opts: leptos_router::NavigateOptions| {
                             navigate(path, opts);
-                        }
+                        },
                     );
-                    
+
                     let handled = view_state.with(|state| {
                         if multiplier > 1 {
-                            processor.process_with_multiplier(instruction.clone(), state, multiplier)
+                            processor.process_with_multiplier(
+                                instruction.clone(),
+                                state,
+                                multiplier,
+                            )
                         } else {
                             processor.process(instruction.clone(), state)
                         }
                     });
-                    
+
                     if !handled {
                         #[cfg(target_arch = "wasm32")]
                         leptos::web_sys::console::log_1(
-                            &format!("🤷 Instruction not handled by processor either: {:?}", instruction).into(),
+                            &format!(
+                                "🤷 Instruction not handled by processor either: {:?}",
+                                instruction
+                            )
+                            .into(),
                         );
                     }
                 }
diff --git a/site/src/main.rs b/site/src/main.rs
index 5438ae2..007270c 100644
--- a/site/src/main.rs
+++ b/site/src/main.rs
@@ -529,7 +529,9 @@ fn SidebarAutoHide(view_state: ViewStateSignal) -> impl IntoView {
         // If we're on a chapter page and screen is mobile-sized, hide sidebar
         if path_parts.len() == 2 && !path_parts[0].is_empty() && !path_parts[1].is_empty() {
             if is_mobile_screen() {
-                view_state.update(|state| { state.execute(&Instruction::CloseLeftSidebar); });
+                view_state.update(|state| {
+                    state.execute(&Instruction::CloseLeftSidebar);
+                });
             }
         }
     });
diff --git a/site/src/storage/mod.rs b/site/src/storage/mod.rs
index 616edab..f5e0f6e 100644
--- a/site/src/storage/mod.rs
+++ b/site/src/storage/mod.rs
@@ -1,10 +1,13 @@
+pub mod recent_chapters;
+pub mod sidebar_storage;
 pub mod translation_manager;
 pub mod translation_storage;
 pub mod translations;
-pub mod sidebar_storage;
-pub mod recent_chapters;
 
+pub use recent_chapters::*;
+pub use sidebar_storage::{
+    get_references_sidebar_open, get_selected_theme, get_sidebar_open, get_verse_visibility,
+    save_references_sidebar_open, save_selected_theme, save_sidebar_open, save_verse_visibility,
+};
 pub use translation_storage::*;
 pub use translations::*;
-pub use sidebar_storage::{get_sidebar_open, save_sidebar_open, get_references_sidebar_open, save_references_sidebar_open, get_verse_visibility, save_verse_visibility, get_selected_theme, save_selected_theme};
-pub use recent_chapters::*;
\ No newline at end of file
diff --git a/site/src/storage/recent_chapters.rs b/site/src/storage/recent_chapters.rs
index c1d94f9..fe08ae1 100644
--- a/site/src/storage/recent_chapters.rs
+++ b/site/src/storage/recent_chapters.rs
@@ -28,23 +28,26 @@ pub fn get_recent_chapters() -> Vec<RecentChapter> {
 
 pub fn add_recent_chapter(book_name: String, chapter: u32, display_name: String, path: String) {
     let mut recent_chapters = get_recent_chapters();
-    
+
     // Remove if already exists (to avoid duplicates and move to front)
     recent_chapters.retain(|ch| !(ch.book_name == book_name && ch.chapter == chapter));
-    
+
     // Add to front (use simple incrementing timestamp)
     let timestamp = recent_chapters.len() as u64;
-    recent_chapters.insert(0, RecentChapter {
-        book_name,
-        chapter,
-        display_name,
-        path,
-        timestamp,
-    });
-    
+    recent_chapters.insert(
+        0,
+        RecentChapter {
+            book_name,
+            chapter,
+            display_name,
+            path,
+            timestamp,
+        },
+    );
+
     // Keep only the most recent ones
     recent_chapters.truncate(MAX_RECENT_CHAPTERS);
-    
+
     // Save to localStorage
     if let Some(window) = web_sys::window() {
         if let Ok(Some(storage)) = window.local_storage() {
@@ -54,4 +57,3 @@ pub fn add_recent_chapter(book_name: String, chapter: u32, display_name: String,
         }
     }
 }
-
diff --git a/site/src/storage/sidebar_storage.rs b/site/src/storage/sidebar_storage.rs
index 9456fd0..ee296df 100644
--- a/site/src/storage/sidebar_storage.rs
+++ b/site/src/storage/sidebar_storage.rs
@@ -35,4 +35,4 @@ pub fn get_selected_theme() -> String {
 
 pub fn save_selected_theme(theme_id: &str) {
     let _ = LocalStorage::set(SELECTED_THEME_KEY, theme_id);
-}
\ No newline at end of file
+}
diff --git a/site/src/storage/translation_manager.rs b/site/src/storage/translation_manager.rs
index e06690a..7f4eb9c 100644
--- a/site/src/storage/translation_manager.rs
+++ b/site/src/storage/translation_manager.rs
@@ -1,27 +1,27 @@
-use leptos::prelude::*;
 use crate::storage::{
-    BibleTranslation, get_selected_translation, set_selected_translation, 
-    is_translation_downloaded, download_translation, switch_bible_translation, uninstall_translation,
-    get_translations
+    download_translation, get_selected_translation, get_translations, is_translation_downloaded,
+    set_selected_translation, switch_bible_translation, uninstall_translation, BibleTranslation,
 };
+use leptos::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 
 #[component]
 pub fn TranslationManager() -> impl IntoView {
-    let (selected_translation, set_selected_translation_signal) = signal(get_selected_translation().unwrap_or_else(|| "sv".to_string()));
+    let (selected_translation, set_selected_translation_signal) =
+        signal(get_selected_translation().unwrap_or_else(|| "sv".to_string()));
     let (downloading_states, set_downloading_states) = signal::<Vec<(String, bool)>>(vec![]); // (translation_short_name, is_downloading)
     let (uninstalling_states, set_uninstalling_states) = signal::<Vec<(String, bool)>>(vec![]); // (translation_short_name, is_uninstalling)
     let (download_error, set_download_error) = signal::<Option<String>>(None);
     let (uninstall_error, set_uninstall_error) = signal::<Option<String>>(None);
-    
+
     let translations = get_translations();
-    
+
     let handle_translation_change = {
         let set_selected_translation_signal = set_selected_translation_signal.clone();
         move |translation_short_name: String| {
             let _ = set_selected_translation(&translation_short_name);
             set_selected_translation_signal.set(translation_short_name.clone());
-            
+
             // Switch the Bible data to the selected translation
             spawn_local(async move {
                 if let Err(e) = switch_bible_translation(&translation_short_name).await {
@@ -36,18 +36,21 @@ pub fn TranslationManager() -> impl IntoView {
         let set_download_error = set_download_error.clone();
         move |translation: BibleTranslation| {
             let translation_short_name = translation.short_name.clone();
-            
+
             // Set downloading state
             set_downloading_states.update(|states| {
-                if let Some(pos) = states.iter().position(|(name, _)| name == &translation_short_name) {
+                if let Some(pos) = states
+                    .iter()
+                    .position(|(name, _)| name == &translation_short_name)
+                {
                     states[pos].1 = true;
                 } else {
                     states.push((translation_short_name.clone(), true));
                 }
             });
-            
+
             set_download_error.set(None);
-            
+
             spawn_local(async move {
                 match download_translation(&translation).await {
                     Ok(_) => {
@@ -59,11 +62,17 @@ pub fn TranslationManager() -> impl IntoView {
                     Err(e) => {
                         // Download failed
                         set_downloading_states.update(|states| {
-                            if let Some(pos) = states.iter().position(|(name, _)| name == &translation_short_name) {
+                            if let Some(pos) = states
+                                .iter()
+                                .position(|(name, _)| name == &translation_short_name)
+                            {
                                 states[pos].1 = false;
                             }
                         });
-                        set_download_error.set(Some(format!("Failed to download {}: {}", translation.name, e)));
+                        set_download_error.set(Some(format!(
+                            "Failed to download {}: {}",
+                            translation.name, e
+                        )));
                     }
                 }
             });
@@ -77,15 +86,18 @@ pub fn TranslationManager() -> impl IntoView {
         move |translation_short_name: String| {
             // Set uninstalling state
             set_uninstalling_states.update(|states| {
-                if let Some(pos) = states.iter().position(|(name, _)| name == &translation_short_name) {
+                if let Some(pos) = states
+                    .iter()
+                    .position(|(name, _)| name == &translation_short_name)
+                {
                     states[pos].1 = true;
                 } else {
                     states.push((translation_short_name.clone(), true));
                 }
             });
-            
+
             set_uninstall_error.set(None);
-            
+
             spawn_local(async move {
                 match uninstall_translation(&translation_short_name).await {
                     Ok(_) => {
@@ -93,19 +105,26 @@ pub fn TranslationManager() -> impl IntoView {
                         set_uninstalling_states.update(|states| {
                             states.retain(|(name, _)| name != &translation_short_name);
                         });
-                        
+
                         // Update selected translation if it was uninstalled
-                        let current_selected = get_selected_translation().unwrap_or_else(|| "sv".to_string());
+                        let current_selected =
+                            get_selected_translation().unwrap_or_else(|| "sv".to_string());
                         set_selected_translation_signal.set(current_selected);
                     }
                     Err(e) => {
                         // Uninstall failed
                         set_uninstalling_states.update(|states| {
-                            if let Some(pos) = states.iter().position(|(name, _)| name == &translation_short_name) {
+                            if let Some(pos) = states
+                                .iter()
+                                .position(|(name, _)| name == &translation_short_name)
+                            {
                                 states[pos].1 = false;
                             }
                         });
-                        set_uninstall_error.set(Some(format!("Failed to uninstall {}: {}", translation_short_name, e)));
+                        set_uninstall_error.set(Some(format!(
+                            "Failed to uninstall {}: {}",
+                            translation_short_name, e
+                        )));
                     }
                 }
             });
@@ -113,206 +132,206 @@ pub fn TranslationManager() -> impl IntoView {
     };
 
     view! {
-        <div class="bg-white rounded-lg shadow-md p-6 mb-6">
-            <h2 class="text-xl font-semibold text-gray-900 mb-4">"Bible Translations"</h2>
-            
-            <Show
-                when=move || download_error.get().is_some()
-                fallback=|| view! { <></> }
-            >
-                <div class="mb-4 p-3 bg-red-100 border border-red-400 text-red-700 rounded">
-                    {move || download_error.get().unwrap_or_default()}
-                </div>
-            </Show>
-            
-            <Show
-                when=move || uninstall_error.get().is_some()
-                fallback=|| view! { <></> }
-            >
-                <div class="mb-4 p-3 bg-red-100 border border-red-400 text-red-700 rounded">
-                    {move || uninstall_error.get().unwrap_or_default()}
-                </div>
-            </Show>
-            
-            <div class="space-y-4">
-{
-                    translations.into_iter().map(|translation| {
-                        let is_downloaded = is_translation_downloaded(&translation.short_name);
-                        
-                        let handle_translation_change_clone = handle_translation_change.clone();
-                        let handle_download_clone = handle_download.clone();
-                        let handle_uninstall_clone = handle_uninstall.clone();
-                        let translation_for_change = translation.clone();
-                        let translation_for_download = translation.clone();
-                        let translation_short_name_for_class = translation.short_name.clone();
-                        let translation_short_name_for_radio = translation.short_name.clone();
-                        let translation_short_name_for_download = translation.short_name.clone();
-                        let translation_short_name_for_uninstall_condition = translation.short_name.clone();
-                        let translation_short_name_for_uninstall_button = translation.short_name.clone();
-                        
-                        view! {
-                            <div class=move || {
-                                let is_selected = selected_translation.get() == translation_short_name_for_class;
-                                if is_selected { 
-                                    "border rounded-lg p-4 border-blue-500 bg-blue-50" 
-                                } else { 
-                                    "border rounded-lg p-4 border-gray-200" 
-                                }
-                            }>
-                                <div class="flex items-start justify-between">
-                                    <div class="flex-1">
-                                        <div class="flex items-center mb-2">
-                                            <input
-                                                type="radio"
-                                                name="translation"
-                                                id=format!("translation-{}", translation.short_name)
-                                                class="mr-3 text-blue-600"
-                                                checked=move || selected_translation.get() == translation_short_name_for_radio
-                                                disabled=!is_downloaded
-                                                on:change=move |_| {
-                                                    if is_downloaded {
-                                                        handle_translation_change_clone(translation_for_change.short_name.clone());
+            <div class="bg-white rounded-lg shadow-md p-6 mb-6">
+                <h2 class="text-xl font-semibold text-gray-900 mb-4">"Bible Translations"</h2>
+
+                <Show
+                    when=move || download_error.get().is_some()
+                    fallback=|| view! { <></> }
+                >
+                    <div class="mb-4 p-3 bg-red-100 border border-red-400 text-red-700 rounded">
+                        {move || download_error.get().unwrap_or_default()}
+                    </div>
+                </Show>
+
+                <Show
+                    when=move || uninstall_error.get().is_some()
+                    fallback=|| view! { <></> }
+                >
+                    <div class="mb-4 p-3 bg-red-100 border border-red-400 text-red-700 rounded">
+                        {move || uninstall_error.get().unwrap_or_default()}
+                    </div>
+                </Show>
+
+                <div class="space-y-4">
+    {
+                        translations.into_iter().map(|translation| {
+                            let is_downloaded = is_translation_downloaded(&translation.short_name);
+
+                            let handle_translation_change_clone = handle_translation_change.clone();
+                            let handle_download_clone = handle_download.clone();
+                            let handle_uninstall_clone = handle_uninstall.clone();
+                            let translation_for_change = translation.clone();
+                            let translation_for_download = translation.clone();
+                            let translation_short_name_for_class = translation.short_name.clone();
+                            let translation_short_name_for_radio = translation.short_name.clone();
+                            let translation_short_name_for_download = translation.short_name.clone();
+                            let translation_short_name_for_uninstall_condition = translation.short_name.clone();
+                            let translation_short_name_for_uninstall_button = translation.short_name.clone();
+
+                            view! {
+                                <div class=move || {
+                                    let is_selected = selected_translation.get() == translation_short_name_for_class;
+                                    if is_selected {
+                                        "border rounded-lg p-4 border-blue-500 bg-blue-50"
+                                    } else {
+                                        "border rounded-lg p-4 border-gray-200"
+                                    }
+                                }>
+                                    <div class="flex items-start justify-between">
+                                        <div class="flex-1">
+                                            <div class="flex items-center mb-2">
+                                                <input
+                                                    type="radio"
+                                                    name="translation"
+                                                    id=format!("translation-{}", translation.short_name)
+                                                    class="mr-3 text-blue-600"
+                                                    checked=move || selected_translation.get() == translation_short_name_for_radio
+                                                    disabled=!is_downloaded
+                                                    on:change=move |_| {
+                                                        if is_downloaded {
+                                                            handle_translation_change_clone(translation_for_change.short_name.clone());
+                                                        }
                                                     }
-                                                }
-                                            />
-                                            <label
-                                                for=format!("translation-{}", translation.short_name)
-                                                class=if is_downloaded { "font-medium text-gray-900" } else { "font-medium text-gray-500" }
-                                            >
-                                                {translation.name.clone()}
-                                            </label>
-                                            <span class="ml-2 text-sm text-gray-500">
-                                                "(" {translation.release_year.to_string()} ")"
-                                            </span>
+                                                />
+                                                <label
+                                                    for=format!("translation-{}", translation.short_name)
+                                                    class=if is_downloaded { "font-medium text-gray-900" } else { "font-medium text-gray-500" }
+                                                >
+                                                    {translation.name.clone()}
+                                                </label>
+                                                <span class="ml-2 text-sm text-gray-500">
+                                                    "(" {translation.release_year.to_string()} ")"
+                                                </span>
+                                            </div>
+                                            <p class="text-sm text-gray-600 mb-2 ml-6">
+                                                "Uitgegeven in " {translation.release_year.to_string()}
+                                            </p>
+                                            <div class="ml-6 flex items-center space-x-4">
+                                                <Show
+                                                    when=move || is_downloaded
+                                                    fallback=|| view! { <></> }
+                                                >
+                                                    <span class="text-sm text-green-600 font-medium">"✓ Downloaded"</span>
+                                                </Show>
+                                            </div>
                                         </div>
-                                        <p class="text-sm text-gray-600 mb-2 ml-6">
-                                            "Uitgegeven in " {translation.release_year.to_string()}
-                                        </p>
-                                        <div class="ml-6 flex items-center space-x-4">
+                                        <div class="ml-4">
                                             <Show
-                                                when=move || is_downloaded
+                                                when=move || !is_downloaded
                                                 fallback=|| view! { <></> }
                                             >
-                                                <span class="text-sm text-green-600 font-medium">"✓ Downloaded"</span>
-                                            </Show>
-                                        </div>
-                                    </div>
-                                    <div class="ml-4">
-                                        <Show
-                                            when=move || !is_downloaded
-                                            fallback=|| view! { <></> }
-                                        >
-                                            {
-                                                let translation_clone = translation_for_download.clone();
-                                                let handle_download_clone = handle_download_clone.clone();
-                                                let translation_short_name_for_download_state = translation_short_name_for_download.clone();
-                                                
-                                                view! {
-                                                    <Show
-                                                        when=move || {
-                                                            downloading_states.get().iter()
-                                                                .find(|(name, _)| name == &translation_short_name_for_download_state)
-                                                                .map(|(_, downloading)| *downloading)
-                                                                .unwrap_or(false)
-                                                        }
-                                                        fallback=move || {
-                                                            let translation_clone = translation_clone.clone();
-                                                            let handle_download_clone = handle_download_clone.clone();
-                                                            view! {
-                                                                <button 
-                                                                    class="px-4 py-2 text-sm bg-blue-600 text-white rounded hover:bg-blue-700 transition-colors"
-                                                                    on:click=move |_| {
-                                                                        handle_download_clone(translation_clone.clone());
-                                                                    }
-                                                                >
-                                                                    "Download"
-                                                                </button>
+                                                {
+                                                    let translation_clone = translation_for_download.clone();
+                                                    let handle_download_clone = handle_download_clone.clone();
+                                                    let translation_short_name_for_download_state = translation_short_name_for_download.clone();
+
+                                                    view! {
+                                                        <Show
+                                                            when=move || {
+                                                                downloading_states.get().iter()
+                                                                    .find(|(name, _)| name == &translation_short_name_for_download_state)
+                                                                    .map(|(_, downloading)| *downloading)
+                                                                    .unwrap_or(false)
+                                                            }
+                                                            fallback=move || {
+                                                                let translation_clone = translation_clone.clone();
+                                                                let handle_download_clone = handle_download_clone.clone();
+                                                                view! {
+                                                                    <button
+                                                                        class="px-4 py-2 text-sm bg-blue-600 text-white rounded hover:bg-blue-700 transition-colors"
+                                                                        on:click=move |_| {
+                                                                            handle_download_clone(translation_clone.clone());
+                                                                        }
+                                                                    >
+                                                                        "Download"
+                                                                    </button>
+                                                                }
                                                             }
-                                                        }
-                                                    >
-                                                        <button 
-                                                            class="px-4 py-2 text-sm bg-yellow-100 text-yellow-800 rounded border border-yellow-300 cursor-not-allowed"
-                                                            disabled=true
                                                         >
-                                                            <div class="flex items-center">
-                                                                <svg class="animate-spin w-4 h-4 mr-2" fill="none" viewBox="0 0 24 24">
-                                                                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
-                                                                    <path class="opacity-75" fill="currentColor" d="m12 2a10 10 0 0 1 10 10h-2a8 8 0 0 0-8-8v-2z"></path>
-                                                                </svg>
-                                                                "Downloading..."
-                                                            </div>
-                                                        </button>
-                                                    </Show>
+                                                            <button
+                                                                class="px-4 py-2 text-sm bg-yellow-100 text-yellow-800 rounded border border-yellow-300 cursor-not-allowed"
+                                                                disabled=true
+                                                            >
+                                                                <div class="flex items-center">
+                                                                    <svg class="animate-spin w-4 h-4 mr-2" fill="none" viewBox="0 0 24 24">
+                                                                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                                                                        <path class="opacity-75" fill="currentColor" d="m12 2a10 10 0 0 1 10 10h-2a8 8 0 0 0-8-8v-2z"></path>
+                                                                    </svg>
+                                                                    "Downloading..."
+                                                                </div>
+                                                            </button>
+                                                        </Show>
+                                                    }
                                                 }
-                                            }
-                                        </Show>
-                                        
-                                        // Uninstall button for downloaded translations (but not if it's the only one or currently selected)
-                                        <Show
-                                            when=move || {
-                                                is_downloaded && 
-                                                translation_short_name_for_uninstall_condition != "sv" && // Don't allow uninstalling Staten vertaling
-                                                selected_translation.get() != translation_short_name_for_uninstall_condition // Don't allow uninstalling currently selected
-                                            }
-                                            fallback=|| view! { <></> }
-                                        >
-                                            {
-                                                let handle_uninstall_clone = handle_uninstall_clone.clone();
-                                                let translation_short_name_for_uninstall_state = translation_short_name_for_uninstall_button.clone();
-                                                let translation_short_name_for_uninstall_click = translation_short_name_for_uninstall_button.clone();
-                                                
-                                                view! {
-                                                    <Show
-                                                        when=move || {
-                                                            uninstalling_states.get().iter()
-                                                                .find(|(name, _)| name == &translation_short_name_for_uninstall_state)
-                                                                .map(|(_, uninstalling)| *uninstalling)
-                                                                .unwrap_or(false)
-                                                        }
-                                                        fallback=move || {
-                                                            let handle_uninstall_clone = handle_uninstall_clone.clone();
-                                                            let translation_short_name_clone = translation_short_name_for_uninstall_click.clone();
-                                                            view! {
-                                                                <button 
-                                                                    class="px-3 py-1 text-xs bg-red-100 text-red-700 rounded border border-red-300 hover:bg-red-200 transition-colors ml-2"
-                                                                    on:click=move |_| {
-                                                                        handle_uninstall_clone(translation_short_name_clone.clone());
-                                                                    }
-                                                                    title="Remove this translation from your device"
-                                                                >
-                                                                    "Uninstall"
-                                                                </button>
+                                            </Show>
+
+                                            // Uninstall button for downloaded translations (but not if it's the only one or currently selected)
+                                            <Show
+                                                when=move || {
+                                                    is_downloaded &&
+                                                    translation_short_name_for_uninstall_condition != "sv" && // Don't allow uninstalling Staten vertaling
+                                                    selected_translation.get() != translation_short_name_for_uninstall_condition // Don't allow uninstalling currently selected
+                                                }
+                                                fallback=|| view! { <></> }
+                                            >
+                                                {
+                                                    let handle_uninstall_clone = handle_uninstall_clone.clone();
+                                                    let translation_short_name_for_uninstall_state = translation_short_name_for_uninstall_button.clone();
+                                                    let translation_short_name_for_uninstall_click = translation_short_name_for_uninstall_button.clone();
+
+                                                    view! {
+                                                        <Show
+                                                            when=move || {
+                                                                uninstalling_states.get().iter()
+                                                                    .find(|(name, _)| name == &translation_short_name_for_uninstall_state)
+                                                                    .map(|(_, uninstalling)| *uninstalling)
+                                                                    .unwrap_or(false)
+                                                            }
+                                                            fallback=move || {
+                                                                let handle_uninstall_clone = handle_uninstall_clone.clone();
+                                                                let translation_short_name_clone = translation_short_name_for_uninstall_click.clone();
+                                                                view! {
+                                                                    <button
+                                                                        class="px-3 py-1 text-xs bg-red-100 text-red-700 rounded border border-red-300 hover:bg-red-200 transition-colors ml-2"
+                                                                        on:click=move |_| {
+                                                                            handle_uninstall_clone(translation_short_name_clone.clone());
+                                                                        }
+                                                                        title="Remove this translation from your device"
+                                                                    >
+                                                                        "Uninstall"
+                                                                    </button>
+                                                                }
                                                             }
-                                                        }
-                                                    >
-                                                        <button 
-                                                            class="px-3 py-1 text-xs bg-red-200 text-red-800 rounded border border-red-300 cursor-not-allowed ml-2"
-                                                            disabled=true
                                                         >
-                                                            <div class="flex items-center">
-                                                                <svg class="animate-spin w-3 h-3 mr-1" fill="none" viewBox="0 0 24 24">
-                                                                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
-                                                                    <path class="opacity-75" fill="currentColor" d="m12 2a10 10 0 0 1 10 10h-2a8 8 0 0 0-8-8v-2z"></path>
-                                                                </svg>
-                                                                "Uninstalling..."
-                                                            </div>
-                                                        </button>
-                                                    </Show>
+                                                            <button
+                                                                class="px-3 py-1 text-xs bg-red-200 text-red-800 rounded border border-red-300 cursor-not-allowed ml-2"
+                                                                disabled=true
+                                                            >
+                                                                <div class="flex items-center">
+                                                                    <svg class="animate-spin w-3 h-3 mr-1" fill="none" viewBox="0 0 24 24">
+                                                                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                                                                        <path class="opacity-75" fill="currentColor" d="m12 2a10 10 0 0 1 10 10h-2a8 8 0 0 0-8-8v-2z"></path>
+                                                                    </svg>
+                                                                    "Uninstalling..."
+                                                                </div>
+                                                            </button>
+                                                        </Show>
+                                                    }
                                                 }
-                                            }
-                                        </Show>
+                                            </Show>
+                                        </div>
                                     </div>
                                 </div>
-                            </div>
-                        }
-                    }).collect_view()
-                }
-            </div>
-            
-            <div class="mt-4 text-sm text-gray-600">
-                <p>"You need to download a translation before you can select and use it."</p>
-                <p>"Downloaded translations are stored locally in your browser for offline access."</p>
+                            }
+                        }).collect_view()
+                    }
+                </div>
+
+                <div class="mt-4 text-sm text-gray-600">
+                    <p>"You need to download a translation before you can select and use it."</p>
+                    <p>"Downloaded translations are stored locally in your browser for offline access."</p>
+                </div>
             </div>
-        </div>
-    }
+        }
 }
diff --git a/site/src/storage/translation_storage.rs b/site/src/storage/translation_storage.rs
index db3afff..dbd7a5a 100644
--- a/site/src/storage/translation_storage.rs
+++ b/site/src/storage/translation_storage.rs
@@ -1,9 +1,9 @@
 use crate::api::{try_fetch_bible, try_fetch_bible_with_progress};
-use crate::core::{Bible, init_bible_signal};
-use crate::core::types::Language;
 use crate::components::custom_translation_import::_remove_custom_translation;
-use leptos::prelude::Set;
+use crate::core::types::Language;
+use crate::core::{init_bible_signal, Bible};
 use gloo_storage::{LocalStorage, Storage};
+use leptos::prelude::Set;
 use rexie::{ObjectStore, Rexie, TransactionMode};
 use serde::{Deserialize, Serialize};
 
@@ -16,7 +16,6 @@ pub struct BibleTranslation {
     pub languages: Vec<Language>,
 }
 
-
 const SELECTED_TRANSLATION_KEY: &str = "selected_translation";
 const DOWNLOADED_TRANSLATIONS_KEY: &str = "downloaded_translations";
 
@@ -115,16 +114,18 @@ where
     F: Fn(f32, String) + Clone + 'static,
 {
     progress_callback(0.1, "Starting download...".to_string());
-    
-    let bible = fetch_translation_from_url_with_progress(&translation.iagon, progress_callback.clone()).await?;
+
+    let bible =
+        fetch_translation_from_url_with_progress(&translation.iagon, progress_callback.clone())
+            .await?;
 
     progress_callback(0.8, "Saving to storage...".to_string());
-    
+
     let translation_cache_key = format!("translation_{}", translation.short_name);
     save_translation_to_cache_internal(&translation_cache_key, &bible).await?;
 
     progress_callback(0.95, "Updating translation list...".to_string());
-    
+
     add_downloaded_translation(&translation.short_name)?;
 
     progress_callback(1.0, "Download complete!".to_string());
@@ -161,8 +162,8 @@ async fn fetch_translation_from_url(url: &str) -> Result<Bible, Box<dyn std::err
 }
 
 async fn fetch_translation_from_url_with_progress<F>(
-    url: &str, 
-    progress_callback: F
+    url: &str,
+    progress_callback: F,
 ) -> Result<Bible, Box<dyn std::error::Error>>
 where
     F: Fn(f32, String) + Clone + 'static,
@@ -175,8 +176,11 @@ where
     let mut last_error = None;
 
     for (i, proxy_url) in proxy_urls.iter().enumerate() {
-        progress_callback(0.2 + (i as f32 * 0.1), format!("Trying download server {}...", i + 1));
-        
+        progress_callback(
+            0.2 + (i as f32 * 0.1),
+            format!("Trying download server {}...", i + 1),
+        );
+
         match try_fetch_bible_with_progress(proxy_url, progress_callback.clone()).await {
             Ok(bible) => return Ok(bible),
             Err(e) => {
@@ -189,7 +193,6 @@ where
     Err(last_error.unwrap_or_else(|| "All proxy attempts failed".into()))
 }
 
-
 async fn load_translation_from_cache(cache_key: &str) -> Result<Bible, Box<dyn std::error::Error>> {
     let rexie = Rexie::builder("TranslationCache")
         .version(1)
@@ -286,4 +289,4 @@ async fn remove_translation_from_cache(cache_key: &str) -> Result<(), Box<dyn st
         .await
         .map_err(|e| format!("Failed to commit transaction: {:?}", e))?;
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/site/src/storage/translations.rs b/site/src/storage/translations.rs
index 28e9d35..6d600a2 100644
--- a/site/src/storage/translations.rs
+++ b/site/src/storage/translations.rs
@@ -1,5 +1,5 @@
-use crate::storage::translation_storage::{get_selected_translation, BibleTranslation};
 use crate::core::types::Language;
+use crate::storage::translation_storage::{get_selected_translation, BibleTranslation};
 use gloo_storage::{LocalStorage, Storage};
 
 const CUSTOM_TRANSLATIONS_KEY: &str = "custom_translations";
@@ -100,4 +100,4 @@ impl Language {
             Language::English => "English",
         }
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/themes/mod.rs b/site/src/themes/mod.rs
index 956c270..1516370 100644
--- a/site/src/themes/mod.rs
+++ b/site/src/themes/mod.rs
@@ -106,62 +106,114 @@ pub fn get_themes() -> Vec<Theme> {
         serde_json::from_str(include_str!("light.json")).expect("Failed to parse light theme"),
         serde_json::from_str(include_str!("dark.json")).expect("Failed to parse dark theme"),
         serde_json::from_str(include_str!("sepia.json")).expect("Failed to parse sepia theme"),
-        serde_json::from_str(include_str!("cherry_blossom.json")).expect("Failed to parse cherry_blossom theme"),
-        serde_json::from_str(include_str!("rose_gold.json")).expect("Failed to parse rose_gold theme"),
-        serde_json::from_str(include_str!("lavender_dreams.json")).expect("Failed to parse lavender_dreams theme"),
-        serde_json::from_str(include_str!("deuteranopia_safe.json")).expect("Failed to parse deuteranopia_safe theme"),
-        serde_json::from_str(include_str!("protanopia_safe.json")).expect("Failed to parse protanopia_safe theme"),
-        serde_json::from_str(include_str!("tritanopia_safe.json")).expect("Failed to parse tritanopia_safe theme"),
+        serde_json::from_str(include_str!("cherry_blossom.json"))
+            .expect("Failed to parse cherry_blossom theme"),
+        serde_json::from_str(include_str!("rose_gold.json"))
+            .expect("Failed to parse rose_gold theme"),
+        serde_json::from_str(include_str!("lavender_dreams.json"))
+            .expect("Failed to parse lavender_dreams theme"),
+        serde_json::from_str(include_str!("deuteranopia_safe.json"))
+            .expect("Failed to parse deuteranopia_safe theme"),
+        serde_json::from_str(include_str!("protanopia_safe.json"))
+            .expect("Failed to parse protanopia_safe theme"),
+        serde_json::from_str(include_str!("tritanopia_safe.json"))
+            .expect("Failed to parse tritanopia_safe theme"),
         serde_json::from_str(include_str!("matrix.json")).expect("Failed to parse matrix theme"),
         serde_json::from_str(include_str!("dracula.json")).expect("Failed to parse dracula theme"),
         serde_json::from_str(include_str!("nord.json")).expect("Failed to parse nord theme"),
         serde_json::from_str(include_str!("monokai.json")).expect("Failed to parse monokai theme"),
-        serde_json::from_str(include_str!("cotton_candy.json")).expect("Failed to parse cotton_candy theme"),
-        serde_json::from_str(include_str!("mint_cream.json")).expect("Failed to parse mint_cream theme"),
-        serde_json::from_str(include_str!("peach_sorbet.json")).expect("Failed to parse peach_sorbet theme"),
-        serde_json::from_str(include_str!("sky_blue.json")).expect("Failed to parse sky_blue theme"),
-        serde_json::from_str(include_str!("forest_green.json")).expect("Failed to parse forest_green theme"),
-        serde_json::from_str(include_str!("ocean_deep.json")).expect("Failed to parse ocean_deep theme"),
-        serde_json::from_str(include_str!("sunset_orange.json")).expect("Failed to parse sunset_orange theme"),
-        serde_json::from_str(include_str!("retro_amber.json")).expect("Failed to parse retro_amber theme"),
-        serde_json::from_str(include_str!("cyberpunk.json")).expect("Failed to parse cyberpunk theme"),
-        serde_json::from_str(include_str!("autumn_leaves.json")).expect("Failed to parse autumn_leaves theme"),
-        serde_json::from_str(include_str!("spring_meadow.json")).expect("Failed to parse spring_meadow theme"),
-        serde_json::from_str(include_str!("winter_frost.json")).expect("Failed to parse winter_frost theme"),
-        serde_json::from_str(include_str!("royal_purple.json")).expect("Failed to parse royal_purple theme"),
-        serde_json::from_str(include_str!("midnight_blue.json")).expect("Failed to parse midnight_blue theme"),
-        serde_json::from_str(include_str!("coral_reef.json")).expect("Failed to parse coral_reef theme"),
-        serde_json::from_str(include_str!("golden_hour.json")).expect("Failed to parse golden_hour theme"),
-        serde_json::from_str(include_str!("monochrome.json")).expect("Failed to parse monochrome theme"),
-        serde_json::from_str(include_str!("emerald_city.json")).expect("Failed to parse emerald_city theme"),
-        serde_json::from_str(include_str!("neon_nights.json")).expect("Failed to parse neon_nights theme"),
-        serde_json::from_str(include_str!("vintage_paper.json")).expect("Failed to parse vintage_paper theme"),
-        serde_json::from_str(include_str!("coffee_shop.json")).expect("Failed to parse coffee_shop theme"),
-        serde_json::from_str(include_str!("arctic_ice.json")).expect("Failed to parse arctic_ice theme"),
-        serde_json::from_str(include_str!("sunset_beach.json")).expect("Failed to parse sunset_beach theme"),
-        serde_json::from_str(include_str!("space_nebula.json")).expect("Failed to parse space_nebula theme"),
-        serde_json::from_str(include_str!("volcano_fire.json")).expect("Failed to parse volcano_fire theme"),
-        serde_json::from_str(include_str!("candy_pink.json")).expect("Failed to parse candy_pink theme"),
-        serde_json::from_str(include_str!("terminal_green.json")).expect("Failed to parse terminal_green theme"),
-        serde_json::from_str(include_str!("deep_ocean.json")).expect("Failed to parse deep_ocean theme"),
-        serde_json::from_str(include_str!("desert_sand.json")).expect("Failed to parse desert_sand theme"),
-        serde_json::from_str(include_str!("midnight_purple.json")).expect("Failed to parse midnight_purple theme"),
-        serde_json::from_str(include_str!("electric_blue.json")).expect("Failed to parse electric_blue theme"),
-        serde_json::from_str(include_str!("forest_night.json")).expect("Failed to parse forest_night theme"),
-        serde_json::from_str(include_str!("sunshine_yellow.json")).expect("Failed to parse sunshine_yellow theme"),
-        serde_json::from_str(include_str!("bubblegum_pop.json")).expect("Failed to parse bubblegum_pop theme"),
-        serde_json::from_str(include_str!("steel_gray.json")).expect("Failed to parse steel_gray theme"),
-        serde_json::from_str(include_str!("lime_twist.json")).expect("Failed to parse lime_twist theme"),
-        serde_json::from_str(include_str!("cosmic_purple.json")).expect("Failed to parse cosmic_purple theme"),
-        serde_json::from_str(include_str!("summer_breeze.json")).expect("Failed to parse summer_breeze theme"),
-        serde_json::from_str(include_str!("wine_red.json")).expect("Failed to parse wine_red theme"),
-        serde_json::from_str(include_str!("glacier_blue.json")).expect("Failed to parse glacier_blue theme"),
-        serde_json::from_str(include_str!("tropical_sunset.json")).expect("Failed to parse tropical_sunset theme"),
-        serde_json::from_str(include_str!("charcoal_night.json")).expect("Failed to parse charcoal_night theme"),
-        serde_json::from_str(include_str!("teal_wave.json")).expect("Failed to parse teal_wave theme"),
-        serde_json::from_str(include_str!("amber_glow.json")).expect("Failed to parse amber_glow theme"),
-        serde_json::from_str(include_str!("midnight_teal.json")).expect("Failed to parse midnight_teal theme"),
-        serde_json::from_str(include_str!("raspberry_cream.json")).expect("Failed to parse raspberry_cream theme"),
+        serde_json::from_str(include_str!("cotton_candy.json"))
+            .expect("Failed to parse cotton_candy theme"),
+        serde_json::from_str(include_str!("mint_cream.json"))
+            .expect("Failed to parse mint_cream theme"),
+        serde_json::from_str(include_str!("peach_sorbet.json"))
+            .expect("Failed to parse peach_sorbet theme"),
+        serde_json::from_str(include_str!("sky_blue.json"))
+            .expect("Failed to parse sky_blue theme"),
+        serde_json::from_str(include_str!("forest_green.json"))
+            .expect("Failed to parse forest_green theme"),
+        serde_json::from_str(include_str!("ocean_deep.json"))
+            .expect("Failed to parse ocean_deep theme"),
+        serde_json::from_str(include_str!("sunset_orange.json"))
+            .expect("Failed to parse sunset_orange theme"),
+        serde_json::from_str(include_str!("retro_amber.json"))
+            .expect("Failed to parse retro_amber theme"),
+        serde_json::from_str(include_str!("cyberpunk.json"))
+            .expect("Failed to parse cyberpunk theme"),
+        serde_json::from_str(include_str!("autumn_leaves.json"))
+            .expect("Failed to parse autumn_leaves theme"),
+        serde_json::from_str(include_str!("spring_meadow.json"))
+            .expect("Failed to parse spring_meadow theme"),
+        serde_json::from_str(include_str!("winter_frost.json"))
+            .expect("Failed to parse winter_frost theme"),
+        serde_json::from_str(include_str!("royal_purple.json"))
+            .expect("Failed to parse royal_purple theme"),
+        serde_json::from_str(include_str!("midnight_blue.json"))
+            .expect("Failed to parse midnight_blue theme"),
+        serde_json::from_str(include_str!("coral_reef.json"))
+            .expect("Failed to parse coral_reef theme"),
+        serde_json::from_str(include_str!("golden_hour.json"))
+            .expect("Failed to parse golden_hour theme"),
+        serde_json::from_str(include_str!("monochrome.json"))
+            .expect("Failed to parse monochrome theme"),
+        serde_json::from_str(include_str!("emerald_city.json"))
+            .expect("Failed to parse emerald_city theme"),
+        serde_json::from_str(include_str!("neon_nights.json"))
+            .expect("Failed to parse neon_nights theme"),
+        serde_json::from_str(include_str!("vintage_paper.json"))
+            .expect("Failed to parse vintage_paper theme"),
+        serde_json::from_str(include_str!("coffee_shop.json"))
+            .expect("Failed to parse coffee_shop theme"),
+        serde_json::from_str(include_str!("arctic_ice.json"))
+            .expect("Failed to parse arctic_ice theme"),
+        serde_json::from_str(include_str!("sunset_beach.json"))
+            .expect("Failed to parse sunset_beach theme"),
+        serde_json::from_str(include_str!("space_nebula.json"))
+            .expect("Failed to parse space_nebula theme"),
+        serde_json::from_str(include_str!("volcano_fire.json"))
+            .expect("Failed to parse volcano_fire theme"),
+        serde_json::from_str(include_str!("candy_pink.json"))
+            .expect("Failed to parse candy_pink theme"),
+        serde_json::from_str(include_str!("terminal_green.json"))
+            .expect("Failed to parse terminal_green theme"),
+        serde_json::from_str(include_str!("deep_ocean.json"))
+            .expect("Failed to parse deep_ocean theme"),
+        serde_json::from_str(include_str!("desert_sand.json"))
+            .expect("Failed to parse desert_sand theme"),
+        serde_json::from_str(include_str!("midnight_purple.json"))
+            .expect("Failed to parse midnight_purple theme"),
+        serde_json::from_str(include_str!("electric_blue.json"))
+            .expect("Failed to parse electric_blue theme"),
+        serde_json::from_str(include_str!("forest_night.json"))
+            .expect("Failed to parse forest_night theme"),
+        serde_json::from_str(include_str!("sunshine_yellow.json"))
+            .expect("Failed to parse sunshine_yellow theme"),
+        serde_json::from_str(include_str!("bubblegum_pop.json"))
+            .expect("Failed to parse bubblegum_pop theme"),
+        serde_json::from_str(include_str!("steel_gray.json"))
+            .expect("Failed to parse steel_gray theme"),
+        serde_json::from_str(include_str!("lime_twist.json"))
+            .expect("Failed to parse lime_twist theme"),
+        serde_json::from_str(include_str!("cosmic_purple.json"))
+            .expect("Failed to parse cosmic_purple theme"),
+        serde_json::from_str(include_str!("summer_breeze.json"))
+            .expect("Failed to parse summer_breeze theme"),
+        serde_json::from_str(include_str!("wine_red.json"))
+            .expect("Failed to parse wine_red theme"),
+        serde_json::from_str(include_str!("glacier_blue.json"))
+            .expect("Failed to parse glacier_blue theme"),
+        serde_json::from_str(include_str!("tropical_sunset.json"))
+            .expect("Failed to parse tropical_sunset theme"),
+        serde_json::from_str(include_str!("charcoal_night.json"))
+            .expect("Failed to parse charcoal_night theme"),
+        serde_json::from_str(include_str!("teal_wave.json"))
+            .expect("Failed to parse teal_wave theme"),
+        serde_json::from_str(include_str!("amber_glow.json"))
+            .expect("Failed to parse amber_glow theme"),
+        serde_json::from_str(include_str!("midnight_teal.json"))
+            .expect("Failed to parse midnight_teal theme"),
+        serde_json::from_str(include_str!("raspberry_cream.json"))
+            .expect("Failed to parse raspberry_cream theme"),
     ]
 }
 
@@ -259,4 +311,4 @@ pub fn theme_to_css_vars(theme: &Theme) -> String {
         theme.colors.command_palette.highlight,
         theme.colors.command_palette.highlight_background,
     )
-}
\ No newline at end of file
+}
diff --git a/site/src/translation_map/mod.rs b/site/src/translation_map/mod.rs
index e5cca50..f5648e8 100644
--- a/site/src/translation_map/mod.rs
+++ b/site/src/translation_map/mod.rs
@@ -1 +1 @@
-pub mod translation;
\ No newline at end of file
+pub mod translation;
diff --git a/site/src/translation_map/translation.rs b/site/src/translation_map/translation.rs
index b6f24a5..166460f 100644
--- a/site/src/translation_map/translation.rs
+++ b/site/src/translation_map/translation.rs
@@ -1,5 +1,5 @@
-use serde::{Deserialize, Serialize};
 use crate::core::types::Language;
+use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Translation<'a> {
@@ -78,13 +78,11 @@ const ENGLISH_JSON: &str = include_str!("english.json");
 
 use std::sync::LazyLock;
 
-static DUTCH_TRANSLATION: LazyLock<Translation<'static>> = LazyLock::new(|| {
-    serde_json::from_str(DUTCH_JSON).expect("Failed to parse dutch.json")
-});
+static DUTCH_TRANSLATION: LazyLock<Translation<'static>> =
+    LazyLock::new(|| serde_json::from_str(DUTCH_JSON).expect("Failed to parse dutch.json"));
 
-static ENGLISH_TRANSLATION: LazyLock<Translation<'static>> = LazyLock::new(|| {
-    serde_json::from_str(ENGLISH_JSON).expect("Failed to parse english.json")
-});
+static ENGLISH_TRANSLATION: LazyLock<Translation<'static>> =
+    LazyLock::new(|| serde_json::from_str(ENGLISH_JSON).expect("Failed to parse english.json"));
 
 impl<'a> Translation<'a> {
     pub fn from_language(language: Language) -> &'static Translation<'static> {
@@ -104,12 +102,20 @@ impl<'a> Translation<'a> {
             "joshua" => Some(self.joshua),
             "judges" => Some(self.judges),
             "ruth" => Some(self.ruth),
-            "first_samuel" | "1_samuel" | "1samuel" | "i_samuel" | "isamuel" => Some(self.first_samuel),
-            "second_samuel" | "2_samuel" | "2samuel" | "ii_samuel" | "iisamuel" => Some(self.second_samuel),
+            "first_samuel" | "1_samuel" | "1samuel" | "i_samuel" | "isamuel" => {
+                Some(self.first_samuel)
+            }
+            "second_samuel" | "2_samuel" | "2samuel" | "ii_samuel" | "iisamuel" => {
+                Some(self.second_samuel)
+            }
             "first_kings" | "1_kings" | "1kings" | "i_kings" | "ikings" => Some(self.first_kings),
-            "second_kings" | "2_kings" | "2kings" | "ii_kings" | "iikings" => Some(self.second_kings),
-            "first_chronicles" | "1_chronicles" | "1chronicles" | "i_chronicles" | "ichronicles" => Some(self.first_chronicles),
-            "second_chronicles" | "2_chronicles" | "2chronicles" | "ii_chronicles" | "iichronicles" => Some(self.second_chronicles),
+            "second_kings" | "2_kings" | "2kings" | "ii_kings" | "iikings" => {
+                Some(self.second_kings)
+            }
+            "first_chronicles" | "1_chronicles" | "1chronicles" | "i_chronicles"
+            | "ichronicles" => Some(self.first_chronicles),
+            "second_chronicles" | "2_chronicles" | "2chronicles" | "ii_chronicles"
+            | "iichronicles" => Some(self.second_chronicles),
             "ezra" => Some(self.ezra),
             "nehemiah" => Some(self.nehemiah),
             "esther" => Some(self.esther),
@@ -141,28 +147,38 @@ impl<'a> Translation<'a> {
             "john" => Some(self.john),
             "acts" => Some(self.acts),
             "romans" => Some(self.romans),
-            "first_corinthians" | "1_corinthians" | "1corinthians" | "i_corinthians" | "icorinthians" => Some(self.first_corinthians),
-            "second_corinthians" | "2_corinthians" | "2corinthians" | "ii_corinthians" | "iicorinthians" => {
-                Some(self.second_corinthians)
-            }
+            "first_corinthians" | "1_corinthians" | "1corinthians" | "i_corinthians"
+            | "icorinthians" => Some(self.first_corinthians),
+            "second_corinthians" | "2_corinthians" | "2corinthians" | "ii_corinthians"
+            | "iicorinthians" => Some(self.second_corinthians),
             "galatians" => Some(self.galatians),
             "ephesians" => Some(self.ephesians),
             "philippians" => Some(self.philippians),
             "colossians" => Some(self.colossians),
-            "first_thessalonians" | "1_thessalonians" | "1thessalonians" | "i_thessalonians" | "ithessalonians" => {
-                Some(self.first_thessalonians)
+            "first_thessalonians"
+            | "1_thessalonians"
+            | "1thessalonians"
+            | "i_thessalonians"
+            | "ithessalonians" => Some(self.first_thessalonians),
+            "second_thessalonians"
+            | "2_thessalonians"
+            | "2thessalonians"
+            | "ii_thessalonians"
+            | "iithessalonians" => Some(self.second_thessalonians),
+            "first_timothy" | "1_timothy" | "1timothy" | "i_timothy" | "itimothy" => {
+                Some(self.first_timothy)
             }
-            "second_thessalonians" | "2_thessalonians" | "2thessalonians" | "ii_thessalonians" | "iithessalonians" => {
-                Some(self.second_thessalonians)
+            "second_timothy" | "2_timothy" | "2timothy" | "ii_timothy" | "iitimothy" => {
+                Some(self.second_timothy)
             }
-            "first_timothy" | "1_timothy" | "1timothy" | "i_timothy" | "itimothy" => Some(self.first_timothy),
-            "second_timothy" | "2_timothy" | "2timothy" | "ii_timothy" | "iitimothy" => Some(self.second_timothy),
             "titus" => Some(self.titus),
             "philemon" => Some(self.philemon),
             "hebrews" => Some(self.hebrews),
             "james" => Some(self.james),
             "first_peter" | "1_peter" | "1peter" | "i_peter" | "ipeter" => Some(self.first_peter),
-            "second_peter" | "2_peter" | "2peter" | "ii_peter" | "iipeter" => Some(self.second_peter),
+            "second_peter" | "2_peter" | "2peter" | "ii_peter" | "iipeter" => {
+                Some(self.second_peter)
+            }
             "first_john" | "1_john" | "1john" | "i_john" | "ijohn" => Some(self.first_john),
             "second_john" | "2_john" | "2john" | "ii_john" | "iijohn" => Some(self.second_john),
             "third_john" | "3_john" | "3john" | "iii_john" | "iiijohn" => Some(self.third_john),
@@ -174,26 +190,26 @@ impl<'a> Translation<'a> {
 
     pub fn get(&self, s: &str) -> Option<String> {
         let input_lower = s.to_lowercase();
-        
+
         // Check if it's a chapter reference by looking for the last space followed by a number
         let words: Vec<&str> = input_lower.split_whitespace().collect();
         if words.len() >= 2 {
             // Check if the last word is a number (chapter number)
             if let Ok(_) = words.last().unwrap().parse::<u32>() {
                 // Everything except the last word is the book name
-                let book_part = words[..words.len()-1].join(" ");
+                let book_part = words[..words.len() - 1].join(" ");
                 let chapter_part = words.last().unwrap();
-                
+
                 // Convert book part to lookup format (replace spaces with underscores)
                 let book_lookup_key = book_part.replace(' ', "_");
-                
+
                 // Try to translate the book part
                 if let Some(translated_book) = self.get_book(&book_lookup_key) {
                     return Some(format!("{} {}", translated_book, chapter_part));
                 }
             }
         }
-        
+
         // If no chapter number found or book not found, try to translate as a book name only
         // Convert spaces to underscores for lookup
         let book_lookup_key = input_lower.replace(' ', "_");
@@ -209,47 +225,77 @@ mod tests {
     #[test]
     fn test_chapter_translation() {
         let dutch_translation = Translation::from_language(Language::Dutch);
-        
+
         // Test book name only
-        assert_eq!(dutch_translation.get("matthew"), Some("Matteüs".to_string()));
+        assert_eq!(
+            dutch_translation.get("matthew"),
+            Some("Matteüs".to_string())
+        );
         assert_eq!(dutch_translation.get("john"), Some("Johannes".to_string()));
         assert_eq!(dutch_translation.get("numbers"), Some("Numeri".to_string()));
-        
+
         // Test chapter references
-        assert_eq!(dutch_translation.get("matthew 7"), Some("Matteüs 7".to_string()));
-        assert_eq!(dutch_translation.get("john 3"), Some("Johannes 3".to_string()));
-        assert_eq!(dutch_translation.get("numbers 7"), Some("Numeri 7".to_string()));
-        assert_eq!(dutch_translation.get("first_john 2"), Some("I Johannes 2".to_string()));
-        
+        assert_eq!(
+            dutch_translation.get("matthew 7"),
+            Some("Matteüs 7".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("john 3"),
+            Some("Johannes 3".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("numbers 7"),
+            Some("Numeri 7".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("first_john 2"),
+            Some("I Johannes 2".to_string())
+        );
+
         // Test non-existent book
         assert_eq!(dutch_translation.get("nonexistent"), None);
         assert_eq!(dutch_translation.get("nonexistent 5"), None);
     }
-    
+
     #[test]
     fn test_english_translation() {
         let english_translation = Translation::from_language(Language::English);
-        
+
         // Test book name only
-        assert_eq!(english_translation.get("matthew"), Some("Matthew".to_string()));
+        assert_eq!(
+            english_translation.get("matthew"),
+            Some("Matthew".to_string())
+        );
         assert_eq!(english_translation.get("john"), Some("John".to_string()));
-        
+
         // Test chapter references
-        assert_eq!(english_translation.get("matthew 7"), Some("Matthew 7".to_string()));
-        assert_eq!(english_translation.get("john 3"), Some("John 3".to_string()));
+        assert_eq!(
+            english_translation.get("matthew 7"),
+            Some("Matthew 7".to_string())
+        );
+        assert_eq!(
+            english_translation.get("john 3"),
+            Some("John 3".to_string())
+        );
     }
 
     #[test]
     fn test_various_formats() {
         let dutch_translation = Translation::from_language(Language::Dutch);
-        
+
         // Test different input formats that might come from the data
         assert_eq!(dutch_translation.get("Numbers"), Some("Numeri".to_string()));
         assert_eq!(dutch_translation.get("numbers"), Some("Numeri".to_string()));
         assert_eq!(dutch_translation.get("NUMBERS"), Some("Numeri".to_string()));
-        assert_eq!(dutch_translation.get("Numbers 7"), Some("Numeri 7".to_string()));
-        assert_eq!(dutch_translation.get("numbers 7"), Some("Numeri 7".to_string()));
-        
+        assert_eq!(
+            dutch_translation.get("Numbers 7"),
+            Some("Numeri 7".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("numbers 7"),
+            Some("Numeri 7".to_string())
+        );
+
         // Test what happens with unknown format
         assert_eq!(dutch_translation.get("SomeUnknownBook"), None);
         assert_eq!(dutch_translation.get("SomeUnknownBook 5"), None);
@@ -258,51 +304,119 @@ mod tests {
     #[test]
     fn test_command_palette_search_scenario() {
         let dutch_translation = Translation::from_language(Language::Dutch);
-        
+
         // Simulate the command palette scenario
         let chapter_name = "Numbers 1"; // This is what's stored in the Bible data
         let translated_name = dutch_translation.get(chapter_name).unwrap(); // Should be "Numeri 1"
         assert_eq!(translated_name, "Numeri 1");
-        
+
         // Now test if searching for "numeri" would find this
         let query = "numeri";
         let translated_lower = translated_name.to_lowercase(); // "numeri 1"
-        
-        // This should return a score > 0 since "numeri" is in "numeri 1" 
-        assert!(translated_lower.contains(query), "Translated name '{}' should contain query '{}'", translated_lower, query);
+
+        // This should return a score > 0 since "numeri" is in "numeri 1"
+        assert!(
+            translated_lower.contains(query),
+            "Translated name '{}' should contain query '{}'",
+            translated_lower,
+            query
+        );
     }
 
     #[test]
     fn test_roman_numeral_translations() {
         let dutch_translation = Translation::from_language(Language::Dutch);
-        
+
         // Test Roman numeral formats that might appear in Bible data
-        assert_eq!(dutch_translation.get("I Samuel"), Some("I Samuël".to_string()));
-        assert_eq!(dutch_translation.get("II Samuel"), Some("II Samuël".to_string()));
-        assert_eq!(dutch_translation.get("I Kings"), Some("I Koningen".to_string()));
-        assert_eq!(dutch_translation.get("II Kings"), Some("II Koningen".to_string()));
-        assert_eq!(dutch_translation.get("I Chronicles"), Some("I Kronieken".to_string()));
-        assert_eq!(dutch_translation.get("II Chronicles"), Some("II Kronieken".to_string()));
-        
+        assert_eq!(
+            dutch_translation.get("I Samuel"),
+            Some("I Samuël".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II Samuel"),
+            Some("II Samuël".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("I Kings"),
+            Some("I Koningen".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II Kings"),
+            Some("II Koningen".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("I Chronicles"),
+            Some("I Kronieken".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II Chronicles"),
+            Some("II Kronieken".to_string())
+        );
+
         // Test chapter references with Roman numerals
-        assert_eq!(dutch_translation.get("II Kings 7"), Some("II Koningen 7".to_string()));
-        assert_eq!(dutch_translation.get("I Samuel 3"), Some("I Samuël 3".to_string()));
-        
+        assert_eq!(
+            dutch_translation.get("II Kings 7"),
+            Some("II Koningen 7".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("I Samuel 3"),
+            Some("I Samuël 3".to_string())
+        );
+
         // Test New Testament books
-        assert_eq!(dutch_translation.get("I Corinthians"), Some("I Korintiërs".to_string()));
-        assert_eq!(dutch_translation.get("II Corinthians"), Some("II Korintiërs".to_string()));
-        assert_eq!(dutch_translation.get("I Timothy"), Some("I Timoteüs".to_string()));
-        assert_eq!(dutch_translation.get("II Timothy"), Some("II Timoteüs".to_string()));
-        assert_eq!(dutch_translation.get("I Peter"), Some("I Petrus".to_string()));
-        assert_eq!(dutch_translation.get("II Peter"), Some("II Petrus".to_string()));
-        assert_eq!(dutch_translation.get("I John"), Some("I Johannes".to_string()));
-        assert_eq!(dutch_translation.get("II John"), Some("II Johannes".to_string()));
-        assert_eq!(dutch_translation.get("III John"), Some("III Johannes".to_string()));
-        
+        assert_eq!(
+            dutch_translation.get("I Corinthians"),
+            Some("I Korintiërs".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II Corinthians"),
+            Some("II Korintiërs".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("I Timothy"),
+            Some("I Timoteüs".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II Timothy"),
+            Some("II Timoteüs".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("I Peter"),
+            Some("I Petrus".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II Peter"),
+            Some("II Petrus".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("I John"),
+            Some("I Johannes".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("II John"),
+            Some("II Johannes".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("III John"),
+            Some("III Johannes".to_string())
+        );
+
         // Test Revelation
-        assert_eq!(dutch_translation.get("Revelation"), Some("Openbaringen".to_string()));
-        assert_eq!(dutch_translation.get("Revelation 1"), Some("Openbaringen 1".to_string()));
-        assert_eq!(dutch_translation.get("Revelation of John"), Some("Openbaringen".to_string()));
-        assert_eq!(dutch_translation.get("Revelation of John 22"), Some("Openbaringen 22".to_string()));
+        assert_eq!(
+            dutch_translation.get("Revelation"),
+            Some("Openbaringen".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("Revelation 1"),
+            Some("Openbaringen 1".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("Revelation of John"),
+            Some("Openbaringen".to_string())
+        );
+        assert_eq!(
+            dutch_translation.get("Revelation of John 22"),
+            Some("Openbaringen 22".to_string())
+        );
     }
 }
diff --git a/site/src/utils/mod.rs b/site/src/utils/mod.rs
index 61a005b..21c2a9e 100644
--- a/site/src/utils/mod.rs
+++ b/site/src/utils/mod.rs
@@ -1,10 +1,10 @@
 // === Utility Modules ===
 // Shared utilities and helper functions
 
-pub mod utils;
 pub mod url_helpers;
+pub mod utils;
 
 // === Public Exports ===
 
+pub use url_helpers::*;
 pub use utils::*;
-pub use url_helpers::*;
\ No newline at end of file
diff --git a/site/src/utils/url_helpers.rs b/site/src/utils/url_helpers.rs
index 386dfe1..08a1c05 100644
--- a/site/src/utils/url_helpers.rs
+++ b/site/src/utils/url_helpers.rs
@@ -1,6 +1,6 @@
 /*!
  * URL Parsing Utilities
- * 
+ *
  * Shared utilities for parsing Bible application URLs and extracting
  * book, chapter, and verse information from URL paths and parameters.
  */
@@ -8,21 +8,21 @@
 use urlencoding::decode;
 
 /// Parse book and chapter information from URL pathname
-/// 
+///
 /// Extracts the book name and chapter number from URL paths like:
 /// - `/Genesis/1` -> Some(("Genesis", 1))
 /// - `/1%20Timothy/3` -> Some(("1 Timothy", 3))
 /// - `/invalid` -> None
-/// 
+///
 /// # Arguments
 /// * `pathname` - URL pathname to parse (e.g., "/Genesis/1")
-/// 
+///
 /// # Returns
 /// * `Some((book_name, chapter_number))` if parsing succeeds
 /// * `None` if the path format is invalid
 pub fn parse_book_chapter_from_url(pathname: &str) -> Option<(String, u32)> {
     let path_parts: Vec<&str> = pathname.trim_start_matches('/').split('/').collect();
-    
+
     if path_parts.len() == 2 {
         // Decode URL-encoded book name (handles spaces as %20, etc.)
         let book_name = if let Ok(decoded) = decode(path_parts[0]) {
@@ -37,18 +37,18 @@ pub fn parse_book_chapter_from_url(pathname: &str) -> Option<(String, u32)> {
             return Some((book_name, chapter_num));
         }
     }
-    
+
     None
 }
 
 /// Validate if a URL path represents a valid Bible chapter
-/// 
+///
 /// Checks if the given pathname follows the expected format
 /// for Bible chapter URLs: `/{book_name}/{chapter_number}`
-/// 
+///
 /// # Arguments
 /// * `pathname` - URL pathname to validate
-/// 
+///
 /// # Returns
 /// * `true` if the path has the correct format
 /// * `false` if the path is invalid or incomplete
@@ -99,4 +99,4 @@ mod tests {
         assert!(!is_valid_chapter_path("/Genesis"));
         assert!(!is_valid_chapter_path("/invalid"));
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/utils/utils.rs b/site/src/utils/utils.rs
index df4c07a..dd62879 100644
--- a/site/src/utils/utils.rs
+++ b/site/src/utils/utils.rs
@@ -15,14 +15,20 @@ pub fn execute_with_navigation<F>(
     F: Fn(&str, NavigateOptions) + Clone,
 {
     let mut instruction_result = InstructionResult::Failed("Not executed".to_string());
-    
+
     view_state.update(|state| {
         instruction_result = state.execute(&instruction);
     });
-    
+
     match instruction_result {
         InstructionResult::Navigate(path) => {
-            navigate(&path, NavigateOptions { scroll: false, ..Default::default() });
+            navigate(
+                &path,
+                NavigateOptions {
+                    scroll: false,
+                    ..Default::default()
+                },
+            );
         }
         InstructionResult::Handled => {
             // Instruction was handled, nothing more to do
@@ -33,7 +39,9 @@ pub fn execute_with_navigation<F>(
         }
         InstructionResult::NotHandled => {
             #[cfg(target_arch = "wasm32")]
-            leptos::web_sys::console::warn_1(&format!("⚠️ Instruction not handled: {:?}", instruction).into());
+            leptos::web_sys::console::warn_1(
+                &format!("⚠️ Instruction not handled: {:?}", instruction).into(),
+            );
         }
     }
 }
@@ -47,4 +55,4 @@ pub fn is_mobile_screen() -> bool {
         }
     }
     false
-}
\ No newline at end of file
+}
diff --git a/site/src/views/about.rs b/site/src/views/about.rs
index fd77e5f..f86fb8a 100644
--- a/site/src/views/about.rs
+++ b/site/src/views/about.rs
@@ -5,15 +5,15 @@ pub fn About() -> impl IntoView {
     view! {
         <article class="max-w-2xl mx-auto px-4 py-12">
             <h1 class="text-2xl font-bold mb-8" style="color: var(--theme-text-primary)">"About"</h1>
-            
+
             <div class="space-y-8 text-sm leading-relaxed" style="color: var(--theme-text-primary)">
                 <section>
                     <p class="mb-4">
                         "A keyboard-driven Bible reading website. Built with Rust and open source."
                     </p>
-                    <a 
-                        href="https://github.com/biblecomputer/bible" 
-                        target="_blank" 
+                    <a
+                        href="https://github.com/biblecomputer/bible"
+                        target="_blank"
                         rel="noopener noreferrer"
                         class="hover:underline translation-link"
                     >
@@ -58,4 +58,4 @@ pub fn About() -> impl IntoView {
             </div>
         </article>
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/views/chapter_view.rs b/site/src/views/chapter_view.rs
index a4000c9..15bcc14 100644
--- a/site/src/views/chapter_view.rs
+++ b/site/src/views/chapter_view.rs
@@ -1,12 +1,12 @@
+use crate::core::types::Language;
 use crate::core::{get_bible, init_bible_signal, Chapter, VerseRange};
 use crate::storage::translations::get_current_translation;
-use crate::core::types::Language;
 use leptos::prelude::*;
 use leptos::view;
+use leptos::wasm_bindgen::JsCast;
 use leptos::IntoView;
 use leptos_router::components::A;
 use wasm_bindgen_futures::spawn_local;
-use leptos::wasm_bindgen::JsCast;
 
 // Removed redundant get_translated_chapter_name function - names are already translated
 
@@ -34,25 +34,25 @@ fn get_navigation_text(key: &str) -> String {
 }
 
 #[component]
-pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool>) -> impl IntoView {
+pub fn ChapterDetail(
+    chapter: Chapter,
+    verse_visibility_enabled: ReadSignal<bool>,
+) -> impl IntoView {
     let bible_signal = init_bible_signal();
-    
+
     // Parse verse ranges from URL - track location explicitly for reactivity
     let location = leptos_router::hooks::use_location();
     let highlighted_verses = Memo::new(move |_| {
         let search_params = location.search.get(); // Explicitly track location.search
-        // Parse verse ranges from the search params
-        if let Some(verses_param) = search_params
-            .split('&')
-            .find_map(|param| {
-                let mut parts = param.split('=');
-                if parts.next()? == "verses" {
-                    parts.next()
-                } else {
-                    None
-                }
-            })
-        {
+                                                   // Parse verse ranges from the search params
+        if let Some(verses_param) = search_params.split('&').find_map(|param| {
+            let mut parts = param.split('=');
+            if parts.next()? == "verses" {
+                parts.next()
+            } else {
+                None
+            }
+        }) {
             verses_param
                 .split(',')
                 .filter_map(|range_str| VerseRange::from_string(range_str))
@@ -61,13 +61,13 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
             Vec::new()
         }
     });
-    
+
     // Enable smooth scrolling globally
     Effect::new(move |_| {
         spawn_local(async move {
             // Small delay to ensure the DOM is ready
             gloo_timers::future::TimeoutFuture::new(50).await;
-            
+
             if let Some(window) = web_sys::window() {
                 if let Some(document) = window.document() {
                     // Use CSS scroll-behavior for smooth scrolling
@@ -77,8 +77,12 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
                         }
                     }
                     if let Some(document_element) = document.document_element() {
-                        if let Ok(html_element) = document_element.dyn_into::<web_sys::HtmlElement>() {
-                            let _ = html_element.style().set_property("scroll-behavior", "smooth");
+                        if let Ok(html_element) =
+                            document_element.dyn_into::<web_sys::HtmlElement>()
+                        {
+                            let _ = html_element
+                                .style()
+                                .set_property("scroll-behavior", "smooth");
                         }
                     }
                 }
@@ -89,35 +93,38 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
     // Auto-focus and scroll to highlighted verses whenever they change
     Effect::new(move |_| {
         let verse_ranges = highlighted_verses.get();
-        
-        
+
         spawn_local(async move {
             // Try multiple times with increasing delays to handle timing issues
             for delay in [50, 150, 300, 500] {
                 gloo_timers::future::TimeoutFuture::new(delay).await;
-                
+
                 if let Some(window) = web_sys::window() {
                     if let Some(document) = window.document() {
                         if let Some(first_range) = verse_ranges.first() {
                             // Focus on the first verse in the first range
                             let verse_id = format!("verse-{}", first_range.start);
-                            
+
                             if let Some(verse_element) = document.get_element_by_id(&verse_id) {
                                 // First scroll the element into view
                                 verse_element.scroll_into_view();
-                                
+
                                 // Then try to focus and adjust position
-                                if let Ok(html_element) = verse_element.dyn_into::<web_sys::HtmlElement>() {
+                                if let Ok(html_element) =
+                                    verse_element.dyn_into::<web_sys::HtmlElement>()
+                                {
                                     let _ = html_element.focus();
-                                    
+
                                     // Try to adjust position to vim-like scrolloff (1/3 from top)
                                     if let Some(window) = web_sys::window() {
                                         if let Ok(window_height) = window.inner_height() {
                                             if let Some(window_height) = window_height.as_f64() {
                                                 // Get current scroll position and adjust
-                                                let current_scroll = window.scroll_y().unwrap_or(0.0);
+                                                let current_scroll =
+                                                    window.scroll_y().unwrap_or(0.0);
                                                 // Move the element down by 1/3 of screen height to achieve vim scrolloff
-                                                let adjusted_scroll = current_scroll - (window_height / 3.0);
+                                                let adjusted_scroll =
+                                                    current_scroll - (window_height / 3.0);
                                                 window.scroll_to_with_x_and_y(0.0, adjusted_scroll);
                                             }
                                         }
@@ -127,8 +134,12 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
                             }
                         } else {
                             // No verses selected, focus the chapter heading for accessibility
-                            if let Some(heading_element) = document.get_element_by_id("chapter-heading") {
-                                if let Ok(html_element) = heading_element.dyn_into::<web_sys::HtmlElement>() {
+                            if let Some(heading_element) =
+                                document.get_element_by_id("chapter-heading")
+                            {
+                                if let Ok(html_element) =
+                                    heading_element.dyn_into::<web_sys::HtmlElement>()
+                                {
                                     let _ = html_element.focus();
                                 }
                             }
@@ -139,13 +150,13 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
             }
         });
     });
-    
+
     // Clone the chapter for use in closures
     // Strategic cloning: clone once per memo instead of multiple times
     let chapter_for_prev = chapter.clone();
     let chapter_for_next = chapter.clone();
     let chapter_for_data = chapter.clone();
-    
+
     // Create reactive computations for navigation chapters
     let prev_chapter = Memo::new(move |_| {
         if let Some(bible) = bible_signal.get() {
@@ -154,7 +165,7 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
             get_bible().get_previous_chapter(&chapter_for_prev)
         }
     });
-    
+
     let next_chapter = Memo::new(move |_| {
         if let Some(bible) = bible_signal.get() {
             bible.get_next_chapter(&chapter_for_next)
@@ -162,15 +173,20 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
             get_bible().get_next_chapter(&chapter_for_next)
         }
     });
-    
+
     let prev_path = Memo::new(move |_| prev_chapter.get().as_ref().map(|ch| ch.to_path()));
     let next_path = Memo::new(move |_| next_chapter.get().as_ref().map(|ch| ch.to_path()));
-    
+
     // Create reactive chapter data - only update when bible translation changes, not on verse navigation
     let current_chapter_data = Memo::new(move |_| {
         if let Some(bible) = bible_signal.get() {
             // Try to get the equivalent chapter from the new Bible
-            let book_name = chapter_for_data.name.split_whitespace().take(chapter_for_data.name.split_whitespace().count() - 1).collect::<Vec<_>>().join(" ");
+            let book_name = chapter_for_data
+                .name
+                .split_whitespace()
+                .take(chapter_for_data.name.split_whitespace().count() - 1)
+                .collect::<Vec<_>>()
+                .join(" ");
             if let Ok(new_chapter) = bible.get_chapter(&book_name, chapter_for_data.chapter) {
                 new_chapter
             } else {
@@ -180,76 +196,77 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
             chapter_for_data.clone()
         }
     });
-    
+
     // Cache the chapter data to prevent unnecessary re-renders during verse navigation
     let stable_chapter_data = RwSignal::new(current_chapter_data.get_untracked());
-    
+
     // Only update the stable data when the chapter actually changes (not just verse navigation)
     Effect::new(move |_| {
         let new_chapter = current_chapter_data.get();
         let current_stable = stable_chapter_data.get_untracked();
-        
+
         // Only update if the chapter book/number changed, not just verse highlighting
-        if new_chapter.name != current_stable.name || new_chapter.chapter != current_stable.chapter {
+        if new_chapter.name != current_stable.name || new_chapter.chapter != current_stable.chapter
+        {
             stable_chapter_data.set(new_chapter);
         }
     });
-    
+
     view! {
         <article class="chapter-detail max-w-2xl mx-auto px-4 pb-32">
             <header class="mb-8">
                 <h1 id="chapter-heading" class="text-3xl font-bold" style="color: var(--theme-text-primary)" tabindex="-1">{move || stable_chapter_data.get().name.clone()}</h1>
             </header>
-            
+
             <div class="verses text-lg leading-8" style="color: var(--theme-text-primary)" role="main" aria-label="Chapter text">
                 {move || {
                     let chapter_data = stable_chapter_data.get();
                     let verses = &chapter_data.verses;
                     let verse_ranges = highlighted_verses.get(); // Single reactive read
-                    
+
                     // Pre-allocate vector with exact capacity for better memory efficiency
                     let mut verse_views = Vec::with_capacity(verses.len());
-                    
+
                     for verse in verses {
                         let is_highlighted = verse_ranges.iter().any(|range| range.contains(verse.verse));
-                        
+
                         // Use theme colors via CSS custom properties
                         let verse_number_class = if is_highlighted {
                             "text-xs font-semibold mr-1 align-sub"
                         } else {
                             "text-xs mr-1 align-sub"
                         };
-                        
+
                         let verse_number_style = if is_highlighted {
                             "color: var(--theme-verse-number-highlighted)"
                         } else {
                             "color: var(--theme-verse-number)"
                         };
-                        
+
                         let verse_text_class = if is_highlighted {
                             "font-bold px-1 rounded"
                         } else {
                             ""
                         };
-                        
+
                         let verse_text_style = if is_highlighted {
                             "color: var(--theme-verse-text-highlighted); background-color: var(--theme-verse-background-highlighted)"
                         } else {
                             "color: var(--theme-text-primary)"
                         };
-                        
+
                         let tabindex = if is_highlighted { "0" } else { "-1" };
                         // Clone verse text for view (required by Leptos)
                         let verse_text = verse.text.clone();
                         let verse_number = verse.verse;
-                        
+
                         verse_views.push(view! {
                             <>
-                                <Show 
+                                <Show
                                     when=move || verse_visibility_enabled.get() && verse_number != 1
                                     fallback=|| view! { <></> }
                                 >
-                                    <span 
+                                    <span
                                         class=verse_number_class
                                         style=verse_number_style
                                         role="text"
@@ -257,7 +274,7 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
                                         {verse_number}
                                     </span>
                                 </Show>
-                                <span 
+                                <span
                                     class=verse_text_class
                                     style=verse_text_style
                                     id=format!("verse-{}", verse_number)
@@ -268,11 +285,11 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
                             </>
                         });
                     }
-                    
+
                     verse_views
                 }}
             </div>
-            
+
             <nav class="flex justify-between items-center mt-8 pt-6 border-t" style="border-color: var(--theme-sidebar-border)" role="navigation" aria-label="Chapter navigation">
                 {move || if let Some(path) = prev_path.get() {
                     view! {
@@ -285,7 +302,7 @@ pub fn ChapterDetail(chapter: Chapter, verse_visibility_enabled: ReadSignal<bool
                 } else {
                     view! { <div class="invisible"></div> }.into_any()
                 }}
-                
+
                 {move || if let Some(path) = next_path.get() {
                     view! {
                         <A href=path attr:class="p-4 rounded-md transition-colors group navigation-button" attr:style="color: var(--theme-navigation-text); display: flex; align-items: center; justify-content: center;" attr:aria-label={get_navigation_text("next_chapter")} attr:title={get_navigation_text("next_chapter")}>
diff --git a/site/src/views/home_translation_picker.rs b/site/src/views/home_translation_picker.rs
index 40eaf22..9a4d26e 100644
--- a/site/src/views/home_translation_picker.rs
+++ b/site/src/views/home_translation_picker.rs
@@ -1,13 +1,13 @@
+use crate::components::{theme_switcher::ThemeSwitcher, CustomTranslationImport};
+use crate::core::types::Language;
+use crate::storage::{
+    download_translation_with_progress, get_available_languages, get_selected_translation,
+    get_translations_by_language, is_translation_downloaded, set_selected_translation,
+    switch_bible_translation, uninstall_translation, BibleTranslation,
+};
 use leptos::prelude::*;
 use leptos_router::hooks::use_navigate;
 use leptos_router::NavigateOptions;
-use crate::storage::{
-    get_selected_translation, set_selected_translation, 
-    is_translation_downloaded, download_translation_with_progress, switch_bible_translation, uninstall_translation,
-    get_available_languages, get_translations_by_language, BibleTranslation
-};
-use crate::core::types::Language;
-use crate::components::{theme_switcher::ThemeSwitcher, CustomTranslationImport};
 use wasm_bindgen_futures::spawn_local;
 
 #[derive(Clone, PartialEq)]
@@ -41,10 +41,12 @@ fn TranslationItem(
     let translation_name = translation.name.clone();
     let translation_release_year = translation.release_year;
     let translation_clone_for_download = translation.clone();
-    
+
     #[cfg(target_arch = "wasm32")]
-    web_sys::console::log_1(&format!("TranslationItem rendered for: {}", translation_short_name).into());
-    
+    web_sys::console::log_1(
+        &format!("TranslationItem rendered for: {}", translation_short_name).into(),
+    );
+
     view! {
         <div class="relative">
             {
@@ -56,12 +58,12 @@ fn TranslationItem(
                 // Watch the refresh trigger and check download status
                 let _ = ui_refresh_trigger.get();
                 let is_downloaded = is_translation_downloaded(&translation_short_name_ref);
-                
+
                 #[cfg(target_arch = "wasm32")]
-                web_sys::console::log_1(&format!("Translation {} - downloading: {}, downloaded: {}, uninstalling: {}", 
+                web_sys::console::log_1(&format!("Translation {} - downloading: {}, downloaded: {}, uninstalling: {}",
                     translation_short_name_ref, is_downloading, is_downloaded, is_uninstalling).into());
-                
-                
+
+
                 if is_downloading {
                     view! {
                         <div class="border rounded-lg p-6 shadow-sm" style="background-color: var(--theme-background); border-color: var(--theme-sidebar-border)">
@@ -82,7 +84,7 @@ fn TranslationItem(
                                     <div>
                                         <div class="text-sm font-medium" style="color: var(--theme-text-primary)">"Downloading..."</div>
                                         <div class="w-24 rounded-full h-1 mt-1" style="background-color: var(--theme-sidebar-border)">
-                                            <div 
+                                            <div
                                                 class="h-1 rounded-full transition-all duration-300 ease-out" style="background-color: var(--theme-buttons-primary-background)"
                                                 style:width={format!("{}%", download_progress.get() * 100.0)}
                                             ></div>
@@ -94,7 +96,7 @@ fn TranslationItem(
                     }.into_any()
                 } else if is_downloaded {
                     view! {
-                        <button 
+                        <button
                             class="w-full border rounded-lg p-6 shadow-sm hover:shadow-md transition-shadow text-left cursor-pointer"
                             style="background-color: var(--theme-background); border-color: var(--theme-sidebar-border)"
                             disabled=move || is_switching.get() || is_uninstalling
@@ -106,7 +108,7 @@ fn TranslationItem(
                                         set_is_switching.set(true);
                                         let _ = set_selected_translation(&translation_short_name_clone3);
                                         set_selected_translation_signal.set(translation_short_name_clone3.clone());
-                                        
+
                                         let translation_short_name_clone2 = translation_short_name_clone3.clone();
                                         let navigate_clone2 = navigate_clone.clone();
                                         spawn_local(async move {
@@ -154,7 +156,7 @@ fn TranslationItem(
                                                                 #[cfg(target_arch = "wasm32")]
                                                                 web_sys::console::log_1(&format!("Delete clicked for: {}", translation_short_name_clone4).into());
                                                                 set_uninstalling_translation.set(Some(translation_short_name_clone4.clone()));
-                                                                
+
                                                                 let translation_short_name_clone2 = translation_short_name_clone4.clone();
                                                                 spawn_local(async move {
                                                                     match uninstall_translation(&translation_short_name_clone2).await {
@@ -171,7 +173,7 @@ fn TranslationItem(
                                                                             set_uninstalling_translation.set(None);
                                                                         }
                                                                     }
-                                                                });  
+                                                                });
                                                             }
                                                         }
                                                     }
@@ -210,7 +212,7 @@ fn TranslationItem(
                     }.into_any()
                 } else {
                     view! {
-                        <button 
+                        <button
                             class="w-full border rounded-lg p-6 shadow-sm hover:shadow-md transition-shadow text-left cursor-pointer"
                             style="background-color: var(--theme-background); border-color: var(--theme-sidebar-border)"
                             on:click={
@@ -224,11 +226,11 @@ fn TranslationItem(
                                     set_download_error.set(None);
                                     set_download_progress.set(0.0);
                                     set_download_status.set("Preparing download...".to_string());
-                                    
+
                                     let translation_clone2 = translation_clone.clone();
                                     let translation_short_name_clone2 = translation_short_name_clone.clone();
                                     let navigate_clone2 = navigate_clone.clone();
-                                    
+
                                     // Create progress callback
                                     let progress_callback = {
                                         move |progress: f32, status: String| {
@@ -236,17 +238,17 @@ fn TranslationItem(
                                             set_download_status.set(status);
                                         }
                                     };
-                                    
+
                                     spawn_local(async move {
                                         match download_translation_with_progress(&translation_clone2, progress_callback).await {
                                             Ok(_) => {
                                                 let _ = set_selected_translation(&translation_short_name_clone2);
                                                 set_selected_translation_signal.set(translation_short_name_clone2.clone());
-                                                
+
                                                 if let Err(e) = switch_bible_translation(&translation_short_name_clone2).await {
                                                     leptos::logging::error!("Failed to switch translation: {}", e);
                                                 }
-                                                
+
                                                 set_downloading_translation.set(None);
                                                 set_download_progress.set(0.0);
                                                 // Trigger UI refresh to update download status
@@ -282,7 +284,7 @@ fn TranslationItem(
                     }.into_any()
                 }
             }}
-            
+
         </div>
     }
 }
@@ -292,50 +294,54 @@ pub fn HomeTranslationPicker(
     current_theme: ReadSignal<crate::themes::Theme>,
     set_current_theme: WriteSignal<crate::themes::Theme>,
 ) -> impl IntoView {
-    let (selected_translation, set_selected_translation_signal) = signal(get_selected_translation().unwrap_or_else(|| "sv".to_string()));
+    let (selected_translation, set_selected_translation_signal) =
+        signal(get_selected_translation().unwrap_or_else(|| "sv".to_string()));
     let (downloading_translation, set_downloading_translation) = signal::<Option<String>>(None);
     let (view_state, set_view_state) = signal(ViewState::LanguageSelection);
-    
+
     // Debug: Watch downloading translation changes
     Effect::new(move |_| {
         let _current = downloading_translation.get();
         #[cfg(target_arch = "wasm32")]
-        web_sys::console::log_1(&format!("Downloading translation changed to: {:?}", _current).into());
+        web_sys::console::log_1(
+            &format!("Downloading translation changed to: {:?}", _current).into(),
+        );
     });
     let (download_progress, set_download_progress) = signal::<f32>(0.0);
     let (download_status, set_download_status) = signal::<String>(String::new());
     let (download_error, set_download_error) = signal::<Option<String>>(None);
     let (is_switching, set_is_switching) = signal(false);
     let (uninstalling_translation, set_uninstalling_translation) = signal::<Option<String>>(None);
-    
+
     // Debug: Watch uninstalling translation changes
     Effect::new(move |_| {
         let _current = uninstalling_translation.get();
         #[cfg(target_arch = "wasm32")]
-        web_sys::console::log_1(&format!("Uninstalling translation changed to: {:?}", _current).into());
+        web_sys::console::log_1(
+            &format!("Uninstalling translation changed to: {:?}", _current).into(),
+        );
     });
-    
+
     let (uninstall_error, _set_uninstall_error) = signal::<Option<String>>(None);
     let (ui_refresh_trigger, set_ui_refresh_trigger) = signal::<u32>(0);
-    
+
     // Debug: Watch UI refresh trigger changes
     Effect::new(move |_| {
         let _current = ui_refresh_trigger.get();
         #[cfg(target_arch = "wasm32")]
         web_sys::console::log_1(&format!("UI refresh trigger changed to: {}", _current).into());
     });
-    
+
     let navigate = use_navigate();
     let languages = get_available_languages();
-    
-    
+
     // Get the current URL parameters once at component initialization
     let location = leptos_router::hooks::use_location();
     let search_params = location.search.get();
-    
+
     #[cfg(target_arch = "wasm32")]
     web_sys::console::log_1(&format!("Search params: {}", search_params).into());
-    
+
     let return_url = {
         use urlencoding::decode;
         // Parse return_url parameter
@@ -345,18 +351,18 @@ pub fn HomeTranslationPicker(
                 .find('&')
                 .map(|pos| return_url_start + pos)
                 .unwrap_or(search_params.len());
-            
+
             let encoded_return_url = &search_params[return_url_start..return_url_end];
-            
+
             #[cfg(target_arch = "wasm32")]
             web_sys::console::log_1(&format!("Encoded return URL: {}", encoded_return_url).into());
-            
+
             if let Ok(decoded_url) = decode(encoded_return_url) {
                 let decoded_string = decoded_url.to_string();
-                
+
                 #[cfg(target_arch = "wasm32")]
                 web_sys::console::log_1(&format!("Decoded return URL: {}", decoded_string).into());
-                
+
                 Some(decoded_string)
             } else {
                 #[cfg(target_arch = "wasm32")]
@@ -373,14 +379,26 @@ pub fn HomeTranslationPicker(
     let navigate_to_first_chapter = move || {
         // Use the pre-parsed return URL if available
         if let Some(ref return_url) = return_url {
-            navigate(return_url, NavigateOptions { scroll: false, ..Default::default() });
+            navigate(
+                return_url,
+                NavigateOptions {
+                    scroll: false,
+                    ..Default::default()
+                },
+            );
             return;
         }
-        
+
         // Fallback: navigate to Genesis 1 if no return URL
-        navigate("/Genesis/1", NavigateOptions { scroll: false, ..Default::default() });
+        navigate(
+            "/Genesis/1",
+            NavigateOptions {
+                scroll: false,
+                ..Default::default()
+            },
+        );
     };
-    
+
     view! {
         <div class="max-w-2xl mx-auto py-8">
             <div class="flex justify-between mb-4">
@@ -411,7 +429,7 @@ pub fn HomeTranslationPicker(
                     }}
                 </p>
             </div>
-            
+
             <div class="space-y-4">
                 {move || match view_state.get() {
                     ViewState::LanguageSelection => {
@@ -484,7 +502,7 @@ pub fn HomeTranslationPicker(
                                     }
                                 }).collect_view()
                                 }
-                                
+
                                 <CustomTranslationImport
                                     selected_language=RwSignal::new(selected_language.clone()).read_only()
                                     on_success=move || {
@@ -498,7 +516,7 @@ pub fn HomeTranslationPicker(
                     }
                 }}
             </div>
-            
+
             <Show
                 when=move || download_error.get().is_some()
                 fallback=|| view! { <></> }
@@ -515,7 +533,7 @@ pub fn HomeTranslationPicker(
                     </div>
                 </div>
             </Show>
-            
+
             <Show
                 when=move || uninstall_error.get().is_some()
                 fallback=|| view! { <></> }
@@ -534,4 +552,4 @@ pub fn HomeTranslationPicker(
             </Show>
         </div>
     }
-}
\ No newline at end of file
+}
diff --git a/site/src/views/mod.rs b/site/src/views/mod.rs
index 3f36632..d2b45fe 100644
--- a/site/src/views/mod.rs
+++ b/site/src/views/mod.rs
@@ -1,7 +1,7 @@
+pub mod about;
 pub mod chapter_view;
 pub mod home_translation_picker;
-pub mod about;
 
+pub use about::*;
 pub use chapter_view::*;
 pub use home_translation_picker::*;
-pub use about::*;
\ No newline at end of file
diff --git a/sources/.DS_Store b/sources/.DS_Store
deleted file mode 100644
index 5a5eb83..0000000
Binary files a/sources/.DS_Store and /dev/null differ