ssr mode works properly now

crates/weaver-app/src/blobcache.rs

···
             }
             AtIdentifier::Handle(handle) => self.client.pds_for_handle(&handle).await?,
         };
-        // let blob = if let Ok(blob_stream) = self
-        //     .client
-        //     .xrpc(pds_url)
-        //     .send(
-        //         &GetBlob::new()
-        //             .cid(cid.clone())
-        //             .did(repo_did.clone())
-        //             .build(),
-        //     )
-        //     .await
-        // {
-        //     blob_stream.buffer().clone()
-        // } else {
-        //     reqwest::get(format!(
-        //         "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@jpeg",
-        //         repo_did, cid
-        //     ))
-        //     .await?
-        //     .bytes()
-        //     .await?
-        //     .clone()
-        // };
-        //
-        let blob = reqwest::get(format!(
-            "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@jpeg",
-            repo_did, cid
-        ))
-        .await?
-        .bytes()
-        .await?
-        .clone();
+        let blob = if let Ok(blob_stream) = self
+            .client
+            .xrpc(pds_url)
+            .send(
+                &GetBlob::new()
+                    .cid(cid.clone())
+                    .did(repo_did.clone())
+                    .build(),
+            )
+            .await
+        {
+            blob_stream.buffer().clone()
+        } else {
+            reqwest::get(format!(
+                "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@jpeg",
+                repo_did, cid
+            ))
+            .await?
+            .bytes()
+            .await?
+            .clone()
+        };
 
         self.cache.insert(cid.clone(), blob);
         if let Some(name) = name {

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

···
 use std::sync::Arc;
 use weaver_api::sh_weaver::notebook::{BookEntryView, EntryView, entry};
 
+// #[component]
+// pub fn EntryPage(
+//     ident: ReadSignal<AtIdentifier<'static>>,
+//     book_title: ReadSignal<SmolStr>,
+//     title: ReadSignal<SmolStr>,
+// ) -> Element {
+//     rsx! {
+//         {std::iter::once(rsx! {Entry {ident, book_title, title}})}
+//     }
+// }
+
 #[component]
 pub fn EntryPage(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
 ) -> Element {
-    tracing::debug!(
-        "EntryPage component rendering for ident: {:?}, book: {}, title: {}",
-        ident(),
-        book_title(),
-        title()
-    );
-    rsx! {
-        {std::iter::once(rsx! {Entry {ident, book_title, title}})}
-    }
-}
+    // Use feature-gated hook for SSR support
+    let (entry_res, entry) = crate::data::use_entry_data(ident, book_title, title);
+    let route = use_route::<Route>();
+    let mut last_route = use_signal(|| route.clone());
 
-#[component]
-pub fn Entry(
-    ident: ReadSignal<AtIdentifier<'static>>,
-    book_title: ReadSignal<SmolStr>,
-    title: ReadSignal<SmolStr>,
-) -> Element {
-    tracing::debug!(
-        "Entry component rendering for ident: {:?}, book: {}, title: {}",
-        ident(),
-        book_title(),
-        title()
-    );
-    // Use feature-gated hook for SSR support
-    let entry = crate::data::use_entry_data(ident, book_title, title);
+    #[cfg(all(
+        target_family = "wasm",
+        target_os = "unknown",
+        not(feature = "fullstack-server")
+    ))]
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    tracing::debug!("Entry component got entry data");
+
+    // Suspend SSR until entry loads
+    #[cfg(feature = "fullstack-server")]
+    let mut entry_res = entry_res?;
+
+    #[cfg(feature = "fullstack-server")]
+    use_effect(use_reactive!(|route| {
+        if route != last_route() {
+            entry_res.restart();
+            last_route.set(route.clone());
+        }
+    }));
 
     // Handle blob caching when entry data is available
     match &*entry.read() {

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

···
         ident()
     );
     use crate::components::ProfileDisplay;
-    let notebooks = data::use_notebooks_for_did(ident);
-    let profile = crate::data::use_profile_data(ident);
+    let (notebooks_result, notebooks) = data::use_notebooks_for_did(ident);
+    let (profile_result, profile) = crate::data::use_profile_data(ident);
     tracing::debug!("RepositoryIndex got profile and notebooks");
