server side cache back in

crates/weaver-app/src/data.rs

···
         async move {
             match fetcher.fetch_entries_from_ufos().await {
                 Ok(entries) => {
+                    // Cache blobs for each entry's embedded images
+                    for arc in &entries {
+                        let (view, entry, _) = arc.as_ref();
+                        if let Some(embeds) = &entry.embeds {
+                            if let Some(images) = &embeds.images {
+                                use jacquard::smol_str::ToSmolStr;
+                                use jacquard::types::aturi::AtUri;
+                                // Extract ident from the entry's at-uri
+                                if let Ok(at_uri) = AtUri::new(view.uri.as_ref()) {
+                                    let ident = at_uri.authority().to_smolstr();
+                                    for image in &images.images {
+                                        let cid = image.image.blob().cid();
+                                        cache_blob(
+                                            ident.clone(),
+                                            cid.to_smolstr(),
+                                            image.name.as_ref().map(|n| n.to_smolstr()),
+                                        )
+                                        .await
+                                        .ok();
+                                    }
+                                }
+                            }
+                        }
+                    }
                     Some(
                         entries
                             .iter()
···
         async move {
             match fetcher.get_entry_by_rkey(ident(), rkey()).await {
                 Ok(Some(data)) => {
+                    // Cache blobs for embedded images
+                    if let Some(embeds) = &data.entry.embeds {
+                        if let Some(images) = &embeds.images {
+                            use jacquard::smol_str::ToSmolStr;
+                            use jacquard::types::aturi::AtUri;
+                            if let Ok(at_uri) = AtUri::new(data.entry_view.uri.as_ref()) {
+                                let ident_str = at_uri.authority().to_smolstr();
+                                for image in &images.images {
+                                    let cid = image.image.blob().cid();
+                                    cache_blob(
+                                        ident_str.clone(),
+                                        cid.to_smolstr(),
+                                        image.name.as_ref().map(|n| n.to_smolstr()),
+                                    )
+                                    .await
+                                    .ok();
+                                }
+                            }
+                        }
+                    }
                     let entry_json = serde_json::to_value(&data.entry).ok()?;
                     let entry_view_json = serde_json::to_value(&data.entry_view).ok()?;
                     let notebook_ctx_json = data.notebook_context.as_ref().map(|ctx| {

crates/weaver-app/src/fetch.rs

···
 #[derive(Clone)]
 pub struct Fetcher {
     pub client: Arc<Client>,
+    #[cfg(feature = "server")]
+    book_cache: cache_impl::Cache<
+        (AtIdentifier<'static>, SmolStr),
+        Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
+    >,
+    #[cfg(feature = "server")]
+    entry_cache: cache_impl::Cache<
+        (AtIdentifier<'static>, SmolStr),
+        Arc<(BookEntryView<'static>, Entry<'static>)>,
+    >,
+    #[cfg(feature = "server")]
+    profile_cache: cache_impl::Cache<AtIdentifier<'static>, Arc<ProfileDataView<'static>>>,
+    #[cfg(feature = "server")]
+    standalone_entry_cache:
+        cache_impl::Cache<(AtIdentifier<'static>, SmolStr), Arc<StandaloneEntryData>>,
 }
 
 //#[cfg(not(feature = "server"))]
···
     pub fn new(client: OAuthClient<JacquardResolver, AuthStore>) -> Self {
         Self {
             client: Arc::new(Client::new(client)),
+            #[cfg(feature = "server")]
+            book_cache: cache_impl::new_cache(100, std::time::Duration::from_secs(30)),
+            #[cfg(feature = "server")]
+            entry_cache: cache_impl::new_cache(100, std::time::Duration::from_secs(30)),
+            #[cfg(feature = "server")]
+            profile_cache: cache_impl::new_cache(100, std::time::Duration::from_secs(1800)),
+            #[cfg(feature = "server")]
+            standalone_entry_cache: cache_impl::new_cache(100, std::time::Duration::from_secs(30)),
         }
     }
 
···
         ident: AtIdentifier<'static>,
         title: SmolStr,
     ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+        #[cfg(feature = "server")]
+        if let Some(cached) = cache_impl::get(&self.book_cache, &(ident.clone(), title.clone())) {
+            return Ok(Some(cached));
+        }
+
         let client = self.get_client();
         if let Some((notebook, entries)) = client
             .notebook_by_title(&ident, &title)
···
             .map_err(|e| dioxus::CapturedError::from_display(e))?
         {
             let stored = Arc::new((notebook, entries));
+            #[cfg(feature = "server")]
+            cache_impl::insert(&self.book_cache, (ident, title), stored.clone());
             Ok(Some(stored))
         } else {
             Err(dioxus::CapturedError::from_display("Notebook not found"))
···
         book_title: SmolStr,
         entry_title: SmolStr,
     ) -> Result<Option<Arc<(BookEntryView<'static>, Entry<'static>)>>> {
+        #[cfg(feature = "server")]
+        if let Some(cached) =
+            cache_impl::get(&self.entry_cache, &(ident.clone(), entry_title.clone()))
+        {
+            return Ok(Some(cached));
+        }
+
         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
             let (notebook, entries) = result.as_ref();
             let client = self.get_client();
···
                 .map_err(|e| dioxus::CapturedError::from_display(e))?
             {
                 let stored = Arc::new(entry);
+                #[cfg(feature = "server")]
+                cache_impl::insert(&self.entry_cache, (ident, entry_title), stored.clone());
                 Ok(Some(stored))
             } else {
                 Err(dioxus::CapturedError::from_display("Entry not found"))
···
             );
             let uri = AtUri::new_owned(uri_str)
                 .map_err(|e| dioxus::CapturedError::from_display(format!("Invalid URI: {}", e)))?;
-
-            // Fetch the full notebook view (which hydrates authors)
             match client.view_notebook(&uri).await {
                 Ok((notebook, entries)) => {
                     let ident = uri.authority().clone().into_static();
···
                         .unwrap_or_else(|| SmolStr::new("Untitled"));
 
                     let result = Arc::new((notebook, entries));
+                    #[cfg(feature = "server")]
+                    cache_impl::insert(&self.book_cache, (ident, title), result.clone());
                     notebooks.push(result);
                 }
                 Err(_) => continue, // Skip notebooks that fail to load
···
 
         let url = "https://ufos-api.microcosm.blue/records?collection=sh.weaver.notebook.entry";
 
-        let response = reqwest::get(url)
-            .await
-            .map_err(|e| {
-                tracing::error!("[fetch_entries_from_ufos] request failed: {:?}", e);
-                dioxus::CapturedError::from_display(e)
-            })?;
-
-        let mut records: Vec<UfosRecord> = response
-            .json()
-            .await
-            .map_err(|e| {
-                tracing::error!("[fetch_entries_from_ufos] json parse failed: {:?}", e);
-                dioxus::CapturedError::from_display(e)
-            })?;
+        let response = reqwest::get(url).await.map_err(|e| {
+            tracing::error!("[fetch_entries_from_ufos] request failed: {:?}", e);
+            dioxus::CapturedError::from_display(e)
+        })?;
 
-        // Sort by time_us descending (reverse chronological)
+        let mut records: Vec<UfosRecord> = response.json().await.map_err(|e| {
+            tracing::error!("[fetch_entries_from_ufos] json parse failed: {:?}", e);
+            dioxus::CapturedError::from_display(e)
+        })?;
         records.sort_by(|a, b| b.time_us.cmp(&a.time_us));
 
         let mut entries = Vec::new();
         let client = self.get_client();
 
         for ufos_record in records {
-            // Parse DID
             let did = match Did::new(&ufos_record.did) {
                 Ok(d) => d.into_static(),
                 Err(e) => {
-                    tracing::warn!("[fetch_entries_from_ufos] invalid DID {}: {:?}", ufos_record.did, e);
+                    tracing::warn!(
+                        "[fetch_entries_from_ufos] invalid DID {}: {:?}",
+                        ufos_record.did,
+                        e
+                    );
                     continue;
                 }
             };
             let ident = AtIdentifier::Did(did);
-
-            // Fetch the entry view
-            match client
-                .fetch_entry_by_rkey(&ident, &ufos_record.rkey)
-                .await
-            {
+            match client.fetch_entry_by_rkey(&ident, &ufos_record.rkey).await {
                 Ok((entry_view, entry)) => {
                     entries.push(Arc::new((
                         entry_view.into_static(),
···
                     )));
                 }
                 Err(e) => {
-                    tracing::warn!("[fetch_entries_from_ufos] failed to load entry {}: {:?}", ufos_record.rkey, e);
+                    tracing::warn!(
+                        "[fetch_entries_from_ufos] failed to load entry {}: {:?}",
+                        ufos_record.rkey,
+                        e
+                    );
                     continue;
                 }
             }
···
                 // View the notebook (which hydrates authors)
                 match client.view_notebook(&record.uri).await {
                     Ok((notebook, entries)) => {
+                        let ident = record.uri.authority().clone().into_static();
+                        let title = notebook
+                            .title
+                            .as_ref()
+                            .map(|t| SmolStr::new(t.as_ref()))
+                            .unwrap_or_else(|| SmolStr::new("Untitled"));
+
                         let result = Arc::new((notebook, entries));
+                        #[cfg(feature = "server")]
+                        cache_impl::insert(&self.book_cache, (ident, title), result.clone());
                         notebooks.push(result);
                     }
                     Err(_) => continue, // Skip notebooks that fail to load
···
         ident: AtIdentifier<'static>,
         book_title: SmolStr,
     ) -> Result<Option<Vec<BookEntryView<'static>>>> {
+        use jacquard::types::aturi::AtUri;
+
         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
-            let (notebook, entries) = result.as_ref();
+            let (notebook, entry_refs) = result.as_ref();
             let mut book_entries = Vec::new();
             let client = self.get_client();
 
-            for index in 0..entries.len() {
-                match client.view_entry(notebook, entries, index).await {
-                    Ok(book_entry) => book_entries.push(book_entry),
-                    Err(_) => continue, // Skip entries that fail to load
+            for (index, entry_ref) in entry_refs.iter().enumerate() {
+                // Try to extract rkey from URI
+                let rkey = AtUri::new(entry_ref.uri.as_ref())
+                    .ok()
+                    .and_then(|uri| uri.rkey().map(|r| SmolStr::new(r.as_ref())));
+
+                // Check cache first
+                #[cfg(feature = "server")]
+                if let Some(ref rkey) = rkey {
+                    if let Some(cached) =
+                        cache_impl::get(&self.entry_cache, &(ident.clone(), rkey.clone()))
+                    {
+                        book_entries.push(cached.0.clone());
+                        continue;
+                    }
+                }
+
+                // Fetch if not cached
+                if let Ok(book_entry) = client.view_entry(notebook, entry_refs, index).await {
+                    // Try to populate cache by deserializing Entry from the view's record
+                    #[cfg(feature = "server")]
+                    if let Some(rkey) = rkey {
+                        use jacquard::IntoStatic;
+                        use weaver_api::sh_weaver::notebook::entry::Entry;
+                        if let Ok(entry) =
+                            jacquard::from_data::<Entry<'_>>(&book_entry.entry.record)
+                        {
+                            let cached =
+                                Arc::new((book_entry.clone().into_static(), entry.into_static()));
+                            cache_impl::insert(&self.entry_cache, (ident.clone(), rkey), cached);
+                        }
+                    }
+                    book_entries.push(book_entry);
                 }
             }
 
···
         &self,
         ident: &AtIdentifier<'_>,
     ) -> Result<Arc<ProfileDataView<'static>>> {
+        use jacquard::IntoStatic;
+
+        let ident_static = ident.clone().into_static();
+
+        #[cfg(feature = "server")]
+        if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
+            return Ok(cached);
+        }
+
         let client = self.get_client();
 
         let did = match ident {
···
             .await
             .map_err(|e| dioxus::CapturedError::from_display(e))?;
 
-        Ok(Arc::new(profile_view))
+        let result = Arc::new(profile_view);
+        #[cfg(feature = "server")]
+        cache_impl::insert(&self.profile_cache, ident_static, result.clone());
+
+        Ok(result)
     }
 
     /// Fetch an entry by rkey with optional notebook context lookup.
···
         rkey: SmolStr,
     ) -> Result<Option<Arc<StandaloneEntryData>>> {
         use jacquard::types::aturi::AtUri;
+
+        #[cfg(feature = "server")]
+        if let Some(cached) =
+            cache_impl::get(&self.standalone_entry_cache, &(ident.clone(), rkey.clone()))
+        {
+            return Ok(Some(cached));
+        }
 
         let client = self.get_client();
 
···
             None
         };
 
-        Ok(Some(Arc::new(StandaloneEntryData {
+        let result = Arc::new(StandaloneEntryData {
             entry,
             entry_view,
             notebook_context,
-        })))
+        });
+        #[cfg(feature = "server")]
+        cache_impl::insert(&self.standalone_entry_cache, (ident, rkey), result.clone());
+
+        Ok(Some(result))
     }
 
     /// Fetch an entry by rkey within a specific notebook context.
···
         rkey: SmolStr,
     ) -> Result<Option<Arc<(BookEntryView<'static>, Entry<'static>)>>> {
         use jacquard::types::aturi::AtUri;
+
+        #[cfg(feature = "server")]
+        if let Some(cached) = cache_impl::get(&self.entry_cache, &(ident.clone(), rkey.clone())) {
+            return Ok(Some(cached));
+        }
 
         let client = self.get_client();
 
···
                 .build();
         }
 
-        Ok(Some(Arc::new((book_entry_view.into_static(), entry))))
+        let result = Arc::new((book_entry_view.into_static(), entry));
+        #[cfg(feature = "server")]
+        cache_impl::insert(&self.entry_cache, (ident, rkey), result.clone());
+
+        Ok(Some(result))
     }
 }
-
-// #[cfg(feature = "server")]
-// #[derive(Clone)]
-// pub struct Fetcher {
-//     pub client: Arc<Client>,
-//     book_cache: cache_impl::Cache<
-//         (AtIdentifier<'static>, SmolStr),
-//         Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
-//     >,
-//     entry_cache: cache_impl::Cache<
-//         (AtIdentifier<'static>, SmolStr),
-//         Arc<(BookEntryView<'static>, Entry<'static>)>,
-//     >,
-//     profile_cache: cache_impl::Cache<AtIdentifier<'static>, Arc<ProfileDataView<'static>>>,
-// }
-
-// // /// SAFETY: This isn't thread-safe on WASM, but we aren't multithreaded on WASM
-// //#[cfg(feature = "server")]
-// unsafe impl Sync for Fetcher {}
-
-// // /// SAFETY: This isn't thread-safe on WASM, but we aren't multithreaded on WASM
-// //#[cfg(feature = "server")]
-// unsafe impl Send for Fetcher {}
-
-// #[cfg(feature = "server")]
-// impl Fetcher {
-//     pub fn new(client: OAuthClient<JacquardResolver, AuthStore>) -> Self {
-//         Self {
-//             client: Arc::new(Client::new(client)),
-//             book_cache: cache_impl::new_cache(100, Duration::from_secs(30)),
-//             entry_cache: cache_impl::new_cache(100, Duration::from_secs(30)),
-//             profile_cache: cache_impl::new_cache(100, Duration::from_secs(1800)),
-//         }
-//     }
-
-//     pub async fn upgrade_to_authenticated(
-//         &self,
-//         session: OAuthSession<JacquardResolver, crate::auth::AuthStore>,
-//     ) {
-//         let mut session_slot = self.client.session.write().await;
-//         *session_slot = Some(Arc::new(Agent::new(session)));
-//     }
-
-//     pub async fn downgrade_to_unauthenticated(&self) {
-//         let mut session_slot = self.client.session.write().await;
-//         if let Some(session) = session_slot.take() {
-//             session.inner().logout().await.ok();
-//         }
-//     }
-
-//     #[allow(dead_code)]
-//     pub async fn current_did(&self) -> Option<Did<'static>> {
-//         let session_slot = self.client.session.read().await;
-//         if let Some(session) = session_slot.as_ref() {
-//             session.info().await.map(|(d, _)| d)
-//         } else {
-//             None
-//         }
-//     }
-
-//     pub fn get_client(&self) -> Arc<Client> {
-//         self.client.clone()
-//     }
-
-//     pub async fn get_notebook(
-//         &self,
-//         ident: AtIdentifier<'static>,
-//         title: SmolStr,
-//     ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
-//         if let Some(entry) = cache_impl::get(&self.book_cache, &(ident.clone(), title.clone())) {
-//             Ok(Some(entry))
-//         } else {
-//             let client = self.get_client();
-//             if let Some((notebook, entries)) = client
-//                 .notebook_by_title(&ident, &title)
-//                 .await
-//                 .map_err(|e| dioxus::CapturedError::from_display(e))?
-//             {
-//                 let stored = Arc::new((notebook, entries));
-//                 cache_impl::insert(&self.book_cache, (ident, title), stored.clone());
-//                 Ok(Some(stored))
-//             } else {
-//                 Ok(None)
-//             }
-//         }
-//     }
-
-//     pub async fn get_entry(
-//         &self,
-//         ident: AtIdentifier<'static>,
-//         book_title: SmolStr,
-//         entry_title: SmolStr,
-//     ) -> Result<Option<Arc<(BookEntryView<'static>, Entry<'static>)>>> {
-//         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
-//             let (notebook, entries) = result.as_ref();
-//             if let Some(entry) =
-//                 cache_impl::get(&self.entry_cache, &(ident.clone(), entry_title.clone()))
-//             {
-//                 Ok(Some(entry))
-//             } else {
-//                 let client = self.get_client();
-//                 if let Some(entry) = client
-//                     .entry_by_title(notebook, entries.as_ref(), &entry_title)
-//                     .await
-//                     .map_err(|e| dioxus::CapturedError::from_display(e))?
-//                 {
-//                     let stored = Arc::new(entry);
-//                     cache_impl::insert(&self.entry_cache, (ident, entry_title), stored.clone());
-//                     Ok(Some(stored))
-//                 } else {
-//                     Ok(None)
-//                 }
-//             }
-//         } else {
-//             Ok(None)
-//         }
-//     }
-
-//     pub async fn fetch_notebooks_from_ufos(
-//         &self,
-//     ) -> Result<Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
-//         use jacquard::{IntoStatic, types::aturi::AtUri};
-
-//         let url = "https://ufos-api.microcosm.blue/records?collection=sh.weaver.notebook.book";
-//         let response = reqwest::get(url)
-//             .await
-//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
-
-//         let records: Vec<UfosRecord> = response
-//             .json()
-//             .await
-//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
-
-//         let mut notebooks = Vec::new();
-//         let client = self.get_client();
-
-//         for ufos_record in records {
-//             // Construct URI
-//             let uri_str = format!(
-//                 "at://{}/{}/{}",
-//                 ufos_record.did, ufos_record.collection, ufos_record.rkey
-//             );
-//             let uri = AtUri::new_owned(uri_str)
-//                 .map_err(|e| dioxus::CapturedError::from_display(format!("Invalid URI: {}", e)))?;
-
-//             // Fetch the full notebook view (which hydrates authors)
-//             match client.view_notebook(&uri).await {
-//                 Ok((notebook, entries)) => {
-//                     let ident = uri.authority().clone().into_static();
-//                     let title = notebook
-//                         .title
-//                         .as_ref()
-//                         .map(|t| SmolStr::new(t.as_ref()))
-//                         .unwrap_or_else(|| SmolStr::new("Untitled"));
-
-//                     let result = Arc::new((notebook, entries));
-//                     // Cache it
-//                     cache_impl::insert(&self.book_cache, (ident, title), result.clone());
-//                     notebooks.push(result);
-//                 }
-//                 Err(_) => continue, // Skip notebooks that fail to load
-//             }
-//         }
-
-//         Ok(notebooks)
-//     }
-
-//     pub async fn fetch_notebooks_for_did(
-//         &self,
-//         ident: &AtIdentifier<'_>,
-//     ) -> Result<Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
-//         use jacquard::{
-//             IntoStatic,
-//             types::{collection::Collection, nsid::Nsid},
-//             xrpc::XrpcExt,
-//         };
-//         use weaver_api::{
-//             com_atproto::repo::list_records::ListRecords, sh_weaver::notebook::book::Book,
-//         };
-
-//         let client = self.get_client();
-
-//         // Resolve DID and PDS
-//         let (repo_did, pds_url) = match ident {
-//             AtIdentifier::Did(did) => {
-//                 let pds = client
-//                     .pds_for_did(did)
-//                     .await
-//                     .map_err(|e| dioxus::CapturedError::from_display(e))?;
-//                 (did.clone(), pds)
-//             }
-//             AtIdentifier::Handle(handle) => client
-//                 .pds_for_handle(handle)
-//                 .await
-//                 .map_err(|e| dioxus::CapturedError::from_display(e))?,
-//         };
-
-//         // Fetch all notebook records for this repo
-//         let resp = client
-//             .xrpc(pds_url)
-//             .send(
-//                 &ListRecords::new()
-//                     .repo(repo_did)
-//                     .collection(Nsid::raw(Book::NSID))
-//                     .limit(100)
-//                     .build(),
-//             )
-//             .await
-//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
-
-//         let mut notebooks = Vec::new();
-
-//         if let Ok(list) = resp.parse() {
-//             for record in list.records {
-//                 // View the notebook (which hydrates authors)
-//                 match client.view_notebook(&record.uri).await {
-//                     Ok((notebook, entries)) => {
-//                         let ident = record.uri.authority().clone().into_static();
-//                         let title = notebook
-//                             .title
-//                             .as_ref()
-//                             .map(|t| SmolStr::new(t.as_ref()))
-//                             .unwrap_or_else(|| SmolStr::new("Untitled"));
-
-//                         let result = Arc::new((notebook, entries));
-//                         // Cache it
-//                         cache_impl::insert(&self.book_cache, (ident, title), result.clone());
-//                         notebooks.push(result);
-//                     }
-//                     Err(_) => continue, // Skip notebooks that fail to load
-//                 }
-//             }
-//         }
-
-//         Ok(notebooks)
-//     }
-
-//     pub async fn list_notebook_entries(
-//         &self,
-//         ident: AtIdentifier<'static>,
-//         book_title: SmolStr,
-//     ) -> Result<Option<Vec<BookEntryView<'static>>>> {
-//         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
-//             let (notebook, entries) = result.as_ref();
-//             let mut book_entries = Vec::new();
-//             let client = self.get_client();
-
-//             for index in 0..entries.len() {
-//                 match client.view_entry(notebook, entries, index).await {
-//                     Ok(book_entry) => book_entries.push(book_entry),
-//                     Err(_) => continue, // Skip entries that fail to load
-//                 }
-//             }
-
-//             Ok(Some(book_entries))
-//         } else {
-//             Ok(None)
-//         }
-//     }
-
-//     pub async fn fetch_profile(
-//         &self,
-//         ident: &AtIdentifier<'_>,
-//     ) -> Result<Arc<ProfileDataView<'static>>> {
-//         use jacquard::IntoStatic;
-
-//         let ident_static = ident.clone().into_static();
-
-//         if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
-//             return Ok(cached);
-//         }
-
-//         let client = self.get_client();
-
-//         let did = match ident {
-//             AtIdentifier::Did(d) => d.clone(),
-//             AtIdentifier::Handle(h) => client
-//                 .resolve_handle(h)
-//                 .await
-//                 .map_err(|e| dioxus::CapturedError::from_display(e))?,
-//         };
-
-//         let (_uri, profile_view) = client
-//             .hydrate_profile_view(&did)
-//             .await
-//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
-
-//         let result = Arc::new(profile_view);
-//         cache_impl::insert(&self.profile_cache, ident_static, result.clone());
-
-//         Ok(result)
-//     }
-// }
 
 impl HttpClient for Fetcher {
     type Error = IdentityError;

crates/weaver-app/src/main.rs

···
 #[cfg(feature = "server")]
 mod blobcache;
 mod cache_impl;
-#[cfg(feature = "server")]
-mod og;
 /// Define a components module that contains all shared components for our app.
 mod components;
 mod config;
 mod data;
 mod env;
 mod fetch;
+#[cfg(feature = "server")]
+mod og;
 mod record_utils;
 mod service_worker;
 /// Define a views module that contains the UI for all Layouts and Routes for our app.
···
                         }
                     }
                 }))
+            // .layer(axum::middleware::from_fn(
+            //     |request: Request, next: Next| async move {
+            //         let mut res = next.run(request).await;
+
+            //         // Cache all HTML responses
+            //         if res
+            //             .headers()
+            //             .get("content-type")
+            //             .and_then(|v| v.to_str().ok())
+            //             .map(|t| t.contains("text/html"))
+            //             .unwrap_or(false)
+            //         {
+            //             res.headers_mut().insert(
+            //                 http::header::CACHE_CONTROL,
+            //                 "public, max-age=300".parse().unwrap(),
+            //             );
+            //         }
+            //         res
+            //     },
+            // ))
         };
         Ok(router)
     });
···
     entry_title: SmolStr,
 ) -> Result<axum::response::Response> {
     use axum::{
-        http::{header::{CACHE_CONTROL, CONTENT_TYPE}, StatusCode},
+        http::{
+            StatusCode,
+            header::{CACHE_CONTROL, CONTENT_TYPE},
+        },
         response::IntoResponse,
     };
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
···
     };
 
     // Fetch entry data
-    let entry_result = fetcher.get_entry(at_ident.clone(), book_title.clone(), entry_title.into()).await;
+    let entry_result = fetcher
+        .get_entry(at_ident.clone(), book_title.clone(), entry_title.into())
+        .await;
 
     let arc_data = match entry_result {
         Ok(Some(data)) => data,
···
                 (CACHE_CONTROL, "public, max-age=3600"),
             ],
             cached,
-        ).into_response());
+        )
+            .into_response());
     }
 
     // Extract metadata
