reworking styling

crates/weaver-api/lexicons/sh_weaver_actor_defs.json

···
           "type": "string",
           "format": "did"
         },
-        "displayName": {
-          "type": "string",
-          "maxLength": 640,
-          "maxGraphemes": 64
-        },
-        "handle": {
-          "type": "string",
-          "format": "handle"
+        "signature": {
+          "type": "bytes",
+          "description": "signed bytes of the corresponding notebook record in the author's repo"
         }
       }
     },
···
           "type": "string",
           "format": "uri"
         },
+        "bluesky": {
+          "type": "boolean",
+          "description": "Include link to this account on Bluesky."
+        },
         "createdAt": {
           "type": "string",
           "format": "datetime"
···
           "description": "Pronouns to use in user-generated content.",
           "ref": "#pronounsList"
         },
+        "streamplace": {
+          "type": "boolean",
+          "description": "Include link to this account on stream.place."
+        },
         "subscribedCount": {
           "type": "integer"
         },
         "subscriberCount": {
           "type": "integer"
+        },
+        "tangled": {
+          "type": "boolean",
+          "description": "Include link to this account on Tangled."
         }
       }
     },

crates/weaver-api/src/sh_weaver/actor.rs

···
 pub struct Author<'a> {
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
+    /// signed bytes of the corresponding notebook record in the author's repo
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    #[serde(borrow)]
-    pub handle: Option<jacquard_common::types::string::Handle<'a>>,
+    pub signature: Option<bytes::Bytes>,
 }
 
 pub mod author_state {
···
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
         ::core::option::Option<jacquard_common::types::string::Did<'a>>,
-        ::core::option::Option<jacquard_common::CowStr<'a>>,
-        ::core::option::Option<jacquard_common::types::string::Handle<'a>>,
+        ::core::option::Option<bytes::Bytes>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
 }
···
     pub fn new() -> Self {
         AuthorBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None),
+            __unsafe_private_named: (None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
 }
 
 impl<'a, S: author_state::State> AuthorBuilder<'a, S> {
-    /// Set the `displayName` field (optional)
-    pub fn display_name(
-        mut self,
-        value: impl Into<Option<jacquard_common::CowStr<'a>>>,
-    ) -> Self {
+    /// Set the `signature` field (optional)
+    pub fn signature(mut self, value: impl Into<Option<bytes::Bytes>>) -> Self {
         self.__unsafe_private_named.1 = value.into();
         self
     }
-    /// Set the `displayName` field to an Option value (optional)
-    pub fn maybe_display_name(
-        mut self,
-        value: Option<jacquard_common::CowStr<'a>>,
-    ) -> Self {
+    /// Set the `signature` field to an Option value (optional)
+    pub fn maybe_signature(mut self, value: Option<bytes::Bytes>) -> Self {
         self.__unsafe_private_named.1 = value;
         self
     }
 }
 
-impl<'a, S: author_state::State> AuthorBuilder<'a, S> {
-    /// Set the `handle` field (optional)
-    pub fn handle(
-        mut self,
-        value: impl Into<Option<jacquard_common::types::string::Handle<'a>>>,
-    ) -> Self {
-        self.__unsafe_private_named.2 = value.into();
-        self
-    }
-    /// Set the `handle` field to an Option value (optional)
-    pub fn maybe_handle(
-        mut self,
-        value: Option<jacquard_common::types::string::Handle<'a>>,
-    ) -> Self {
-        self.__unsafe_private_named.2 = value;
-        self
-    }
-}
-
 impl<'a, S> AuthorBuilder<'a, S>
 where
     S: author_state::State,
···
     pub fn build(self) -> Author<'a> {
         Author {
             did: self.__unsafe_private_named.0.unwrap(),
-            display_name: self.__unsafe_private_named.1,
-            handle: self.__unsafe_private_named.2,
+            signature: self.__unsafe_private_named.1,
             extra_data: Default::default(),
         }
     }
···
     ) -> Author<'a> {
         Author {
             did: self.__unsafe_private_named.0.unwrap(),
-            display_name: self.__unsafe_private_named.1,
-            handle: self.__unsafe_private_named.2,
+            signature: self.__unsafe_private_named.1,
             extra_data: Some(extra_data),
         }
     }