+
+    #[cfg(feature = "fullstack-server")]
+    notebooks_result?;
+
+    #[cfg(feature = "fullstack-server")]
+    profile_result?;
+
     rsx! {
         document::Stylesheet { href: NOTEBOOK_CARD_CSS }
 

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

···
 
 mod entry;
 #[allow(unused_imports)]
-pub use entry::{Entry, EntryCard, EntryMarkdown, EntryPage};
+pub use entry::{EntryCard, EntryMarkdown, EntryPage};
 
 pub mod identity;
 #[allow(unused_imports)]

crates/weaver-app/src/data.rs

···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
-) -> Memo<Option<(BookEntryView<'static>, Entry<'static>)>> {
+) -> (
+    Result<Resource<Option<(serde_json::Value, serde_json::Value)>>, RenderError>,
+    Memo<Option<(BookEntryView<'static>, Entry<'static>)>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|(ident, book_title, title)| {
         let fetcher = fetcher.clone();
         async move {
             if let Some(entry) = fetcher
···
                 let (_book_entry_view, entry_record) = (&entry.0, &entry.1);
                 if let Some(embeds) = &entry_record.embeds {
                     if let Some(images) = &embeds.images {
-                        let ident_val = ident();
+                        let ident_val = ident.clone();
                         let images = images.clone();
                         for image in &images.images {
                             use jacquard::smol_str::ToSmolStr;
···
                 None
             }
         }
-    });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    }));
+    let memo = use_memo(use_reactive!(|res| {
+        let res = res.as_ref().ok()?;
         if let Some(Some((ev, e))) = &*res.read() {
             use jacquard::from_json_value;
 
···
         } else {
             None
         }
-    }))
+    }));
+    (res, memo)
 }
 /// Fetches entry data client-side only (no SSR).
 #[cfg(not(feature = "fullstack-server"))]
···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
-) -> Memo<Option<(BookEntryView<'static>, Entry<'static>)>> {
+) -> (
+    Resource<Option<(serde_json::Value, serde_json::Value)>>,
+    Memo<Option<(BookEntryView<'static>, Entry<'static>)>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
     let res = use_resource(move || {
···
             }
         }
     });
-    use_memo(move || {
+    let memo = use_memo(move || {
         if let Some(Some((ev, e))) = &*res.read() {
             use jacquard::from_json_value;
 
···
         } else {
             None
         }
+    });
+    (res, memo)
+}
+
+#[cfg(feature = "fullstack-server")]
+pub fn use_get_handle(did: Did<'static>) -> Memo<AtIdentifier<'static>> {
+    let ident = use_signal(use_reactive!(|did| AtIdentifier::Did(did.clone())));
+    let old_ident = ident.read().clone();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let fetcher = fetcher.clone();
+    let res = use_resource(move || {
+        let client = fetcher.get_client();
+        let old_ident = old_ident.clone();
+        async move {
+            client
+                .resolve_ident_owned(&*ident.read())
+                .await
+                .map(|doc| {
+                    doc.handles()
+                        .first()
+                        .map(|h| AtIdentifier::Handle(h.clone()).into_static())
+                })
+                .ok()
+                .flatten()
+                .unwrap_or(old_ident)
+        }
+    });
+    use_memo(move || {
+        if let Some(value) = &*res.read() {
+            value.clone()
+        } else {
+            ident.read().clone()
+        }
     })
 }
 
-pub fn use_get_handle(did: Did<'static>) -> AtIdentifier<'static> {
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_get_handle(did: Did<'static>) -> Memo<AtIdentifier<'static>> {
     let ident = use_signal(use_reactive!(|did| AtIdentifier::Did(did.clone())));
-    use_handle(ident.into()).read().clone()
+    let old_ident = ident.read().clone();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let fetcher = fetcher.clone();
+    let res = use_resource(move || {
+        let client = fetcher.get_client();
+        let old_ident = old_ident.clone();
+        async move {
+            client
+                .resolve_ident_owned(&*ident.read())
+                .await
+                .map(|doc| {
+                    doc.handles()
+                        .first()
+                        .map(|h| AtIdentifier::Handle(h.clone()).into_static())
+                })
+                .ok()
+                .flatten()
+                .unwrap_or(old_ident)
+        }
+    });
+    use_memo(move || {
+        if let Some(value) = &*res.read() {
+            value.clone()
+        } else {
+            ident.read().clone()
+        }
+    })
 }
 
 #[cfg(feature = "fullstack-server")]
 pub fn use_load_handle(
     ident: Option<AtIdentifier<'static>>,
-) -> ReadSignal<Option<AtIdentifier<'static>>> {
+) -> (
+    Result<Resource<Option<SmolStr>>, RenderError>,
+    Memo<Option<AtIdentifier<'static>>>,
+) {
     let ident = use_signal(use_reactive!(|ident| ident.clone()));
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|ident| {
         let client = fetcher.get_client();
         async move {
             if let Some(ident) = &*ident.read() {
···
                 None
             }
         }
-    });
+    }));
 
-    use_memo(use_reactive!(|res| {
+    let memo = use_memo(use_reactive!(|res| {
         if let Ok(res) = res {
             if let Some(value) = &*res.read() {
                 if let Some(handle) = value {
···
         } else {
             ident.read().clone()
         }
-    }))
-    .into()
+    }));
+
+    (res, memo)
 }
 
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_load_handle(
     ident: Option<AtIdentifier<'static>>,
-) -> ReadSignal<Option<AtIdentifier<'static>>> {
+) -> (
+    Resource<Option<AtIdentifier<'static>>>,
+    Memo<Option<AtIdentifier<'static>>>,
+) {
     let ident = use_signal(use_reactive!(|ident| ident.clone()));
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
···
         }
     });
 