···
     // TODO: Could fetch actual notebook record to get display title
     let notebook_title_str: String = book_title.to_string();
 
-    let author_handle = book_entry.entry.authors.first()
+    let author_handle = book_entry
+        .entry
+        .authors
+        .first()
         .map(|a| match &a.record.inner {
             ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
             ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
···
                 // Build CDN URL
                 let cdn_url = format!(
                     "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@{}",
-                    did.as_str(), cid.as_ref(), format
+                    did.as_str(),
+                    cid.as_ref(),
+                    format
                 );
 
                 // Fetch the image
···
                         match response.bytes().await {
                             Ok(bytes) => {
                                 use base64::Engine;
-                                let base64_str = base64::engine::general_purpose::STANDARD.encode(&bytes);
+                                let base64_str =
+                                    base64::engine::general_purpose::STANDARD.encode(&bytes);
                                 Some(format!("data:{};base64,{}", mime, base64_str))
                             }
-                            Err(_) => None
+                            Err(_) => None,
                         }
                     }
-                    _ => None
+                    _ => None,
                 }
             } else {
                 None
···
         match og::generate_hero_image(hero_data, title, &notebook_title_str, &author_handle) {
             Ok(bytes) => bytes,
             Err(e) => {
-                tracing::error!("Failed to generate hero OG image: {:?}, falling back to text", e);
+                tracing::error!(
+                    "Failed to generate hero OG image: {:?}, falling back to text",
+                    e
+                );
                 og::generate_text_only(title, &content_snippet, &notebook_title_str, &author_handle)
                     .map_err(|e| {
                         tracing::error!("Failed to generate text OG image: {:?}", e);
···
             Ok(bytes) => bytes,
             Err(e) => {
                 tracing::error!("Failed to generate OG image: {:?}", e);
-                return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to generate image").into_response());
+                return Ok((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "Failed to generate image",
+                )
+                    .into_response());
             }
         }
     };
···
             (CACHE_CONTROL, "public, max-age=3600"),
         ],
         png_bytes,
-    ).into_response())
+    )
+        .into_response())
 }
 
 // Route: /og/notebook/{ident}/{book_title}.png - OpenGraph image for notebook index
