diff --git a/src/disc/bluray.rs b/src/disc/bluray.rs
index b2eeebe..a0edc02 100644
--- a/src/disc/bluray.rs
+++ b/src/disc/bluray.rs
@@ -12,19 +12,8 @@ impl Disc {
         reader: &mut dyn SectorReader,
         udf_fs: &udf::UdfFs,
     ) -> Vec<DiscTitle> {
-        let t0 = std::time::Instant::now();
         let mut titles = Vec::new();
         if let Some(playlist_dir) = udf_fs.find_dir("/BDMV/PLAYLIST") {
-            let mpls_count = playlist_dir
-                .entries
-                .iter()
-                .filter(|e| !e.is_dir && e.name.to_lowercase().ends_with(".mpls"))
-                .count();
-            eprintln!(
-                "[titles {:.1}s] {} MPLS files",
-                t0.elapsed().as_secs_f64(),
-                mpls_count
-            );
             for entry in &playlist_dir.entries {
                 if !entry.is_dir && entry.name.to_lowercase().ends_with(".mpls") {
                     let path = format!("/BDMV/PLAYLIST/{}", entry.name);
@@ -32,23 +21,12 @@ impl Disc {
                         if let Some(title) =
                             Self::parse_playlist(reader, udf_fs, &entry.name, &mpls_data)
                         {
-                            eprintln!(
-                                "[titles {:.1}s] {} -> title ({:.0}s)",
-                                t0.elapsed().as_secs_f64(),
-                                entry.name,
-                                title.duration_secs
-                            );
                             titles.push(title);
                         }
                     }
                 }
             }
         }
-        eprintln!(
-            "[titles {:.1}s] done: {} titles",
-            t0.elapsed().as_secs_f64(),
-            titles.len()
-        );
         titles
     }
 
diff --git a/src/disc/mod.rs b/src/disc/mod.rs
index 01ebe42..c78ee1c 100644
--- a/src/disc/mod.rs
+++ b/src/disc/mod.rs
@@ -940,37 +940,24 @@ impl Disc {
     /// The session must be open and unlocked (Drive::open handles this).
     /// All disc reads use standard READ(10) via UDF -- no vendor SCSI commands.
     pub fn scan(session: &mut Drive, opts: &ScanOptions) -> Result<Self> {
-        let t0 = std::time::Instant::now();
         // READ CAPACITY may fail in LibreDrive mode — proceed with 0 and estimate later
         let capacity = Self::read_capacity(session).unwrap_or(0);
-        eprintln!(
-            "[scan {:.1}s] capacity={}",
-            t0.elapsed().as_secs_f64(),
-            capacity
-        );
 
         // AACS handshake (Blu-ray/UHD)
         let handshake = Self::do_handshake(session, opts);
-        eprintln!("[scan {:.1}s] handshake done", t0.elapsed().as_secs_f64());
 
         // Request max read speed — removes riplock on DVD
         // (BD/UHD speed is set by firmware init, but DVD needs explicit SET CD SPEED)
         session.set_speed(0xFFFF);
-        eprintln!("[scan {:.1}s] speed set", t0.elapsed().as_secs_f64());
 
+        // Buffer sector reads — USB drives have ~500ms per SCSI command,
+        // so prefetching reduces hundreds of commands to dozens.
         let batch = detect_max_batch_sectors(session.device_path());
         let mut buffered = udf::BufferedSectorReader::new(session, batch);
         let udf_fs = udf::read_filesystem(&mut buffered)?;
-        eprintln!(
-            "[scan {:.1}s] UDF parsed, prefetching metadata ({} sectors)...",
-            t0.elapsed().as_secs_f64(),
-            udf_fs.metadata_sectors()
-        );
         buffered.prefetch(udf_fs.metadata_start(), udf_fs.metadata_sectors());
-        eprintln!("[scan {:.1}s] metadata cached", t0.elapsed().as_secs_f64());
 
         let mut disc = Self::scan_with(&mut buffered, capacity, handshake, opts, udf_fs)?;
-        eprintln!("[scan {:.1}s] scan_with done", t0.elapsed().as_secs_f64());
 
         // CSS key extraction for DVDs (bus auth → disc key → title key).
         // Must be a single auth session — can't call authenticate() separately.
@@ -1020,17 +1007,11 @@ impl Disc {
         opts: &ScanOptions,
         udf_fs: udf::UdfFs,
     ) -> Result<Self> {
-        let t0 = std::time::Instant::now();
-
         // 2. Resolve encryption (AACS, CSS, or none)
         let encrypted =
             udf_fs.find_dir("/AACS").is_some() || udf_fs.find_dir("/BDMV/AACS").is_some();
 
         let aacs = if encrypted {
-            eprintln!(
-                "[scan_with {:.1}s] resolving encryption...",
-                t0.elapsed().as_secs_f64()
-            );
             if let Some(keydb_path) = opts.resolve_keydb() {
                 Self::resolve_encryption(&udf_fs, reader, &keydb_path, handshake.as_ref()).ok()
             } else {
@@ -1039,10 +1020,6 @@ impl Disc {
         } else {
             None
         };
-        eprintln!(
-            "[scan_with {:.1}s] encryption done",
-            t0.elapsed().as_secs_f64()
-        );
 
         // 3. Titles — BD (MPLS playlists) or DVD (IFO title sets)
         let (mut titles, content_format) = if udf_fs.find_dir("/BDMV").is_some() {
@@ -1058,11 +1035,6 @@ impl Disc {
         } else {
             (Vec::new(), ContentFormat::BdTs)
         };
-        eprintln!(
-            "[scan_with {:.1}s] titles done: {}",
-            t0.elapsed().as_secs_f64(),
-            titles.len()
-        );
         titles.sort_by(|a, b| {
             b.duration_secs
                 .partial_cmp(&a.duration_secs)
@@ -1071,12 +1043,7 @@ impl Disc {
 
         // 4. Metadata + labels
         let meta_title = Self::read_meta_title(reader, &udf_fs);
-        eprintln!(
-            "[scan_with {:.1}s] meta_title done",
-            t0.elapsed().as_secs_f64()
-        );
         crate::labels::apply(reader, &udf_fs, &mut titles);
-        eprintln!("[scan_with {:.1}s] labels done", t0.elapsed().as_secs_f64());
 
         // 5. Derive format, layers, region
         let format = Self::detect_format(&titles);