-    if let Ok(ident) = res.suspend() {
-        ident.into()
-    } else {
-        ident.into()
-    }
+    let memo = use_memo(move || {
+        if let Some(value) = &*res.read() {
+            value.clone()
+        } else {
+            ident.read().clone()
+        }
+    });
+
+    (res, memo)
 }
 #[cfg(not(feature = "fullstack-server"))]
-pub fn use_handle(ident: ReadSignal<AtIdentifier<'static>>) -> ReadSignal<AtIdentifier<'static>> {
+pub fn use_handle(
+    ident: ReadSignal<AtIdentifier<'static>>,
+) -> (Resource<AtIdentifier<'static>>, Memo<AtIdentifier<'static>>) {
     let old_ident = ident.read().clone();
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
···
                 .unwrap_or(old_ident)
         }
     });
-    if let Ok(ident) = res.suspend() {
-        ident.into()
-    } else {
-        ident
-    }
+
+    let memo = use_memo(move || {
+        if let Some(value) = &*res.read() {
+            value.clone()
+        } else {
+            ident.read().clone()
+        }
+    });
+
+    (res, memo)
 }
 #[cfg(feature = "fullstack-server")]
-pub fn use_handle(ident: ReadSignal<AtIdentifier<'static>>) -> ReadSignal<AtIdentifier<'static>> {
+pub fn use_handle(
+    ident: ReadSignal<AtIdentifier<'static>>,
+) -> (
+    Result<Resource<SmolStr>, RenderError>,
+    Memo<AtIdentifier<'static>>,
+) {
     let old_ident = ident.read().clone();
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|ident| {
         let client = fetcher.get_client();
         let old_ident = old_ident.clone();
         async move {
             use jacquard::smol_str::ToSmolStr;
 
             client
-                .resolve_ident_owned(&*ident.read())
+                .resolve_ident_owned(&ident())
                 .await
                 .map(|doc| {
                     use jacquard::smol_str::ToSmolStr;
···
                 .flatten()
                 .unwrap_or(old_ident.to_smolstr())
         }
-    });
+    }));
 
-    use_memo(use_reactive!(|res| {
+    let memo = use_memo(use_reactive!(|res| {
         if let Ok(res) = res {
             if let Some(value) = &*res.read() {
                 AtIdentifier::new_owned(value).unwrap()
···
         } else {
             ident.read().clone()
         }
-    }))
-    .into()
+    }));
+
+    (res, memo)
 }
 
 /// Hook to render markdown with SSR support.
···
     ident: ReadSignal<AtIdentifier<'static>>,
 ) -> Memo<Option<String>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|(content, ident)| {
         let client = fetcher.get_client();
         async move {
-            let did = match ident() {
+            let did = match ident.read().clone() {
                 AtIdentifier::Did(d) => d,
                 AtIdentifier::Handle(h) => client.resolve_handle(&h).await.ok()?,
             };
             Some(render_markdown_impl(content(), did).await)
         }
-    });
+    }));
     use_memo(use_reactive!(|res| {
         let res = res.ok()?;
         if let Some(Some(value)) = &*res.read() {
···
 #[cfg(feature = "fullstack-server")]
 pub fn use_profile_data(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Memo<Option<ProfileDataView<'static>>> {
+) -> (
+    Result<Resource<Option<serde_json::Value>>, RenderError>,
+    Memo<Option<ProfileDataView<'static>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|ident| {
         let fetcher = fetcher.clone();
         async move {
-            tracing::debug!("use_profile_data server future STARTED for {:?}", ident());
+            tracing::debug!("use_profile_data server future STARTED for {:?}", ident);
             let result = 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());
+            tracing::debug!("use_profile_data server future COMPLETED for {:?}", ident);
             result
         }
-    });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    }));
+    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)
 }
 
 /// Fetches profile data client-side only (no SSR)
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_profile_data(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Memo<Option<ProfileDataView<'static>>> {
+) -> (
+    Resource<Option<serde_json::Value>>,
+    Memo<Option<ProfileDataView<'static>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    use_memo(move || {
+    let memo = use_memo(move || {
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<ProfileDataView>(value.clone()).ok()
         } else {
             None
         }
-    })
+    });
+    (res, memo);
 }
 
 /// Fetches notebooks for a specific DID
 #[cfg(feature = "fullstack-server")]
 pub fn use_notebooks_for_did(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+) -> (
+    Result<Resource<Option<Vec<serde_json::Value>>>, RenderError>,
+    Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|ident| {
         let fetcher = fetcher.clone();
         async move {
             fetcher
···
                 })
                 .flatten()
         }
