entry list on profile

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

···
 use crate::auth::AuthState;
-use crate::components::{ProfileActions, ProfileActionsMenubar};
+use crate::components::{FeedEntryCard, ProfileActions, ProfileActionsMenubar};
 use crate::{Route, data, fetch};
 use dioxus::prelude::*;
 use jacquard::{smol_str::SmolStr, types::ident::AtIdentifier};
+use std::collections::HashSet;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
-use weaver_api::sh_weaver::notebook::NotebookView;
+use weaver_api::sh_weaver::notebook::{EntryView, NotebookView, entry::Entry};
+
+/// A single item in the profile timeline (either notebook or standalone entry)
+#[derive(Clone, PartialEq)]
+pub enum ProfileTimelineItem {
+    Notebook {
+        notebook: NotebookView<'static>,
+        entries: Vec<StrongRef<'static>>,
+        /// Most recent entry's created_at for sorting
+        sort_date: jacquard::types::string::Datetime,
+    },
+    StandaloneEntry {
+        entry_view: EntryView<'static>,
+        entry: Entry<'static>,
+    },
+}
+
+impl ProfileTimelineItem {
+    pub fn sort_date(&self) -> &jacquard::types::string::Datetime {
+        match self {
+            Self::Notebook { sort_date, .. } => sort_date,
+            Self::StandaloneEntry { entry, .. } => &entry.created_at,
+        }
+    }
+}
 
 /// OpenGraph and Twitter Card meta tags for profile/repository pages
 #[component]