···
                         );
                         map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static(
-                                "displayName",
+                                "signature",
                             ),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Bytes(::jacquard_lexicon::lexicon::LexBytes {
                                 description: None,
-                                format: None,
-                                default: None,
+                                max_length: None,
                                 min_length: None,
-                                max_length: Some(640usize),
-                                min_graphemes: None,
-                                max_graphemes: Some(64usize),
-                                r#enum: None,
-                                r#const: None,
-                                known_values: None,
-                            }),
-                        );
-                        map.insert(
-                            ::jacquard_common::smol_str::SmolStr::new_static("handle"),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                description: None,
-                                format: Some(
-                                    ::jacquard_lexicon::lexicon::LexStringFormat::Handle,
-                                ),
-                                default: None,
-                                min_length: None,
-                                max_length: None,
-                                min_graphemes: None,
-                                max_graphemes: None,
-                                r#enum: None,
-                                r#const: None,
-                                known_values: None,
                             }),
                         );
                         map
···
                                 r#enum: None,
                                 r#const: None,
                                 known_values: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("bluesky"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
+                                description: None,
+                                default: None,
+                                r#const: None,
                             }),
                         );
                         map.insert(
···
                         );
                         map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static(
+                                "streamplace",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
+                                description: None,
+                                default: None,
+                                r#const: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
                                 "subscribedCount",
                             ),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
···
                                 minimum: None,
                                 maximum: None,
                                 r#enum: None,
+                                r#const: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("tangled"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
+                                description: None,
+                                default: None,
                                 r#const: None,
                             }),
                         );
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
-        if let Some(ref value) = self.display_name {
-            #[allow(unused_comparisons)]
-            if <str>::len(value.as_ref()) > 640usize {
-                return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
-                    path: ::jacquard_lexicon::validation::ValidationPath::from_field(
-                        "display_name",
-                    ),
-                    max: 640usize,
-                    actual: <str>::len(value.as_ref()),
-                });
-            }
-        }
-        if let Some(ref value) = self.display_name {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 64usize {
-                    return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
-                        path: ::jacquard_lexicon::validation::ValidationPath::from_field(
-                            "display_name",
-                        ),
-                        max: 64usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub banner: Option<jacquard_common::types::string::Uri<'a>>,
+    /// Include link to this account on Bluesky.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    pub bluesky: Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub created_at: Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub pronouns: Option<crate::sh_weaver::actor::PronounsList<'a>>,
+    /// Include link to this account on stream.place.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    pub streamplace: Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub subscribed_count: Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub subscriber_count: Option<i64>,
+    /// Include link to this account on Tangled.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    pub tangled: Option<bool>,
 }
 
 pub mod profile_view_state {
···
     __unsafe_private_named: (
         ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
         ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
+        ::core::option::Option<bool>,
         ::core::option::Option<jacquard_common::types::string::Datetime>,
         ::core::option::Option<jacquard_common::CowStr<'a>>,
         ::core::option::Option<jacquard_common::types::string::Did<'a>>,
···
         ::core::option::Option<jacquard_common::CowStr<'a>>,
         ::core::option::Option<crate::sh_weaver::actor::PinnedList<'a>>,
         ::core::option::Option<crate::sh_weaver::actor::PronounsList<'a>>,
+        ::core::option::Option<bool>,
         ::core::option::Option<i64>,
         ::core::option::Option<i64>,
+        ::core::option::Option<bool>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
 }
···
                 None,
                 None,
                 None,
+                None,
+                None,
+                None,
             ),
             _phantom: ::core::marker::PhantomData,
         }
···
 }
 
 impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
+    /// Set the `bluesky` field (optional)
+    pub fn bluesky(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.__unsafe_private_named.2 = value.into();
+        self
+    }
+    /// Set the `bluesky` field to an Option value (optional)
+    pub fn maybe_bluesky(mut self, value: Option<bool>) -> Self {
+        self.__unsafe_private_named.2 = value;
+        self
+    }
+}
+
+impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
     /// Set the `createdAt` field (optional)
     pub fn created_at(
         mut self,
         value: impl Into<Option<jacquard_common::types::string::Datetime>>,
     ) -> Self {
-        self.__unsafe_private_named.2 = value.into();
+        self.__unsafe_private_named.3 = value.into();
         self
     }
     /// Set the `createdAt` field to an Option value (optional)
···
         mut self,
         value: Option<jacquard_common::types::string::Datetime>,
     ) -> Self {
-        self.__unsafe_private_named.2 = value;
+        self.__unsafe_private_named.3 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<Option<jacquard_common::CowStr<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.3 = value.into();
+        self.__unsafe_private_named.4 = value.into();
         self
     }
     /// Set the `description` field to an Option value (optional)
