refactor: change tile return type from Vec<u8> to Bytes in SlideService

server/src/slide/local.rs

@@ -441,7 +441,7 @@ impl SlideService for LocalSlideService {
         Ok(meta)
     }
 
-    async fn get_tile(&self, request: &TileRequest) -> Result<Vec<u8>, SlideError> {
+    async fn get_tile(&self, request: &TileRequest) -> Result<Bytes, SlideError> {
         let start = Instant::now();
         counter!("pathcollab_tile_requests_total").increment(1);
 
@@ -456,12 +456,12 @@ impl SlideService for LocalSlideService {
         // Fast path: check tile cache first
         if let Some(cached_tile) = self.tile_cache.get(&cache_key).await {
             histogram!("pathcollab_tile_duration_seconds").record(start.elapsed());
-            return Ok(cached_tile.to_vec());
+            return Ok(cached_tile);
         }
 
         // Cache miss - need to compute the tile
         // Helper to record metrics on all exit paths
-        let record_metrics = |result: &Result<Vec<u8>, SlideError>, start: Instant| {
+        let record_metrics = |result: &Result<Bytes, SlideError>, start: Instant| {
             histogram!("pathcollab_tile_duration_seconds").record(start.elapsed());
             if result.is_err() {
                 counter!("pathcollab_tile_errors_total").increment(1);
@@ -497,13 +497,12 @@ impl SlideService for LocalSlideService {
         // Read and encode the tile
         let result = self
             .read_tile_jpeg(slide, &metadata, request.level, request.x, request.y)
-            .await;
+            .await
+            .map(Bytes::from);
 
         // Cache the tile on success
         if let Ok(ref tile_data) = result {
-            self.tile_cache
-                .insert(cache_key, Bytes::from(tile_data.clone()))
-                .await;
+            self.tile_cache.insert(cache_key, tile_data.clone()).await;
         }
 
         // Record overall tile latency

server/src/slide/service.rs

@@ -1,6 +1,7 @@
 //! SlideService trait definition
 
 use async_trait::async_trait;
+use bytes::Bytes;
 
 use super::types::{SlideError, SlideMetadata, TileRequest};
 
@@ -14,7 +15,7 @@ pub trait SlideService: Send + Sync {
     async fn get_slide(&self, id: &str) -> Result<SlideMetadata, SlideError>;
 
     /// Get a tile as JPEG bytes
-    async fn get_tile(&self, request: &TileRequest) -> Result<Vec<u8>, SlideError>;
+    async fn get_tile(&self, request: &TileRequest) -> Result<Bytes, SlideError>;
 
     /// Check if a slide exists
     async fn slide_exists(&self, id: &str) -> bool {

server/tests/common/mod.rs

@@ -4,6 +4,7 @@
 
 use async_trait::async_trait;
 use axum::{Json, Router, routing::get};
+use bytes::Bytes;
 use pathcollab_server::protocol::SlideInfo;
 use pathcollab_server::server::AppState;
 use pathcollab_server::{
@@ -131,7 +132,7 @@ impl SlideService for MockSlideService {
             .ok_or_else(|| SlideError::NotFound(id.to_string()))
     }
 
-    async fn get_tile(&self, request: &TileRequest) -> Result<Vec<u8>, SlideError> {
+    async fn get_tile(&self, request: &TileRequest) -> Result<Bytes, SlideError> {
         // Verify slide exists
         let metadata = self.get_slide(&request.slide_id).await?;
 
@@ -160,7 +161,7 @@ impl SlideService for MockSlideService {
         }
 
         // Return a test JPEG
-        Ok(Self::create_test_jpeg())
+        Ok(Bytes::from(Self::create_test_jpeg()))
     }
 }