···
     book_title: SmolStr,
 ) -> Result<axum::response::Response> {
     use axum::{
-        http::{header::{CACHE_CONTROL, CONTENT_TYPE}, StatusCode},
+        http::{
+            StatusCode,
+            header::{CACHE_CONTROL, CONTENT_TYPE},
+        },
         response::IntoResponse,
     };
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
···
     };
 
     // Fetch notebook data
-    let notebook_result = fetcher.get_notebook(at_ident.clone(), book_title.into()).await;
+    let notebook_result = fetcher
+        .get_notebook(at_ident.clone(), book_title.into())
+        .await;
 
     let arc_data = match notebook_result {
         Ok(Some(data)) => data,
         Ok(None) => return Ok((StatusCode::NOT_FOUND, "Notebook not found").into_response()),
         Err(e) => {
             tracing::error!("Failed to fetch notebook for OG image: {:?}", e);
-            return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to fetch notebook").into_response());
+            return Ok((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Failed to fetch notebook",
+            )
+                .into_response());
         }
     };
     let (notebook_view, _entries) = arc_data.as_ref();
···
                 (CACHE_CONTROL, "public, max-age=3600"),
             ],
             cached,
-        ).into_response());
+        )
+            .into_response());
     }
 
     // Extract metadata
-    let title = notebook_view.title
+    let title = notebook_view
+        .title
         .as_ref()
         .map(|t| t.as_ref())
         .unwrap_or("Untitled Notebook");
 
-    let author_handle = notebook_view.authors.first()
+    let author_handle = notebook_view
+        .authors
+        .first()
         .map(|a| match &a.record.inner {
             ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
             ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
···
         .unwrap_or_else(|| "unknown".to_string());
 
     // Fetch entries to get entry titles and count
-    let entries_result = fetcher.list_notebook_entries(at_ident.clone(), book_title.into()).await;
+    let entries_result = fetcher
+        .list_notebook_entries(at_ident.clone(), book_title.into())
+        .await;
     let (entry_count, entry_titles) = match entries_result {
         Ok(Some(entries)) => {
             let count = entries.len();
···
                 .iter()
                 .take(4)
                 .map(|e| {
-                    e.entry.title
+                    e.entry
+                        .title
                         .as_ref()
                         .map(|t| t.as_ref().to_string())
                         .unwrap_or_else(|| "Untitled".to_string())
···
     };
 
     // Generate image
-    let png_bytes = match og::generate_notebook_og(title, &author_handle, entry_count, entry_titles) {
+    let png_bytes = match og::generate_notebook_og(title, &author_handle, entry_count, entry_titles)
+    {
         Ok(bytes) => bytes,
         Err(e) => {
             tracing::error!("Failed to generate notebook OG image: {:?}", e);
-            return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to generate image").into_response());
+            return Ok((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Failed to generate image",
+            )
+                .into_response());
         }
     };
 
···
             (CACHE_CONTROL, "public, max-age=3600"),
         ],
         png_bytes,
-    ).into_response())
+    )
+        .into_response())
 }
 
 // Route: /og/profile/{ident}.png - OpenGraph image for profile/repository
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
 #[get("/og/profile/{ident}", fetcher: Extension<Arc<fetch::Fetcher>>)]