-    });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    }));
+    let memo = use_memo(use_reactive!(|res| {
+        let res = res.as_ref().ok()?;
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    }))
+    }));
+    (res, memo)
 }
 
 /// Fetches notebooks client-side only (no SSR)
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_notebooks_for_did(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+) -> (
+    Resource<Option<Vec<serde_json::Value>>>,
+    Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    use_memo(move || {
+    let memo = use_memo(move || {
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    })
+    });
+    (res, memo)
 }
 
 /// Fetches notebooks from UFOS with SSR support in fullstack mode
 #[cfg(feature = "fullstack-server")]
-pub fn use_notebooks_from_ufos()
--> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+pub fn use_notebooks_from_ufos() -> (
+    Result<Resource<Option<Vec<serde_json::Value>>>, RenderError>,
+    Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    let memo = use_memo(use_reactive!(|res| {
+        let res = res.as_ref().ok()?;
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    }))
+    }));
+    (res, memo)
 }
 
 /// Fetches notebooks from UFOS client-side only (no SSR)
 #[cfg(not(feature = "fullstack-server"))]
-pub fn use_notebooks_from_ufos()
--> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+pub fn use_notebooks_from_ufos() -> (
+    Resource<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+    Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    use_memo(move || {
+    let memo = use_memo(move || {
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    })
+    });
+    (res, memo)
 }
 
 /// Fetches notebook metadata with SSR support in fullstack mode
···
 pub fn use_notebook(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
+) -> (
+    Result<Resource<Option<serde_json::Value>>, RenderError>,
+    Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|(ident, book_title)| {
         let fetcher = fetcher.clone();
         async move {
             fetcher
···
                 .map(|arc| serde_json::to_value(arc.as_ref()).ok())
                 .flatten()
         }
-    });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    }));
+    let memo = use_memo(use_reactive!(|res| {
+        let res = res.as_ref().ok()?;
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
         } else {
             None
         }
-    }))
+    }));
+    (res, memo)
 }
 
 /// Fetches notebook metadata client-side only (no SSR)
···
 pub fn use_notebook(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
+) -> (
+    Resource<Option<serde_json::Value>>,
+    Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    let memo = use_memo(use_reactive!(|res| {
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
         } else {
             None
         }
-    }))
+    }));
+    (res, memo)
 }
 
 /// Fetches notebook entries with SSR support in fullstack mode
···
 pub fn use_notebook_entries(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Memo<Option<Vec<BookEntryView<'static>>>> {
+) -> (
+    Result<Resource<Option<Vec<serde_json::Value>>>, RenderError>,
+    Memo<Option<Vec<BookEntryView<'static>>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_server_future(move || {
+    let res = use_server_future(use_reactive!(|(ident, book_title)| {
         let fetcher = fetcher.clone();
         async move {
             fetcher
···
                 })
                 .flatten()
         }
-    });
-    use_memo(use_reactive!(|res| {
-        let res = res.ok()?;
+    }));
+    let memo = use_memo(use_reactive!(|res| {
+        let res = res.as_ref().ok()?;
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    }))
+    }));
+
+    (res, memo)
 }
 
 /// Fetches notebook entries client-side only (no SSR)
···
 pub fn use_notebook_entries(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Memo<Option<Vec<BookEntryView<'static>>>> {
+) -> (
+    Resource<Option<Vec<BookEntryView<'static>>>>,
+    Memo<Option<Vec<BookEntryView<'static>>>>,
+) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let r = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    use_memo(move || r.read().as_ref().and_then(|v| v.clone()))
+    let memo = use_memo(move || r.read().as_ref().and_then(|v| v.clone()));
+    (r, memo)
 }
 
 #[cfg(feature = "fullstack-server")]

crates/weaver-app/src/fetch.rs

···
     }
 }
 
-//#[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 {
···
     }
 }
 