···
 #[component]
 pub fn RepositoryIndex(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
     use crate::components::ProfileDisplay;
+    use jacquard::from_data;
+    use weaver_api::sh_weaver::notebook::book::Book;
+
     let (notebooks_result, notebooks) = data::use_notebooks_for_did(ident);
+    let (entries_result, all_entries) = data::use_entries_for_did(ident);
     let (profile_result, profile) = crate::data::use_profile_data(ident);
 
     #[cfg(feature = "fullstack-server")]
     notebooks_result?;
 
     #[cfg(feature = "fullstack-server")]
+    entries_result?;
+
+    #[cfg(feature = "fullstack-server")]
     profile_result?;
 
+    // Extract pinned URIs from profile (only Weaver ProfileView has pinned)
+    let pinned_uris = use_memo(move || {
+        use jacquard::IntoStatic;
+        use jacquard::types::aturi::AtUri;
+        use weaver_api::sh_weaver::actor::ProfileDataViewInner;
+
+        let Some(prof) = profile.read().as_ref().cloned() else {
+            return Vec::<AtUri<'static>>::new();
+        };
+
+        match &prof.inner {
+            ProfileDataViewInner::ProfileView(p) => p
+                .pinned
+                .as_ref()
+                .map(|pins| pins.iter().map(|r| r.uri.clone().into_static()).collect())
+                .unwrap_or_default(),
+            _ => Vec::new(),
+        }
+    });
+
+    // Compute standalone entries (entries not in any notebook)
+    let standalone_entries = use_memo(move || {
+        let nbs = notebooks.read();
+        let ents = all_entries.read();
+
+        let (Some(nbs), Some(ents)) = (nbs.as_ref(), ents.as_ref()) else {
+            return Vec::new();
+        };
+
+        // Collect all entry URIs from all notebook entry_lists
+        let notebook_entry_uris: HashSet<&str> = nbs
+            .iter()
+            .flat_map(|(_, refs)| refs.iter().map(|r| r.uri.as_ref()))
+            .collect();
+
+        // Filter entries not in any notebook
+        ents.iter()
+            .filter(|(view, _)| !notebook_entry_uris.contains(view.uri.as_ref()))
+            .cloned()
+            .collect::<Vec<_>>()
+    });
+
+    // Helper to check if a URI is pinned
+    fn is_pinned(uri: &str, pinned: &[jacquard::types::aturi::AtUri<'static>]) -> bool {
+        pinned.iter().any(|p| p.as_ref() == uri)
+    }
+
+    // Build pinned items (matching notebooks/entries against pinned URIs)
+    let pinned_items = use_memo(move || {
+        let nbs = notebooks.read();
+        let standalone = standalone_entries.read();
+        let ents = all_entries.read();
+        let pinned = pinned_uris.read();
+
+        let mut items: Vec<ProfileTimelineItem> = Vec::new();
+
+        // Check notebooks
+        if let Some(nbs) = nbs.as_ref() {
+            if let Some(all_ents) = ents.as_ref() {
+                for (notebook, entry_refs) in nbs {
+                    if is_pinned(notebook.uri.as_ref(), &pinned) {
+                        let sort_date = entry_refs
+                            .iter()
+                            .filter_map(|r| {
+                                all_ents
+                                    .iter()
+                                    .find(|(v, _)| v.uri.as_ref() == r.uri.as_ref())
+                            })
+                            .map(|(_, entry)| entry.created_at.clone())
+                            .max()
+                            .unwrap_or_else(|| notebook.indexed_at.clone());
+
+                        items.push(ProfileTimelineItem::Notebook {
+                            notebook: notebook.clone(),
+                            entries: entry_refs.clone(),
+                            sort_date,
+                        });
+                    }
+                }
+            }
+        }
+
+        // Check standalone entries
+        for (view, entry) in standalone.iter() {
+            if is_pinned(view.uri.as_ref(), &pinned) {
+                items.push(ProfileTimelineItem::StandaloneEntry {
+                    entry_view: view.clone(),
+                    entry: entry.clone(),
+                });
+            }
+        }
+
+        // Sort pinned by their order in the pinned list
+        items.sort_by_key(|item| {
+            let uri = match item {
+                ProfileTimelineItem::Notebook { notebook, .. } => notebook.uri.as_ref(),
+                ProfileTimelineItem::StandaloneEntry { entry_view, .. } => entry_view.uri.as_ref(),
+            };
+            pinned
+                .iter()
+                .position(|p| p.as_ref() == uri)
+                .unwrap_or(usize::MAX)
+        });
+
+        items
+    });
+
+    // Build merged timeline sorted by date (newest first), excluding pinned items
+    let timeline = use_memo(move || {
+        let nbs = notebooks.read();
+        let standalone = standalone_entries.read();
+        let ents = all_entries.read();
+        let pinned = pinned_uris.read();
+
+        let mut items: Vec<ProfileTimelineItem> = Vec::new();
+
+        // Add notebooks (excluding pinned)
+        if let Some(nbs) = nbs.as_ref() {
+            if let Some(all_ents) = ents.as_ref() {
+                for (notebook, entry_refs) in nbs {
+                    if !is_pinned(notebook.uri.as_ref(), &pinned) {
+                        let sort_date = entry_refs
+                            .iter()
+                            .filter_map(|r| {
+                                all_ents
+                                    .iter()
+                                    .find(|(v, _)| v.uri.as_ref() == r.uri.as_ref())
+                            })
+                            .map(|(_, entry)| entry.created_at.clone())
+                            .max()
+                            .unwrap_or_else(|| notebook.indexed_at.clone());
+
+                        items.push(ProfileTimelineItem::Notebook {
+                            notebook: notebook.clone(),
+                            entries: entry_refs.clone(),
+                            sort_date,
+                        });
+                    }
+                }
+            }
+        }
+
+        // Add standalone entries (excluding pinned)
+        for (view, entry) in standalone.iter() {
+            if !is_pinned(view.uri.as_ref(), &pinned) {
+                items.push(ProfileTimelineItem::StandaloneEntry {
+                    entry_view: view.clone(),
+                    entry: entry.clone(),
+                });
+            }
+        }
+
+        // Sort by date descending (newest first)
+        items.sort_by(|a, b| b.sort_date().cmp(&a.sort_date()));
+
+        items
+    });
+
+    // Count standalone entries for stats
+    let entry_count = use_memo(move || all_entries.read().as_ref().map(|e| e.len()).unwrap_or(0));
+
     // Build OG metadata when profile is available
     let og_meta = match &*profile.read() {
         Some(profile_view) => {
···
         div { class: "repository-layout",
             // Profile sidebar (desktop) / header (mobile)
             aside { class: "repository-sidebar",
-                ProfileDisplay { profile, notebooks }
+                ProfileDisplay { profile, notebooks, entry_count: *entry_count.read() }
             }
 
             // Main content area
···
                 // Mobile menubar (hidden on desktop)
                 ProfileActionsMenubar { ident }
 
-                div { class: "notebooks-list",
-                    match &*notebooks.read() {
-                        Some(notebook_list) => rsx! {
-                            for notebook in notebook_list.iter() {
-                                {
-                                    let view = &notebook.0;
-                                    let entries = &notebook.1;
-                                    rsx! {
-                                        div {
-                                            key: "{view.cid}",
-                                            NotebookCard {
-                                                notebook: view.clone(),
-                                                entry_refs: entries.clone()
+                div { class: "profile-timeline",
+                    // Pinned items section
+                    {
+                        let pinned = pinned_items.read();
+                        if !pinned.is_empty() {
+                            rsx! {
+                                div { class: "pinned-section",
+                                    h3 { class: "pinned-header", "Pinned" }
+                                    for (idx, item) in pinned.iter().enumerate() {
+                                        {
+                                            match item {
+                                                ProfileTimelineItem::Notebook { notebook, entries, .. } => {
+                                                    rsx! {
+                                                        div {
+                                                            key: "pinned-notebook-{notebook.cid}",
+                                                            class: "pinned-item",
+                                                            NotebookCard {
+                                                                notebook: notebook.clone(),
+                                                                entry_refs: entries.clone()
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                ProfileTimelineItem::StandaloneEntry { entry_view, entry } => {
+                                                    rsx! {
+                                                        div {
+                                                            key: "pinned-entry-{idx}",
+                                                            class: "pinned-item standalone-entry-item",
+                                                            FeedEntryCard {
+                                                                entry_view: entry_view.clone(),
+                                                                entry: entry.clone()
+                                                            }
+                                                        }
+                                                    }
+                                                }
                                             }
                                         }
                                     }
                                 }
                             }
-                        },
-                        None => rsx! {
-                            div { "Loading notebooks..." }
+                        } else {
+                            rsx! {}
+                        }
+                    }
+
+                    // Chronological timeline
+                    {
+                        let timeline_items = timeline.read();
+                        if timeline_items.is_empty() && pinned_items.read().is_empty() {
+                            rsx! { div { class: "timeline-empty", "No content yet" } }
+                        } else {
+                            rsx! {
+                                for (idx, item) in timeline_items.iter().enumerate() {
+                                    {
+                                        match item {
+                                            ProfileTimelineItem::Notebook { notebook, entries, .. } => {
+                                                rsx! {
+                                                    div {
+                                                        key: "notebook-{notebook.cid}",
+                                                        NotebookCard {
+                                                            notebook: notebook.clone(),
+                                                            entry_refs: entries.clone()
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            ProfileTimelineItem::StandaloneEntry { entry_view, entry } => {
+                                                rsx! {
+                                                    div {
+                                                        key: "entry-{idx}",
+                                                        class: "standalone-entry-item",
+                                                        FeedEntryCard {
+                                                            entry_view: entry_view.clone(),
+                                                            entry: entry.clone()
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         }
                     }
                 }

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

···
 pub fn ProfileDisplay(
     profile: Memo<Option<ProfileDataView<'static>>>,
     notebooks: Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+    #[props(default)] entry_count: usize,
 ) -> Element {
     match &*profile.read() {
         Some(profile_view) => {
···
                         div {
                             class: "profile-extras",
                             // Stats
-                            ProfileStats { notebooks: notebooks }
+                            ProfileStats { notebooks, entry_count }
 
                             // Links
                             ProfileLinks { profile_view }
···
 #[component]
 fn ProfileStats(
     notebooks: Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+    #[props(default)] entry_count: usize,
 ) -> Element {
-    // Fetch notebook count
-    let notebook_count = if let Some(notebooks) = &*notebooks.read() {
-        notebooks.len()
-    } else {
-        0
-    };
+    let notebook_count = notebooks.read().as_ref().map(|n| n.len()).unwrap_or(0);
 
     rsx! {
         div { class: "profile-stats",
             div { class: "profile-stat",
                 span { class: "profile-stat-label", "{notebook_count} notebooks" }
             }
-            // TODO: Add entry count, subscriber counts when available
+            if entry_count > 0 {
+                div { class: "profile-stat",
+                    span { class: "profile-stat-label", "{entry_count} entries" }
+                }
+            }
         }
     }
 }

crates/weaver-app/src/data.rs

···
     (res, memo)
 }
 
+/// Fetches all entries for a specific DID with SSR support
+#[cfg(feature = "fullstack-server")]
+pub fn use_entries_for_did(
+    ident: ReadSignal<AtIdentifier<'static>>,
+) -> (
+    Result<Resource<Option<Vec<(serde_json::Value, serde_json::Value)>>>, RenderError>,
+    Memo<Option<Vec<(EntryView<'static>, Entry<'static>)>>>,
+) {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let res = use_server_future(use_reactive!(|ident| {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_entries_for_did(&ident())
+                .await
+                .ok()
+                .map(|entries| {
+                    entries
+                        .iter()
+                        .filter_map(|arc| {
+                            let (view, entry) = arc.as_ref();
+                            let view_json = serde_json::to_value(view).ok()?;
+                            let entry_json = serde_json::to_value(entry).ok()?;
+                            Some((view_json, entry_json))
+                        })
+                        .collect::<Vec<_>>()
+                })
+        }
+    }));
+    let memo = use_memo(use_reactive!(|res| {
+        let res = res.as_ref().ok()?;
+        if let Some(Some(values)) = &*res.read() {
+            let result: Vec<_> = values
+                .iter()
+                .filter_map(|(view_json, entry_json)| {
+                    let view = jacquard::from_json_value::<EntryView>(view_json.clone()).ok()?;
+                    let entry = jacquard::from_json_value::<Entry>(entry_json.clone()).ok()?;
+                    Some((view, entry))
+                })
+                .collect();
+            Some(result)
+        } else {
+            None
+        }
+    }));
+    (res, memo)
+}
+
+/// Fetches all entries for a specific DID client-side only (no SSR)
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_entries_for_did(
+    ident: ReadSignal<AtIdentifier<'static>>,
+) -> (
+    Resource<Option<Vec<(EntryView<'static>, Entry<'static>)>>>,
+    Memo<Option<Vec<(EntryView<'static>, Entry<'static>)>>>,
+) {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let res = use_resource(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_entries_for_did(&ident())
+                .await
+                .ok()
+                .map(|entries| {
+                    entries
+                        .iter()
+                        .map(|arc| arc.as_ref().clone())
+                        .collect::<Vec<_>>()
+                })
+        }
+    });
+    let memo = use_memo(move || res.read().clone().flatten());
+    (res, memo)
+}
+
 /// Fetches notebooks from UFOS with SSR support in fullstack mode
 #[cfg(feature = "fullstack-server")]
 pub fn use_notebooks_from_ufos() -> (

crates/weaver-app/src/fetch.rs

···
         Ok(notebooks)
     }
 
+    /// Fetch all entries for a DID (for profile timeline)
+    pub async fn fetch_entries_for_did(
+        &self,
+        ident: &AtIdentifier<'_>,
+    ) -> Result<Vec<Arc<(EntryView<'static>, Entry<'static>)>>> {
+        use jacquard::{
+            IntoStatic,
+            types::{collection::Collection, nsid::Nsid},
+            xrpc::XrpcExt,
+        };
+        use weaver_api::com_atproto::repo::list_records::ListRecords;
+
+        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 entry records for this repo
+        let resp = client
+            .xrpc(pds_url)
+            .send(
+                &ListRecords::new()
+                    .repo(repo_did)
+                    .collection(Nsid::raw(Entry::NSID))
+                    .limit(100)
+                    .build(),
+            )
+            .await
+            .map_err(|e| dioxus::CapturedError::from_display(e))?;
+
+        let mut entries = Vec::new();
+        let ident_static = ident.clone().into_static();
+
+        if let Ok(list) = resp.parse() {
+            for record in list.records {
+                // Extract rkey from URI
+                let rkey = record
+                    .uri
+                    .rkey()
+                    .map(|r| r.0.as_str())
+                    .unwrap_or_default();
+
+                // Fetch the entry with hydration
+                match client.fetch_entry_by_rkey(&ident_static, rkey).await {
+                    Ok((entry_view, entry)) => {
+                        entries.push(Arc::new((entry_view.into_static(), entry.into_static())));
+                    }
+                    Err(e) => {
+                        tracing::warn!(
+                            "[fetch_entries_for_did] failed to load entry {}: {:?}",
+                            rkey,
+                            e
+                        );
+                        continue;
+                    }
+                }
+            }
+        }
+
+        Ok(entries)
+    }
+
     pub async fn list_notebook_entries(
         &self,
         ident: AtIdentifier<'static>,