···
         mut self,
         value: Option<jacquard_common::CowStr<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.3 = value;
+        self.__unsafe_private_named.4 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<jacquard_common::types::string::Did<'a>>,
     ) -> ProfileViewBuilder<'a, profile_view_state::SetDid<S>> {
-        self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.5 = ::core::option::Option::Some(value.into());
         ProfileViewBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
         mut self,
         value: impl Into<Option<jacquard_common::CowStr<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.5 = value.into();
+        self.__unsafe_private_named.6 = value.into();
         self
     }
     /// Set the `displayName` field to an Option value (optional)
···
         mut self,
         value: Option<jacquard_common::CowStr<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.5 = value;
+        self.__unsafe_private_named.6 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<jacquard_common::types::string::Handle<'a>>,
     ) -> ProfileViewBuilder<'a, profile_view_state::SetHandle<S>> {
-        self.__unsafe_private_named.6 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.7 = ::core::option::Option::Some(value.into());
         ProfileViewBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
         mut self,
         value: impl Into<Option<jacquard_common::types::string::Datetime>>,
     ) -> Self {
-        self.__unsafe_private_named.7 = value.into();
+        self.__unsafe_private_named.8 = value.into();
         self
     }
     /// Set the `indexedAt` field to an Option value (optional)
···
         mut self,
         value: Option<jacquard_common::types::string::Datetime>,
     ) -> Self {
-        self.__unsafe_private_named.7 = value;
+        self.__unsafe_private_named.8 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
     ) -> Self {
-        self.__unsafe_private_named.8 = value.into();
+        self.__unsafe_private_named.9 = value.into();
         self
     }
     /// Set the `labels` field to an Option value (optional)
···
         mut self,
         value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.8 = value;
+        self.__unsafe_private_named.9 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<Option<Vec<jacquard_common::types::string::Uri<'a>>>>,
     ) -> Self {
-        self.__unsafe_private_named.9 = value.into();
+        self.__unsafe_private_named.10 = value.into();
         self
     }
     /// Set the `links` field to an Option value (optional)
···
         mut self,
         value: Option<Vec<jacquard_common::types::string::Uri<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.9 = value;
+        self.__unsafe_private_named.10 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<Option<jacquard_common::CowStr<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.10 = value.into();
+        self.__unsafe_private_named.11 = value.into();
         self
     }
     /// Set the `location` field to an Option value (optional)
     pub fn maybe_location(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
-        self.__unsafe_private_named.10 = value;
+        self.__unsafe_private_named.11 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<Option<crate::sh_weaver::actor::PinnedList<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.11 = value.into();
+        self.__unsafe_private_named.12 = value.into();
         self
     }
     /// Set the `pinned` field to an Option value (optional)
···
         mut self,
         value: Option<crate::sh_weaver::actor::PinnedList<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.11 = value;
+        self.__unsafe_private_named.12 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<Option<crate::sh_weaver::actor::PronounsList<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.12 = value.into();
+        self.__unsafe_private_named.13 = value.into();
         self
     }
     /// Set the `pronouns` field to an Option value (optional)
···
         mut self,
         value: Option<crate::sh_weaver::actor::PronounsList<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.12 = value;
+        self.__unsafe_private_named.13 = value;
+        self
+    }
+}
+
+impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
+    /// Set the `streamplace` field (optional)
+    pub fn streamplace(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.__unsafe_private_named.14 = value.into();
+        self
+    }
+    /// Set the `streamplace` field to an Option value (optional)
+    pub fn maybe_streamplace(mut self, value: Option<bool>) -> Self {
+        self.__unsafe_private_named.14 = value;
         self
     }
 }
···
 impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
     /// Set the `subscribedCount` field (optional)
     pub fn subscribed_count(mut self, value: impl Into<Option<i64>>) -> Self {
-        self.__unsafe_private_named.13 = value.into();
+        self.__unsafe_private_named.15 = value.into();
         self
     }
     /// Set the `subscribedCount` field to an Option value (optional)
     pub fn maybe_subscribed_count(mut self, value: Option<i64>) -> Self {
-        self.__unsafe_private_named.13 = value;
+        self.__unsafe_private_named.15 = value;
         self
     }
 }