-// //#[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

···
     ))]
     {
         let fetcher = fetcher.clone();
-        use_future(move || {
+        use_effect(move || {
             let fetcher = fetcher.clone();
-            async move {
-                if let Err(e) = auth::restore_session(fetcher, auth_state).await {
-                    tracing::debug!("Session restoration failed: {}", e);
+            use_future(move || {
+                let fetcher = fetcher.clone();
+                async move {
+                    if let Err(e) = auth::restore_session(fetcher, auth_state).await {
+                        tracing::debug!("Session restoration failed: {}", e);
+                    }
                 }
-            }
+            });
         });
     }
 

crates/weaver-app/src/views/home.rs

···
 #[component]
 pub fn Home() -> Element {
     // Fetch notebooks from UFOS with SSR support
-    let notebooks = data::use_notebooks_from_ufos();
+    let (notebooks_result, notebooks) = data::use_notebooks_from_ufos();
     let navigator = use_navigator();
     let mut uri_input = use_signal(|| String::new());
 
···
             }
         }
     };
+    #[cfg(feature = "fullstack-server")]
+    notebooks_result
+        .as_ref()
+        .ok()
+        .map(|r| r.suspend())
+        .transpose()?;
 
     rsx! {
         document::Link { rel: "stylesheet", href: NOTEBOOK_CARD_CSS }

crates/weaver-app/src/views/navbar.rs

···
 use crate::data::{use_get_handle, use_load_handle};
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
+use jacquard::types::string::Did;
 
 const NAVBAR_CSS: Asset = asset!("/assets/styling/navbar.css");
 
···
     tracing::debug!("Route: {:?}", route);
 
     let mut auth_state = use_context::<Signal<crate::auth::AuthState>>();
-    let route_handle = use_load_handle(match &route {
+    let (route_handle_res, route_handle) = use_load_handle(match &route {
         Route::EntryPage { ident, .. } => Some(ident.clone()),
         Route::RepositoryIndex { ident } => Some(ident.clone()),
         Route::NotebookIndex { ident, .. } => Some(ident.clone()),
         _ => None,
     });
+
+    #[cfg(feature = "fullstack-server")]
+    route_handle_res?;
+
     let fetcher = use_context::<Fetcher>();
     let mut show_login_modal = use_signal(|| false);
 
-    tracing::debug!("Navbar got route_handle: {:?}", route_handle);
+    tracing::debug!("Navbar got route_handle: {:?}", route_handle.read());
 
     rsx! {
         document::Link { rel: "stylesheet", href: NAVBAR_CSS }
···
             }
             if auth_state.read().is_authenticated() {
                 if let Some(did) = &auth_state.read().did {
-                    Button {
-                        variant: ButtonVariant::Ghost,
-                        onclick: move |_| {
-                            let fetcher = fetcher.clone();
-                            auth_state.write().clear();
-                            async move {
-                                fetcher.downgrade_to_unauthenticated().await;
-                            }
-                        },
-                        span { class: "auth-handle", "@{use_get_handle(did.clone())}" }
-                    }
+                    AuthButton { did: did.clone() }
                 }
             } else {
                 div {
···
         Outlet::<Route> {}
     }
 }
+
+#[component]
+fn AuthButton(did: Did<'static>) -> Element {
+    let auth_handle = use_get_handle(did);
+
+    let fetcher = use_context::<Fetcher>();
+    let mut auth_state = use_context::<Signal<AuthState>>();
+
+    rsx! {
+        Button {
+            variant: ButtonVariant::Ghost,
+            onclick: move |_| {
+                let fetcher = fetcher.clone();
+                auth_state.write().clear();
+                async move {
+                    fetcher.downgrade_to_unauthenticated().await;
+                }
+            },
+            span { class: "auth-handle", "@{auth_handle()}" }
+        }
+    }
+}

crates/weaver-app/src/views/notebook.rs

···
     );
     // Fetch full notebook metadata with SSR support
     // IMPORTANT: Call ALL hooks before any ? early returns to maintain hook order
-    let notebook_data = data::use_notebook(ident, book_title);
-    let entries_resource = data::use_notebook_entries(ident, book_title);
+    let (notebook_result, notebook_data) = data::use_notebook(ident, book_title);
+    let (entries_result, entries_resource) = data::use_notebook_entries(ident, book_title);
     tracing::debug!("NotebookIndex got notebook data and entries");
+
+    #[cfg(feature = "fullstack-server")]
+    notebook_result?;
+
+    #[cfg(feature = "fullstack-server")]
+    entries_result?;
 
     rsx! {
         document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }