and now everything works well

Cargo.toml

···
 
 [profile]
 
+[profile.wasm-release]
+inherits = "release"
+opt-level = "z"
+debug = false
+lto = true
+codegen-units = 1
+panic = "abort"
+incremental = false
+strip = "debuginfo"
+
+
 [profile.wasm-dev]
 inherits = "dev"
 debug = true
···
 [profile.server-dev]
 inherits = "dev"
 debug = true
+
+
+[profile.server-release]
+inherits = "release"
+opt-level = 2
 
 [profile.android-dev]
 inherits = "dev"

crates/weaver-app/.env-example

···
+WEAVER_APP_ENV="dev"
+WEAVER_APP_HOST="http://localhost"
+WEAVER_APP_DOMAIN=""
+WEAVER_PORT=8080
+WEAVER_APP_SCOPES="atproto transition:generic"
+WEAVER_CLIENT_NAME="Weaver"
+
+WEAVER_LOGO_URI=""
+WEAVER_TOS_URI=""
+WEAVER_PRIVACY_POLICY_URI=""

crates/weaver-app/.env-prod

···
-WEAVER_APP_ENV="prod"
-WEAVER_APP_HOST="https://alpha.weaver.sh"
-WEAVER_APP_DOMAIN="https://alpha.weaver.sh"
-WEAVER_PORT=8080
-WEAVER_APP_SCOPES="atproto transition:generic"
-WEAVER_CLIENT_NAME="Weaver"
-
-WEAVER_LOGO_URI=""
-WEAVER_TOS_URI=""
-WEAVER_PRIVACY_POLICY_URI=""

crates/weaver-app/Cargo.toml

···
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 webbrowser = "1.0.6"
-reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
+reqwest = { version = "0.12", default-features = false, features = ["json"] }
 
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
 reqwest = { version = "0.12", default-features = false, features = ["json"] }

crates/weaver-app/src/blobcache.rs

···
             }
             AtIdentifier::Handle(handle) => self.client.pds_for_handle(&handle).await?,
         };
+        if self.get_cid(&cid).is_some() {
+            return Ok(());
+        }
         let blob = if let Ok(blob_stream) = self
             .client
             .xrpc(pds_url)

crates/weaver-app/src/components/entry.rs

···
     match &*entry.read() {
         Some((book_entry_view, entry_record)) => {
             if let Some(embeds) = &entry_record.embeds {
-                if let Some(images) = &embeds.images {
+                if let Some(_images) = &embeds.images {
                     // Register blob mappings with service worker (client-side only)
                     #[cfg(all(
                         target_family = "wasm",
···
                             let _ = crate::service_worker::register_entry_blobs(
                                 &ident(),
                                 book_title().as_str(),
-                                &images,
+                                &_images,
                                 &fetcher,
                             )
                             .await;
···
         .as_ref()
         .map(|t| t.as_ref())
         .unwrap_or("Untitled");
+
+    tracing::info!("Entry: {book_title} - {title}");
 
     rsx! {
         // Set page title

crates/weaver-app/src/data.rs

···
     Memo<Option<ProfileDataView<'static>>>,
 ) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_server_future(use_reactive!(|ident| {
+    let res = use_resource(use_reactive!(|ident| {
         let fetcher = fetcher.clone();
         async move {
-            tracing::debug!("use_profile_data server future STARTED for {:?}", ident);
-            let result = fetcher
+            fetcher
                 .fetch_profile(&ident())
                 .await
                 .ok()
                 .map(|arc| serde_json::to_value(&*arc).ok())
-                .flatten();
-            tracing::debug!("use_profile_data server future COMPLETED for {:?}", ident);
-            result
+                .flatten()
         }
     }));
     let memo = use_memo(use_reactive!(|res| {
-        let res = res.as_ref().ok()?;
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<ProfileDataView>(value.clone()).ok()
         } else {
             None
         }
     }));
-    (res, memo)
+    (Ok(res), memo)
 }
 
 /// Fetches profile data client-side only (no SSR)

crates/weaver-app/src/env.rs

···
 // This file is automatically generated by build.rs
 
 #[allow(unused)]
-pub const WEAVER_APP_ENV: &'static str = "dev";
+pub const WEAVER_APP_ENV: &'static str = "prod";
 #[allow(unused)]
-pub const WEAVER_APP_HOST: &'static str = "http://localhost";
+pub const WEAVER_APP_HOST: &'static str = "https://alpha.weaver.sh";
 #[allow(unused)]
-pub const WEAVER_APP_DOMAIN: &'static str = "";
+pub const WEAVER_APP_DOMAIN: &'static str = "https://alpha.weaver.sh";
 #[allow(unused)]
 pub const WEAVER_PORT: &'static str = "8080";
 #[allow(unused)]
···
 #[allow(unused)]
 pub const WEAVER_CLIENT_NAME: &'static str = "Weaver";
 #[allow(unused)]
-pub const WEAVER_LOGO_URI: &'static str = "";
+pub const WEAVER_LOGO_URI: &'static str = "https://alpha.weaver.sh/favicon.ico";
 #[allow(unused)]
 pub const WEAVER_TOS_URI: &'static str = "";
 #[allow(unused)]

crates/weaver-app/src/fetch.rs

···
 use jacquard::CowStr;
 use jacquard::IntoStatic;
 use jacquard::client::Agent;
+use jacquard::client::AgentError;
 use jacquard::client::AgentKind;
 use jacquard::error::ClientError;
 use jacquard::error::XrpcResult;
···
 use std::future::Future;
 use std::{sync::Arc, time::Duration};
 use tokio::sync::RwLock;
+use weaver_api::app_bsky::actor::get_profile::GetProfile;
+use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 use weaver_api::{
     com_atproto::repo::strong_ref::StrongRef,
     sh_weaver::{
···
         notebook::{BookEntryView, NotebookView, entry::Entry},
     },
 };
+use weaver_common::WeaverError;
 use weaver_common::WeaverExt;
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
···
     }
 }
 
-#[cfg(not(feature = "server"))]
+//#[cfg(not(feature = "server"))]
 #[derive(Clone)]
 pub struct Fetcher {
     pub client: Arc<Client>,
 }
 
-#[cfg(not(feature = "server"))]
+//#[cfg(not(feature = "server"))]
 impl Fetcher {
     pub fn new(client: OAuthClient<JacquardResolver, AuthStore>) -> Self {
         Self {
···
                 // 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));
                         notebooks.push(result);
                     }
···
                 }
             }
         }
-
         Ok(notebooks)
     }
 
···
             .await
             .map_err(|e| dioxus::CapturedError::from_display(e))?;
 
-        let result = Arc::new(profile_view);
-
-        Ok(result)
+        Ok(Arc::new(profile_view))
     }
 }
 
-#[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>>>,
-}
+// #[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 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 {}
+// // /// 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)),
-        }
-    }
+// #[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 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();
-        }
-    }
+//     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
-        }
-    }
+//     #[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 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_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 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};
+//     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 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 records: Vec<UfosRecord> = response
+//             .json()
+//             .await
+//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
 
-        let mut notebooks = Vec::new();
-        let client = self.get_client();
+//         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)))?;
+//         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"));
+//             // 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
-            }
-        }
+//                     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)
-    }
+//         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,
-        };
+//     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();
+//         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))?,
-        };
+//         // 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))?;
+//         // 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();
+//         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"));
+//         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
-                }
-            }
-        }
+//                         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)
-    }
+//         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();
+//     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
-                }
-            }
+//             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)
-        }
-    }
+//             Ok(Some(book_entries))
+//         } else {
+//             Ok(None)
+//         }
+//     }
 
-    pub async fn fetch_profile(
-        &self,
-        ident: &AtIdentifier<'_>,
-    ) -> Result<Arc<ProfileDataView<'static>>> {
-        use jacquard::IntoStatic;
+//     pub async fn fetch_profile(
+//         &self,
+//         ident: &AtIdentifier<'_>,
+//     ) -> Result<Arc<ProfileDataView<'static>>> {
+//         use jacquard::IntoStatic;
 
-        let ident_static = ident.clone().into_static();
+//         let ident_static = ident.clone().into_static();
 
-        if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
-            return Ok(cached);
-        }
+//         if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
+//             return Ok(cached);
+//         }
 
-        let client = self.get_client();
+//         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 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 (_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());
+//         let result = Arc::new(profile_view);
+//         cache_impl::insert(&self.profile_cache, ident_static, result.clone());
 
-        Ok(result)
-    }
-}
+//         Ok(result)
+//     }
+// }
 
 impl HttpClient for Fetcher {
     #[doc = " Error type returned by the HTTP client"]

crates/weaver-app/src/main.rs

···
     #[cfg(target_arch = "wasm32")]
     console_error_panic_hook::set_once();
 
+    #[cfg(feature = "server")]
+    std::panic::set_hook(Box::new(|panic_info| {
+        tracing::error!("PANIC: {:?}", panic_info);
+    }));
+
     // Run `serve()` on the server only
     #[cfg(feature = "server")]
     dioxus::serve(|| async move {
···
                 UnauthenticatedSession::new_public(),
             )));
             axum::Router::new()
+                .route("/favicon.ico", get(favicon))
                 // Server side render the application, serve static assets, and register server functions
                 .serve_dioxus_application(
                     ServeConfig::builder(), // Enable incremental rendering
···
             Outlet::<Route> {}
         }
     }
+}
+
+#[cfg(all(feature = "fullstack-server", feature = "server"))]
+pub async fn favicon() -> axum::response::Response {
+    use axum::{http::header::CONTENT_TYPE, response::IntoResponse};
+    let bytes = include_bytes!("../assets/weaver_photo_sm.jpg");
+    ([(CONTENT_TYPE, "image/jpg")], bytes).into_response()
 }
 
 #[cfg(all(feature = "fullstack-server", feature = "server"))]