···
 impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
     /// Set the `subscriberCount` field (optional)
     pub fn subscriber_count(mut self, value: impl Into<Option<i64>>) -> Self {
-        self.__unsafe_private_named.14 = value.into();
+        self.__unsafe_private_named.16 = value.into();
         self
     }
     /// Set the `subscriberCount` field to an Option value (optional)
     pub fn maybe_subscriber_count(mut self, value: Option<i64>) -> Self {
-        self.__unsafe_private_named.14 = value;
+        self.__unsafe_private_named.16 = value;
+        self
+    }
+}
+
+impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
+    /// Set the `tangled` field (optional)
+    pub fn tangled(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.__unsafe_private_named.17 = value.into();
+        self
+    }
+    /// Set the `tangled` field to an Option value (optional)
+    pub fn maybe_tangled(mut self, value: Option<bool>) -> Self {
+        self.__unsafe_private_named.17 = value;
         self
     }
 }
···
         ProfileView {
             avatar: self.__unsafe_private_named.0,
             banner: self.__unsafe_private_named.1,
-            created_at: self.__unsafe_private_named.2,
-            description: self.__unsafe_private_named.3,
-            did: self.__unsafe_private_named.4.unwrap(),
-            display_name: self.__unsafe_private_named.5,
-            handle: self.__unsafe_private_named.6.unwrap(),
-            indexed_at: self.__unsafe_private_named.7,
-            labels: self.__unsafe_private_named.8,
-            links: self.__unsafe_private_named.9,
-            location: self.__unsafe_private_named.10,
-            pinned: self.__unsafe_private_named.11,
-            pronouns: self.__unsafe_private_named.12,
-            subscribed_count: self.__unsafe_private_named.13,
-            subscriber_count: self.__unsafe_private_named.14,
+            bluesky: self.__unsafe_private_named.2,
+            created_at: self.__unsafe_private_named.3,
+            description: self.__unsafe_private_named.4,
+            did: self.__unsafe_private_named.5.unwrap(),
+            display_name: self.__unsafe_private_named.6,
+            handle: self.__unsafe_private_named.7.unwrap(),
+            indexed_at: self.__unsafe_private_named.8,
+            labels: self.__unsafe_private_named.9,
+            links: self.__unsafe_private_named.10,
+            location: self.__unsafe_private_named.11,
+            pinned: self.__unsafe_private_named.12,
+            pronouns: self.__unsafe_private_named.13,
+            streamplace: self.__unsafe_private_named.14,
+            subscribed_count: self.__unsafe_private_named.15,
+            subscriber_count: self.__unsafe_private_named.16,
+            tangled: self.__unsafe_private_named.17,
             extra_data: Default::default(),
         }
     }
···
         ProfileView {
             avatar: self.__unsafe_private_named.0,
             banner: self.__unsafe_private_named.1,
-            created_at: self.__unsafe_private_named.2,
-            description: self.__unsafe_private_named.3,
-            did: self.__unsafe_private_named.4.unwrap(),
-            display_name: self.__unsafe_private_named.5,
-            handle: self.__unsafe_private_named.6.unwrap(),
-            indexed_at: self.__unsafe_private_named.7,
-            labels: self.__unsafe_private_named.8,
-            links: self.__unsafe_private_named.9,
-            location: self.__unsafe_private_named.10,
-            pinned: self.__unsafe_private_named.11,
-            pronouns: self.__unsafe_private_named.12,
-            subscribed_count: self.__unsafe_private_named.13,
-            subscriber_count: self.__unsafe_private_named.14,
+            bluesky: self.__unsafe_private_named.2,
+            created_at: self.__unsafe_private_named.3,
+            description: self.__unsafe_private_named.4,
+            did: self.__unsafe_private_named.5.unwrap(),
+            display_name: self.__unsafe_private_named.6,
+            handle: self.__unsafe_private_named.7.unwrap(),
+            indexed_at: self.__unsafe_private_named.8,
+            labels: self.__unsafe_private_named.9,
+            links: self.__unsafe_private_named.10,
+            location: self.__unsafe_private_named.11,
+            pinned: self.__unsafe_private_named.12,
+            pronouns: self.__unsafe_private_named.13,
+            streamplace: self.__unsafe_private_named.14,
+            subscribed_count: self.__unsafe_private_named.15,
+            subscriber_count: self.__unsafe_private_named.16,
+            tangled: self.__unsafe_private_named.17,
             extra_data: Some(extra_data),
         }
     }

crates/weaver-app/assets/styling/profile.css

