diff --git a/render-wasm/src/render.rs b/render-wasm/src/render.rs
index 34673cdf3b..f2f04ed8fa 100644
--- a/render-wasm/src/render.rs
+++ b/render-wasm/src/render.rs
@@ -1395,16 +1395,16 @@ impl RenderState {
             }
 
             // Draw directly from cache surface, avoiding snapshot overhead
-            self.surfaces.draw_cache_to_target();
+            // self.surfaces.draw_cache_to_target();
 
             // Restore canvas state
             self.surfaces.canvas(SurfaceId::Target).restore();
 
-            // When zooming out, the cached surface (from a previous, more zoomed-in
-            // render) may not cover the newly visible world area. Fill those gaps
-            // with any cached tiles (exact zoom or cross-zoom fallback) so we don't
-            // show temporary empty squares.
-            if navigate_zoom < 1.0 {
+            // When zooming out OR panning, the cached surface (from a previous render)
+            // may not cover the newly visible world area. Fill those gaps with any
+            // cached tiles (exact zoom or cross-zoom fallback) so we don't show
+            // temporary empty squares while tiles for the new view are rendering.
+            // if navigate_zoom <= 1.0 {
                 let current_scale = self.get_scale();
                 let current_scale_bits = current_scale.to_bits();
                 let tiles::TileRect(vsx, vsy, vex, vey) =
@@ -1413,11 +1413,6 @@ impl RenderState {
                 let offset_x = self.viewbox.area.left * current_scale;
                 let offset_y = self.viewbox.area.top * current_scale;
 
-                let mut exact_hits: usize = 0;
-                let mut fallback_hits: usize = 0;
-                let mut fallback_blits: usize = 0;
-                let mut misses: usize = 0;
-
                 for x in vsx..=vex {
                     for y in vsy..=vey {
                         let tile = tiles::Tile::from(x, y);
@@ -1427,17 +1422,19 @@ impl RenderState {
                             tiles::TILE_SIZE,
                             tiles::TILE_SIZE,
                         );
-                        if self.surfaces.has_cached_tile_surface(tile, current_scale_bits) {
+                        if self
+                            .surfaces
+                            .has_cached_tile_surface(tile, current_scale_bits)
+                        {
                             self.surfaces.draw_cached_tile_surface(
                                 tile,
                                 current_scale_bits,
                                 rect,
                                 self.background_color,
                             );
-                            exact_hits += 1;
                         } else {
                             let target_world_rect = tiles::get_tile_rect(tile, current_scale);
-                            let blits = self.surfaces.draw_tile_fallback_cross_zoom(
+                            let _ = self.surfaces.draw_tile_fallback_cross_zoom(
                                 &self.tile_viewbox,
                                 rect,
                                 self.background_color,
@@ -1446,21 +1443,10 @@ impl RenderState {
                                 current_scale_bits,
                                 true,
                             );
-                            if blits > 0 {
-                                fallback_hits += 1;
-                                fallback_blits += blits;
-                            } else {
-                                misses += 1;
-                            }
                         }
                     }
                 }
-
-                eprintln!(
-                    "render_from_cache zoom-out fill: exact_hits={} fallback_tiles={} fallback_blits={} misses={} scale={}",
-                    exact_hits, fallback_hits, fallback_blits, misses, current_scale
-                );
-            }
+            // }
 
             if self.options.is_debug_visible() {
                 debug::render(self);
@@ -2579,7 +2565,10 @@ impl RenderState {
             if let Some(current_tile) = self.current_tile {
                 let scale = self.get_scale();
                 let scale_bits = scale.to_bits();
-                if self.surfaces.has_cached_tile_surface(current_tile, scale_bits) {
+                if self
+                    .surfaces
+                    .has_cached_tile_surface(current_tile, scale_bits)
+                {
                     performance::begin_measure!("render_shape_tree::cached");
                     let tile_rect = self.get_current_tile_bounds()?;
                     self.surfaces.draw_cached_tile_surface(
diff --git a/render-wasm/src/render/surfaces.rs b/render-wasm/src/render/surfaces.rs
index 840337d41b..edb8152d64 100644
--- a/render-wasm/src/render/surfaces.rs
+++ b/render-wasm/src/render/surfaces.rs
@@ -676,35 +676,21 @@ impl Surfaces {
         target_scale_bits: u32,
         debug_trace: bool,
     ) -> usize {
-        let Some(candidate_scale_bits) =
-            self.tiles
-                .best_fallback_scale_bits(target_scale, target_scale_bits)
+        let Some(candidate_scale_bits) = self
+            .tiles
+            .best_fallback_scale_bits(target_scale, target_scale_bits)
         else {
             if debug_trace {
-                println!(
-                    "tile_fallback: no candidate scale (target_scale={})",
-                    target_scale
-                );
             }
             return 0;
         };
 
         let src_scale = f32::from_bits(candidate_scale_bits);
         if !src_scale.is_finite() || src_scale <= 0.0 {
-            if debug_trace {
-                println!(
-                    "tile_fallback: invalid candidate scale (bits={}, scale={})",
-                    candidate_scale_bits, src_scale
-                );
-            }
             return 0;
         }
 
         if debug_trace {
-            println!(
-                "tile_fallback: target_scale={} -> candidate_scale={}",
-                target_scale, src_scale
-            );
         }
 
         let tile_size_src_world = super::tiles::get_tile_size(src_scale);
@@ -721,7 +707,8 @@ impl Surfaces {
                 };
 
                 let src_world_rect = super::tiles::get_tile_rect(src_tile, src_scale);
-                let Some(overlap_world) = Self::rect_intersection(target_world_rect, src_world_rect)
+                let Some(overlap_world) =
+                    Self::rect_intersection(target_world_rect, src_world_rect)
                 else {
                     continue;
                 };
@@ -767,10 +754,6 @@ impl Surfaces {
             self.tiles.free_tiles(tile_viewbox);
         }
 
-        if debug_trace {
-            println!("tile_fallback: blits={}", blits);
-        }
-
         blits
     }
 
@@ -847,6 +830,7 @@ impl TileTextureCache {
     }
 
     fn gc(&mut self) {
+        println!("gc");
         // Make a real remove
         let removed = std::mem::take(&mut self.removed);
         for key in removed.iter() {
@@ -897,7 +881,6 @@ impl TileTextureCache {
         };
         self.scales.insert(scale_bits);
         self.grid.insert(key, image);
-        println!("add: {:?}", key);
         self.removed.remove(&key);
     }
 
@@ -931,7 +914,11 @@ impl TileTextureCache {
         self.grid.len()
     }
 
-    pub fn best_fallback_scale_bits(&self, target_scale: f32, target_scale_bits: u32) -> Option<u32> {
+    pub fn best_fallback_scale_bits(
+        &self,
+        target_scale: f32,
+        target_scale_bits: u32,
+    ) -> Option<u32> {
         let mut best: Option<(f32, u32)> = None;
         for bits in self.scales.iter().copied() {
             if bits == target_scale_bits {