crates/weaver-common/src/agent.rs

···
+use weaver_api::app_bsky::actor::get_profile::GetProfile;
 // Re-export view types for use elsewhere
 pub use weaver_api::sh_weaver::notebook::{
     AuthorListView, BookEntryRef, BookEntryView, EntryView, NotebookView,
···
 /// - `agent.upload_blob()` - Upload a single blob
 ///
 /// This trait is for multi-step workflows that coordinate between multiple operations.
-//#[trait_variant::make(Send)]
-pub trait WeaverExt: AgentSessionExt + XrpcExt {
-    /// Publish a notebook directory to the user's PDS
-    ///
-    /// Multi-step workflow:
-    /// 1. Parse markdown files in directory
-    /// 2. Extract and upload images/assets → BlobRefs
-    /// 3. Transform markdown refs to point at uploaded blobs
-    /// 4. Create entry records for each file
-    /// 5. Create book record with entry refs
-    ///
-    /// Returns the AT-URI of the published book
-    fn publish_notebook(
-        &self,
-        path: &Path,
-    ) -> impl Future<Output = Result<PublishResult<'_>, WeaverError>> {
-        async { todo!() }
-    }
-
+//#[cfg_attr(not(target_arch = "wasm32"), trait_variant::make(Send))]
+pub trait WeaverExt: AgentSessionExt + XrpcExt + Send + Sync {
     /// Publish a blob to the user's PDS
     ///
     /// Multi-step workflow:
···
     ///
     /// Returns the AT-URI of the published blob
     fn publish_blob<'a>(
-        &self,
+        &'a self,
         blob: Bytes,
         url_path: &'a str,
         prev: Option<Tid>,
-    ) -> impl Future<Output = Result<(StrongRef<'a>, PublishedBlob<'a>), WeaverError>> {
+    ) -> impl Future<Output = Result<(StrongRef<'a>, PublishedBlob<'a>), WeaverError>> + 'a {
         async move {
             let mime_type =
                 MimeType::new_owned(blob.sniff_mime_type().unwrap_or("application/octet-stream"));
 
-            let blob = self.upload_blob(blob, mime_type).await?;
+            let blob = self.upload_blob(blob, mime_type.into_static()).await?;
             let publish_record = PublishedBlob::new()
                 .path(url_path)
                 .upload(BlobRef::Blob(blob))
···
         }
     }
 
-    fn confirm_record_ref(
-        &self,
-        uri: &AtUri<'_>,
-    ) -> impl Future<Output = Result<StrongRef<'_>, WeaverError>> {
+    fn confirm_record_ref<'a>(
+        &'a self,
+        uri: &'a AtUri<'a>,
+    ) -> impl Future<Output = Result<StrongRef<'static>, WeaverError>> + 'a {
         async move {
             let rkey = uri.rkey().ok_or_else(|| {
                 AgentError::from(
···
             let tags = notebook.value.tags.clone();
 
             let mut authors = Vec::new();
+            use weaver_api::app_bsky::actor::{
+                ProfileViewDetailed, get_profile::GetProfile, profile::Profile as BskyProfile,
+            };
+            use weaver_api::sh_weaver::actor::{
+                ProfileDataView, ProfileDataViewInner, ProfileView,
+                profile::Profile as WeaverProfile,
+            };
 
             for (index, author) in notebook.value.authors.iter().enumerate() {
                 let (profile_uri, profile_view) = self.hydrate_profile_view(&author.did).await?;
···
                         let tags = notebook.tags.clone();
 
                         let mut authors = Vec::new();
+                        use weaver_api::app_bsky::actor::{
+                            ProfileViewDetailed, get_profile::GetProfile,
+                            profile::Profile as BskyProfile,
+                        };
+                        use weaver_api::sh_weaver::actor::{
+                            ProfileDataView, ProfileDataViewInner, ProfileView,
+                            profile::Profile as WeaverProfile,
+                        };
 
                         for (index, author) in notebook.authors.iter().enumerate() {
                             let (profile_uri, profile_view) =
···
                     .send(GetProfile::new().actor(did.clone()).build())
                     .await
                 {
-                    if let Ok(output) = bsky_resp.parse() {
+                    if let Ok(output) = bsky_resp.into_output() {
                         let bsky_uri =
                             BskyProfile::uri(format!("at://{}/app.bsky.actor.profile/self", did))
                                 .map_err(|_| {
···
                             Some(bsky_uri.as_uri().clone().into_static()),
                             ProfileDataView::new()
                                 .inner(ProfileDataViewInner::ProfileViewDetailed(Box::new(
-                                    output.value.into_static(),
+                                    output.value,
                                 )))
                                 .build()
                                 .into_static(),