···
+/* Profile display - sidebar on desktop, header on mobile */
+
+.profile-display {
+    background: var(--color-surface);
+    border: 1px solid var(--color-border);
+    border-radius: 4px;
+}
+
+.profile-banner {
+    width: 100%;
+    height: 120px;
+    overflow: hidden;
+    border-radius: 4px 4px 0 0;
+}
+
+.profile-banner img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.profile-content {
+    padding: 1.5rem;
+}
+
+.profile-identity {
+    margin-bottom: 1.5rem;
+}
+
+.profile-identity .avatar {
+    width: 120px;
+    height: 120px;
+    margin-bottom: 1rem;
+}
+
+.profile-name-section {
+    margin-bottom: 0.75rem;
+}
+
+.profile-display-name {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--color-text);
+    margin: 0 0 0.25rem 0;
+    font-family: var(--font-heading);
+}
+
+.profile-pronouns {
+    font-size: 1rem;
+    font-weight: 400;
+    color: var(--color-muted);
+}
+
+.profile-handle {
+    font-size: 0.95rem;
+    color: var(--color-subtle);
+    margin-bottom: 0.5rem;
+}
+
+.profile-location {
+    font-size: 0.9rem;
+    color: var(--color-muted);
+}
+
+.profile-description {
+    color: var(--color-text);
+    line-height: 1.5;
+    margin-top: 0.75rem;
+    white-space: pre-wrap;
+}
+
+.profile-stats {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+    gap: 1rem;
+    padding: 1rem 0;
+    margin: 1rem 0;
+    border-top: 1px solid var(--color-border);
+    border-bottom: 1px solid var(--color-border);
+}
+
+.profile-stat {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+}
+
+.profile-stat-label {
+    font-size: 0.85rem;
+    color: var(--color-subtle);
+}
+
+.profile-stat-value {
+    font-size: 1.25rem;
+    font-weight: 600;
+    color: var(--color-primary);
+}
+
+.profile-links {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.profile-link {
+    color: var(--color-link);
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.15s ease;
+}
+
+.profile-link:hover {
+    color: var(--color-primary);
+}
+
+.profile-link-platform {
+    font-weight: 500;
+}
+
+.profile-loading {
+    padding: 2rem;
+    text-align: center;
+    color: var(--color-muted);
+}
+
+/* Mobile layout */
+@media (max-width: 768px) {
+    .profile-identity .avatar {
+        width: 80px;
+        height: 80px;
+    }
+
+    .profile-display-name {
+        font-size: 1.25rem;
+    }
+}

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

···
 pub mod identity;
 pub use identity::{NotebookCard, Repository, RepositoryIndex};
 pub mod avatar;
+
+pub mod profile;
+pub use profile::ProfileDisplay;

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

···
+#![allow(non_snake_case)]
+
+use crate::{
+    components::avatar::{Avatar, AvatarImage},
+    Route,
+};
+use dioxus::prelude::*;
+use jacquard::types::ident::AtIdentifier;
+use weaver_api::sh_weaver::actor::ProfileDataViewInner;
+
+const PROFILE_CSS: Asset = asset!("/assets/styling/profile.css");
+
+#[component]
+pub fn ProfileDisplay(ident: AtIdentifier<'static>) -> Element {
+    // Fetch profile data
+    let profile = crate::data::use_profile_data(ident.clone())?;
+
+    match profile().as_ref() {
+        Some(profile_view) => rsx! {
+            document::Link { rel: "stylesheet", href: PROFILE_CSS }
+
+            div { class: "profile-display",
+                // Banner if present
+                {match &profile_view.inner {
+                    ProfileDataViewInner::ProfileView(p) => {
+                        if let Some(ref banner) = p.banner {
+                            rsx! {
+                                div { class: "profile-banner",
+                                    img { src: "{banner.as_ref()}", alt: "Profile banner" }
+                                }
+                            }
+                        } else {
+                            rsx! { }
+                        }
+                    }
+                    _ => rsx! { }
+                }}
+
+                div { class: "profile-content",
+                    // Avatar and identity
+                    ProfileIdentity { profile_view: profile_view.clone(), ident: ident.clone() }
+
+                    // Stats
+                    ProfileStats { ident: ident.clone() }
+
+                    // Links
+                    ProfileLinks { profile_view: profile_view.clone(), ident: ident.clone() }
+                }
+            }
+        },
+        None => rsx! {
+            div { class: "profile-display profile-loading",
+                "Loading profile..."
+            }
+        },
+    }
+}
+
+#[component]
+fn ProfileIdentity(
+    profile_view: weaver_api::sh_weaver::actor::ProfileDataView<'static>,
+    ident: AtIdentifier<'static>,
+) -> Element {
+    match &profile_view.inner {
+        ProfileDataViewInner::ProfileView(profile) => {
+            let display_name = profile
+                .display_name
+                .as_ref()
+                .map(|n| n.as_ref())
+                .unwrap_or("Unknown");
+
+            // Format pronouns
+            let pronouns_text = if let Some(ref pronouns) = profile.pronouns {
+                if !pronouns.is_empty() {
+                    Some(
+                        pronouns
+                            .iter()
+                            .map(|p| p.as_ref())
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                    )
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            rsx! {
+                div { class: "profile-identity",
+                    if let Some(ref avatar) = profile.avatar {
+                        Avatar {
+                            AvatarImage { src: avatar.as_ref() }
+                        }
+                    }
+
+                    div { class: "profile-name-section",
+                        h1 { class: "profile-display-name",
+                            "{display_name}"
+                            if let Some(ref pronouns) = pronouns_text {
+                                span { class: "profile-pronouns", " ({pronouns})" }
+                            }
+                        }
+                        div { class: "profile-handle", "@{ident}" }
+
+                        if let Some(ref location) = profile.location {
+                            div { class: "profile-location", "{location}" }
+                        }
+                    }
+
+                    if let Some(ref description) = profile.description {
+                        div { class: "profile-description", "{description}" }
+                    }
+                }
+            }
+        }
+        ProfileDataViewInner::ProfileViewDetailed(profile) => {
+            let display_name = profile
+                .display_name
+                .as_ref()
+                .map(|n| n.as_ref())
+                .unwrap_or("Unknown");
+
+            rsx! {
+                div { class: "profile-identity",
+                    if let Some(ref avatar) = profile.avatar {
+                        Avatar {
+                            AvatarImage { src: avatar.as_ref() }
+                        }
+                    }
+
+                    div { class: "profile-name-section",
+                        h1 { class: "profile-display-name", "{display_name}" }
+                        div { class: "profile-handle", "@{ident}" }
+                    }
+
+                    if let Some(ref description) = profile.description {
+                        div { class: "profile-description", "{description}" }
+                    }
+                }
+            }
+        }
+        ProfileDataViewInner::TangledProfileView(profile) => {
+            rsx! {
+                div { class: "profile-identity",
+                    div { class: "profile-name-section",
+                        h1 { class: "profile-display-name", "@{profile.handle.as_ref()}" }
+                        div { class: "profile-handle", "{ident}" }
+
+                        if let Some(ref location) = profile.location {
+                            div { class: "profile-location", "{location}" }
+                        }
+                    }
+
+                    if let Some(ref description) = profile.description {
+                        div { class: "profile-description", "{description}" }
+                    }
+                }
+            }
+        }
+        _ => rsx! {
+            div { class: "profile-identity",
+                "Unknown profile type"
+            }
+        },
+    }
+}
+
+#[component]
+fn ProfileStats(ident: AtIdentifier<'static>) -> Element {
+    // Fetch notebook count
+    let notebooks = crate::data::use_notebooks_for_did(ident.clone())?;
+
+    let notebook_count = notebooks().as_ref().map(|n| n.len()).unwrap_or(0);
+
+    rsx! {
+        div { class: "profile-stats",
+            div { class: "profile-stat",
+                span { class: "profile-stat-label", "Notebooks" }
+                span { class: "profile-stat-value", "{notebook_count}" }
+            }
+            // TODO: Add entry count, subscriber counts when available
+        }
+    }
+}
+
+#[component]
+fn ProfileLinks(
+    profile_view: weaver_api::sh_weaver::actor::ProfileDataView<'static>,
+    ident: AtIdentifier<'static>,
+) -> Element {
+    match &profile_view.inner {
+        ProfileDataViewInner::ProfileView(profile) => {
+            rsx! {
+                div { class: "profile-links",
+                    // Generic links
+                    if let Some(ref links) = profile.links {
+                        for link in links.iter() {
+                            a {
+                                href: "{link.as_ref()}",
+                                target: "_blank",
+                                rel: "noopener noreferrer",
+                                class: "profile-link",
+                                "{link.as_ref()}"
+                            }
+                        }
+                    }
+
+                    // Platform-specific links
+                    if profile.bluesky.unwrap_or(false) {
+                        a {
+                            href: "https://bsky.app/profile/{ident}",
+                            target: "_blank",
+                            rel: "noopener noreferrer",
+                            class: "profile-link profile-link-platform",
+                            "View on Bluesky"
+                        }
+                    }
+
+                    if profile.tangled.unwrap_or(false) {
+                        a {
+                            href: "https://tangled.dev/{ident}",
+                            target: "_blank",
+                            rel: "noopener noreferrer",
+                            class: "profile-link profile-link-platform",
+                            "View on Tangled"
+                        }
+                    }
+
+                    if profile.streamplace.unwrap_or(false) {
+                        a {
+                            href: "https://stream.place/{ident}",
+                            target: "_blank",
+                            rel: "noopener noreferrer",
+                            class: "profile-link profile-link-platform",
+                            "View on stream.place"
+                        }
+                    }
+                }
+            }
+        }
+        ProfileDataViewInner::ProfileViewDetailed(_profile) => {
+            // Bluesky ProfileViewDetailed - doesn't have weaver platform flags
+            rsx! {
+                div { class: "profile-links",
+                    a {
+                        href: "https://bsky.app/profile/{ident}",
+                        target: "_blank",
+                        rel: "noopener noreferrer",
+                        class: "profile-link profile-link-platform",
+                        "View on Bluesky"
+                    }
+                }
+            }
+        }
+        ProfileDataViewInner::TangledProfileView(profile) => {
+            rsx! {
+                div { class: "profile-links",
+                    if let Some(ref links) = profile.links {
+                        for link in links.iter() {
+                            a {
+                                href: "{link.as_ref()}",
+                                target: "_blank",
+                                rel: "noopener noreferrer",
+                                class: "profile-link",
+                                "{link.as_ref()}"
+                            }
+                        }
+                    }
+
+                    if profile.bluesky {
+                        a {
+                            href: "https://bsky.app/profile/{ident}",
+                            target: "_blank",
+                            rel: "noopener noreferrer",
+                            class: "profile-link profile-link-platform",
+                            "View on Bluesky"
+                        }
+                    }
+                }
+            }
+        }
+        _ => rsx! {},
+    }
+}

crates/weaver-app/src/data.rs

···
     html_buf
 }
 
+/// Fetches profile data for a given identifier
+#[cfg(feature = "fullstack-server")]
+pub fn use_profile_data(
+    ident: AtIdentifier<'static>,
+) -> Result<Memo<Option<weaver_api::sh_weaver::actor::ProfileDataView<'static>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let ident = use_signal(|| ident);
+    let res = use_server_future(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_profile(&ident())
+                .await
+                .ok()
+                .map(|arc| serde_json::to_value(&*arc).ok())
+                .flatten()
+        }
+    })?;
+    Ok(use_memo(move || {
+        if let Some(Some(value)) = &*res.read_unchecked() {
+            jacquard::from_json_value::<weaver_api::sh_weaver::actor::ProfileDataView>(value.clone()).ok()
+        } else {
+            None
+        }
+    }))
+}
+
+/// Fetches profile data client-side only (no SSR)
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_profile_data(
+    ident: AtIdentifier<'static>,
+) -> Result<Memo<Option<weaver_api::sh_weaver::actor::ProfileDataView<'static>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let r = use_resource(use_reactive!(|ident| {
+        let fetcher = fetcher.clone();
+        async move { fetcher.fetch_profile(&ident).await.ok().map(|arc| (*arc).clone()) }
+    }));
+    Ok(use_memo(move || {
+        r.read_unchecked().as_ref().and_then(|v| v.clone())
+    }))
+}
+
+/// Fetches notebooks for a specific DID
+#[cfg(feature = "fullstack-server")]
+pub fn use_notebooks_for_did(
+    ident: AtIdentifier<'static>,
+) -> Result<
+    Memo<
+        Option<
+            Vec<(
+                weaver_api::sh_weaver::notebook::NotebookView<'static>,
+                Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>,
+            )>,
+        >,
+    >,
+    RenderError,
+> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let ident = use_signal(|| ident);
+    let res = use_server_future(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_notebooks_for_did(&ident())
+                .await
+                .ok()
+                .map(|notebooks| {
+                    notebooks
+                        .iter()
+                        .map(|arc| serde_json::to_value(arc.as_ref()).ok())
+                        .collect::<Option<Vec<_>>>()
+                })
+                .flatten()
+        }
+    })?;
+    Ok(use_memo(move || {
+        if let Some(Some(values)) = &*res.read_unchecked() {
+            values
+                .iter()
+                .map(|v| jacquard::from_json_value::<(
+                    weaver_api::sh_weaver::notebook::NotebookView,
+                    Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef>,
+                )>(v.clone()).ok())
+                .collect::<Option<Vec<_>>>()
+        } else {
+            None
+        }
+    }))
+}
+
+/// Fetches notebooks client-side only (no SSR)
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_notebooks_for_did(
+    ident: AtIdentifier<'static>,
+) -> Result<
+    Memo<
+        Option<
+            Vec<(
+                weaver_api::sh_weaver::notebook::NotebookView<'static>,
+                Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>,
+            )>,
+        >,
+    >,
+    RenderError,
+> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let r = use_resource(use_reactive!(|ident| {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_notebooks_for_did(&ident)
+                .await
+                .ok()
+                .map(|notebooks| notebooks.iter().map(|arc| (*arc).clone()).collect())
+        }
+    }));
+    Ok(use_memo(move || {
+        r.read_unchecked().as_ref().and_then(|v| v.clone())
+    }))
+}
+
 #[cfg(feature = "fullstack-server")]
 #[put("/cache/{ident}/{cid}?name", cache: Extension<Arc<BlobCache>>)]
 pub async fn cache_blob(ident: SmolStr, cid: SmolStr, name: Option<SmolStr>) -> Result<()> {

crates/weaver-app/src/fetch.rs

···
 use std::{sync::Arc, time::Duration};
 use weaver_api::{
     com_atproto::repo::strong_ref::StrongRef,
-    sh_weaver::notebook::{entry::Entry, BookEntryView, NotebookView},
+    sh_weaver::{
+        actor::ProfileDataView,
+        notebook::{entry::Entry, BookEntryView, NotebookView},
+    },
 };
 use weaver_common::WeaverExt;
 
···
         (AtIdentifier<'static>, SmolStr),
         Arc<(BookEntryView<'static>, Entry<'static>)>,
     >,
+    profile_cache: cache_impl::Cache<AtIdentifier<'static>, Arc<ProfileDataView<'static>>>,
 }
 
 impl CachedFetcher {
···
             client,
             book_cache: cache_impl::new_cache(100, Duration::from_secs(1200)),
             entry_cache: cache_impl::new_cache(100, Duration::from_secs(600)),
+            profile_cache: cache_impl::new_cache(100, Duration::from_secs(1800)),
         }
     }
 
···
         } else {
             Ok(None)
         }
+    }
+
+    pub async fn fetch_profile(
+        &self,
+        ident: &AtIdentifier<'_>,
+    ) -> Result<Arc<ProfileDataView<'static>>> {
+        use jacquard::IntoStatic;
+
+        let ident_static = ident.clone().into_static();
+
+        if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
+            return Ok(cached);
+        }
+
+        let did = match ident {
+            AtIdentifier::Did(d) => d.clone(),
+            AtIdentifier::Handle(h) => self
+                .client
+                .resolve_handle(h)
+                .await
+                .map_err(|e| dioxus::CapturedError::from_display(e))?,
+        };
+
+        let (_uri, profile_view) = self
+            .client
+            .hydrate_profile_view(&did)
+            .await
+            .map_err(|e| dioxus::CapturedError::from_display(e))?;
+
+        let result = Arc::new(profile_view);
+        cache_impl::insert(&self.profile_cache, ident_static, result.clone());
+
+        Ok(result)
     }
 }

crates/weaver-common/src/agent.rs

···
                 .maybe_description(weaver_record.value.description.clone())
                 .maybe_avatar(avatar)
                 .maybe_banner(banner)
+                .maybe_bluesky(weaver_record.value.bluesky)
+                .maybe_tangled(weaver_record.value.tangled)
+                .maybe_streamplace(weaver_record.value.streamplace)
                 .maybe_location(weaver_record.value.location.clone())
                 .maybe_links(weaver_record.value.links.clone())
                 .maybe_pronouns(weaver_record.value.pronouns.clone())

lexicons/actor/defs.json

···
           "type": "ref",
           "ref": "#pinnedList"
         },
+        "bluesky": {
+          "type": "boolean",
+          "description": "Include link to this account on Bluesky."
+        },
+        "tangled": {
+          "type": "boolean",
+          "description": "Include link to this account on Tangled."
+        },
+        "streamplace": {
+          "type": "boolean",
+          "description": "Include link to this account on stream.place."
+        },
         "labels": {
           "type": "array",
           "items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
···
       "properties": {
         "did": { "type": "string", "format": "did" },
         "signature": {
-          "type": "bytes"
+          "type": "bytes",
           "description": "signed bytes of the corresponding notebook record in the author's repo"
         }
       }