-pub async fn og_profile_image(
-    ident: SmolStr,
-) -> Result<axum::response::Response> {
+pub async fn og_profile_image(ident: SmolStr) -> Result<axum::response::Response> {
     use axum::{
-        http::{header::{CACHE_CONTROL, CONTENT_TYPE}, StatusCode},
+        http::{
+            StatusCode,
+            header::{CACHE_CONTROL, CONTENT_TYPE},
+        },
         response::IntoResponse,
     };
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
···
         Ok(data) => data,
         Err(e) => {
             tracing::error!("Failed to fetch profile for OG image: {:?}", e);
-            return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to fetch profile").into_response());
+            return Ok(
+                (StatusCode::INTERNAL_SERVER_ERROR, "Failed to fetch profile").into_response(),
+            );
         }
     };
 
···
     // Use DID as cache key since profiles don't have a CID field
     let (display_name, handle, bio, avatar_url, banner_url, cache_id) = match &profile_view.inner {
         ProfileDataViewInner::ProfileView(p) => (
-            p.display_name.as_ref().map(|n| n.as_ref().to_string()).unwrap_or_default(),
+            p.display_name
+                .as_ref()
+                .map(|n| n.as_ref().to_string())
+                .unwrap_or_default(),
             p.handle.as_ref().to_string(),
-            p.description.as_ref().map(|d| d.as_ref().to_string()).unwrap_or_default(),
+            p.description
+                .as_ref()
+                .map(|d| d.as_ref().to_string())
+                .unwrap_or_default(),
             p.avatar.as_ref().map(|u| u.as_ref().to_string()),
             None::<String>,
             p.did.as_ref().to_string(),
         ),
         ProfileDataViewInner::ProfileViewDetailed(p) => (
-            p.display_name.as_ref().map(|n| n.as_ref().to_string()).unwrap_or_default(),
+            p.display_name
+                .as_ref()
+                .map(|n| n.as_ref().to_string())
+                .unwrap_or_default(),
             p.handle.as_ref().to_string(),
-            p.description.as_ref().map(|d| d.as_ref().to_string()).unwrap_or_default(),
+            p.description
+                .as_ref()
+                .map(|d| d.as_ref().to_string())
+                .unwrap_or_default(),
             p.avatar.as_ref().map(|u| u.as_ref().to_string()),
             p.banner.as_ref().map(|u| u.as_ref().to_string()),
             p.did.as_ref().to_string(),
···
                 (CACHE_CONTROL, "public, max-age=3600"),
             ],
             cached,
-        ).into_response());
+        )
+            .into_response());
     }
 
     // Fetch notebook count
···
             ) {
                 Ok(bytes) => bytes,
                 Err(e) => {
-                    tracing::error!("Failed to generate profile banner OG image: {:?}, falling back", e);
-                    og::generate_profile_og(&display_name, &handle, &bio, avatar_data, notebook_count)
-                        .unwrap_or_default()
+                    tracing::error!(
+                        "Failed to generate profile banner OG image: {:?}, falling back",
+                        e
+                    );
+                    og::generate_profile_og(
+                        &display_name,
+                        &handle,
+                        &bio,
+                        avatar_data,
+                        notebook_count,
+                    )
+                    .unwrap_or_default()
                 }
             }
         } else {
···
             Ok(bytes) => bytes,
             Err(e) => {
                 tracing::error!("Failed to generate profile OG image: {:?}", e);
-                return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to generate image").into_response());
+                return Ok((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "Failed to generate image",
+                )
+                    .into_response());
             }
         }
     };
···
             (CACHE_CONTROL, "public, max-age=3600"),
         ],
         png_bytes,
-    ).into_response())
+    )
+        .into_response())
 }
 
 // Route: /og/site.png - OpenGraph image for homepage
···
 #[get("/og/site.png")]
 pub async fn og_site_image() -> Result<axum::response::Response> {
     use axum::{
-        http::{header::{CACHE_CONTROL, CONTENT_TYPE}, StatusCode},
+        http::{
+            StatusCode,
+            header::{CACHE_CONTROL, CONTENT_TYPE},
+        },
         response::IntoResponse,
     };
 
     // Site OG is static, cache aggressively
     static SITE_OG_CACHE: std::sync::OnceLock<Vec<u8>> = std::sync::OnceLock::new();
 
-    let png_bytes = SITE_OG_CACHE.get_or_init(|| {
-        og::generate_site_og().unwrap_or_default()
-    });
+    let png_bytes = SITE_OG_CACHE.get_or_init(|| og::generate_site_og().unwrap_or_default());
 
     if png_bytes.is_empty() {
-        return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to generate image").into_response());
+        return Ok((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to generate image",
+        )
+            .into_response());
     }
 
     Ok((
···
             (CACHE_CONTROL, "public, max-age=86400"),
         ],
         png_bytes.clone(),
-    ).into_response())
+    )
+        .into_response())
 }
 
 // #[server(endpoint = "static_routes", output = server_fn::codec::Json)]