fonts and css tweaks

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

···
     grid-template-columns: 1fr auto;
     grid-template-rows: auto auto 1fr;
     height: 100%;
-    max-width: 1200px;
+    max-width: calc(95ch + 100px);
     margin: 0 auto;
     padding: 0 20px;
     font-family: var(--font-body);
···
     border-bottom: 2px solid var(--color-border);
     background: transparent;
     color: var(--color-text);
-    font-family: var(--font-body);
+    font-family: var(--font-heading);
     font-size: 24px;
     font-weight: 500;
     outline: none;
···
     border-radius: 12px;
     background: transparent;
     color: var(--color-text);
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
     font-size: 13px;
     min-width: 80px;
 }
···
     color: var(--color-text);
     cursor: pointer;
     font-size: 0.9rem;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .report-bug-button:hover {
···
     border-radius: 4px;
     background: var(--color-base);
     color: var(--color-text);
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
     resize: vertical;
 }
 
···
     border-radius: 4px;
     color: var(--color-text);
     cursor: pointer;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .report-cancel:hover {
···
     color: var(--color-base);
     cursor: pointer;
     font-weight: 500;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .report-submit:hover {
···
     color: var(--color-base);
     cursor: pointer;
     font-weight: 500;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .publish-button:hover:not(:disabled) {
···
     border-radius: 4px;
     background: var(--color-base);
     color: var(--color-text);
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
     font-size: 14px;
     box-sizing: border-box;
 }
···
     border-radius: 4px;
     color: var(--color-base);
     cursor: pointer;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .publish-actions {
···
     border-radius: 4px;
     color: var(--color-text);
     cursor: pointer;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .publish-cancel:hover:not(:disabled) {
···
     color: var(--color-base);
     cursor: pointer;
     font-weight: 500;
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
 }
 
 .publish-submit:hover:not(:disabled) {
···
     border-radius: 4px;
     background: var(--color-base);
     color: var(--color-text);
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
     resize: vertical;
 }
 

crates/weaver-app/assets/styling/entry-card.css

···
 /* Notebook layout - sidebar in left gutter on desktop, header on mobile */
 .notebook-layout {
     display: grid;
-    grid-template-columns: minmax(280px, 1fr) minmax(0, 90ch) minmax(280px, 1fr);
+    grid-template-columns: minmax(280px, 1fr) minmax(0, 90rem) minmax(280px, 1fr);
     gap: 2rem;
-    max-width: calc(90ch + 560px + 4rem); /* content + gutters + gaps */
+    max-width: calc(90rem + 560px + 4rem); /* content + gutters + gaps */
     margin: 0 auto;
     padding: 2.5rem 1.25rem 2.5rem 0;
 }
···
 /* Mobile layout - sidebar becomes header */
 @media (max-width: 1400px) {
     .notebook-layout {
-        grid-template-columns: minmax(1rem, 1fr) minmax(0, 90ch) minmax(1rem, 1fr) !important;
+        grid-template-columns: minmax(1rem, 1fr) minmax(0, 90rem) minmax(1rem, 1fr) !important;
         gap: 0 !important;
         max-width: 100vw !important;
         box-sizing: border-box !important;
···
 .entry-card-preview {
     margin-top: 0.5rem;
     color: var(--color-subtle);
+    font-family: var(--font-body);
     font-size: 0.875rem;
     line-height: 1.5;
     display: -webkit-box;
···
 .entry-card-preview h6 {
     font-size: 0.875rem;
     font-weight: 600;
-    margin: 0.5rem 0;
+    margin-top: 0.5rem;
+    margin-left: 0;
+    margin-right: 0;
 }
 
 .entry-card-preview p {

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

···
 /* Entry page layout with gutter navigation */
 .entry-page-layout {
     display: grid;
-    grid-template-columns: minmax(200px, 1fr) minmax(0, 90ch) minmax(200px, 1fr);
+    grid-template-columns: minmax(200px, 1fr) minmax(0, 95ch) minmax(200px, 1fr);
     gap: 2rem;
     width: 100%;
     min-height: 100vh;
     background: var(--color-base);
-    max-width: calc(90ch + 400px + 4rem); /* content + gutters + gaps */
+    max-width: calc(95ch + 400px + 4rem); /* content + gutters + gaps */
     margin: 0 auto;
     padding: 0 1rem 0 0;
     box-sizing: border-box;
···
 .entry-tags {
     display: flex;
     align-items: center;
+    font-family: var(--font-ui);
     gap: 0.5rem;
 }
 

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

···
 body {
     background-color: var(--color-base);
     color: var(--color-text);
-    font-family: var(--font-body);
+    font-family: var(--font-ui);
+}
+
+a {
+    color: var(--color-link);
+    text-decoration: none;
 }
 
 #header {
···
     transition: border-color 0.2s;
 }
 
+.notebook-content {
+    width: 100%;
+    max-width: 95ch;
+}
+
 .uri-input:focus {
     border-color: var(--color-primary);
 }
···
     color: var(--color-subtle);
     opacity: 0.5;
 }
-
-a {{
-    color: var(--color-link);
-    text-decoration: none;
-}}
-
 
 @font-face {
     font-family: "Ioskeley Mono";

crates/weaver-app/assets/styling/notebook-card.css

···
 
 .repository-layout {
     display: grid;
-    grid-template-columns: minmax(240px, 1fr) minmax(0, 90ch) minmax(240px, 1fr);
-    gap: 2rem;
-    max-width: calc(90ch + 480px + 4rem); /* content + gutters + gaps */
+    grid-template-columns: minmax(240px, 1fr) minmax(0, 95ch) minmax(240px, 1fr);
+    gap: 1rem;
+    max-width: calc(95ch + 480px + 4rem); /* content + gutters + gaps */
     margin: 0 auto;
     padding: 2.25rem 1.25rem 2.25rem 0;
 }
···
 /* Mobile layout - sidebar becomes header */
 @media (max-width: 1400px) {
     .repository-layout {
-        grid-template-columns: minmax(1rem, 1fr) minmax(0, 90ch) minmax(1rem, 1fr) !important;
+        grid-template-columns: minmax(1rem, 1fr) minmax(0, 95ch) minmax(1rem, 1fr) !important;
         gap: 0 !important;
         max-width: 100vw !important;
         box-sizing: border-box !important;
···
     color: var(--color-base);
 }
 
+.notebook-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+.notebook-header-actions .button {
+    font-size: 0.85rem;
+    color: var(--color-primary);
+    background: transparent;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0;
+    border: 1px solid var(--color-border);
+    transition:
+        background-color 0.15s ease,
+        color 0.15s ease;
+}
+
+.notebook-header-actions .button:hover {
+    background-color: var(--color-primary);
+    color: var(--color-base);
+}
+
 .notebook-actions {
-    margin-bottom: 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+.notebook-actions-dropdown {
+    position: relative;
+}
+
+.notebook-action-link {
+    text-decoration: none;
+}
+
+.notebook-actions .button {
+    font-size: 0.85rem;
+    color: var(--color-primary);
+    background: transparent;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0;
+    border: 1px solid var(--color-border);
+    transition:
+        background-color 0.15s ease,
+        color 0.15s ease;
+}
+
+.notebook-actions .button:hover {
+    background-color: var(--color-primary);
+    color: var(--color-base);
 }
 
 .notebook-card-title {
···
 .notebook-card-date {
     color: var(--color-muted);
     font-size: 0.85rem;
+    margin-left: 0.25rem;
 }
 
 .notebook-card-authors {
···
 
 .entry-preview-content {
     color: var(--color-subtle);
+    font-family: var(--font-body);
     font-size: 0.875rem;
     line-height: 1.5;
     display: -webkit-box;
···
 .entry-preview-content h6 {
     font-size: 0.875rem;
     font-weight: 600;
-    margin: 0;
+    margin-top: 0;
+    margin-left: 0;
+    margin-right: 0;
 }
 
 .entry-preview-content code {
···
 .notebook-card-preview {
     margin-top: 0.75rem;
     color: var(--color-subtle);
+    font-family: var(--font-body);
     font-size: 0.9rem;
     line-height: 1.5;
     display: -webkit-box;
···
 @media (prefers-color-scheme: dark) {
     .notebook-card-container {
         box-shadow: none;
-        border: 1px dashed var(--color-border);
+        border: 1px solid var(--color-border);
     }
 }

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

···
     width: 100%;
     height: 100%;
     object-fit: cover;
+    margin: 0;
+    border-radius: 0;
 }
 
 .profile-content {
···
 .profile-stats {
     display: grid;
     grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
-    gap: 1.25rem;
+    gap: 0.25rem;
     padding: 1.25rem 0;
     margin: 1.25rem 0;
     border-top: 1.5px dashed var(--color-border);
···
 @media (prefers-color-scheme: dark) {
     .profile-display {
         background-color: var(--color-surface);
-        border: 1px dashed var(--color-border);
+        border: 1px solid var(--color-border);
     }
 }
 
 /* Desktop: sidebar gets top and right borders */
 @media (min-width: 1400px) {
     .profile-display {
-        border-top: 1.5px dashed var(--color-border);
-        border-right: 1.5px dashed var(--color-border);
+        border-top: 1.5px solid var(--color-border);
+        border-right: 1.5px solid var(--color-border);
     }
 }

crates/weaver-app/assets/styling/theme-defaults.css

···
 /* Default theme variables for non-notebook pages */
 /* These match the Rose Pine light/dark defaults */
 
+/* ==========================================================================
+   FONT FACES
+   Note: Dioxus serves all assets from /assets/ regardless of subdirectory
+   ========================================================================== */
+
+/* --- Ioskeley Mono (monospace) --- */
 @font-face {
     font-family: "Ioskeley Mono";
     font-style: normal;
···
     src: url("/assets/IoskeleyMono-BoldItalic.woff2") format("woff2");
 }
 
-/* CSS Variables - Light Mode (default) */
+/* --- Adobe Caslon Pro (serif) --- */
+@font-face {
+    font-family: "Adobe Caslon Pro";
+    font-style: normal;
+    font-weight: normal;
+    src: url("/assets/AdobeCaslonPro-Regular.ttf") format("truetype");
+}
+
+@font-face {
+    font-family: "Adobe Caslon Pro";
+    font-style: normal;
+    font-weight: bold;
+    src: url("/assets/AdobeCaslonPro-Semibold.ttf") format("truetype");
+}
+
+@font-face {
+    font-family: "Adobe Caslon Pro";
+    font-style: italic;
+    font-weight: normal;
+    src: url("/assets/AdobeCaslonPro-Italic.ttf") format("truetype");
+}
+
+@font-face {
+    font-family: "Adobe Caslon Pro";
+    font-style: italic;
+    font-weight: bold;
+    src: url("/assets/AdobeCaslonPro-BoldItalic.ttf") format("truetype");
+}
+
+/* --- Latin Modern Roman (serif) --- */
+@font-face {
+    font-family: "Latin Modern Roman";
+    font-style: normal;
+    font-weight: normal;
+    src: url("/assets/LatinModernRoman-Regular.otf") format("opentype");
+}
+@font-face {
+    font-family: "Latin Modern Roman";
+    font-style: normal;
+    font-weight: bold;
+    src: url("/assets/LatinModernRoman-Bold.otf") format("opentype");
+}
+@font-face {
+    font-family: "Latin Modern Roman";
+    font-style: italic;
+    font-weight: normal;
+    src: url("/assets/LatinModernRoman-Italic.otf") format("opentype");
+}
+@font-face {
+    font-family: "Latin Modern Roman";
+    font-style: italic;
+    font-weight: bold;
+    src: url("/assets/LatinModernRoman-BoldItalic.otf") format("opentype");
+}
+
+/* --- Computer Modern Serif --- */
+@font-face {
+    font-family: "CM Serif";
+    font-style: normal;
+    font-weight: normal;
+    src: url("/assets/CMSerif-Regular.woff") format("woff");
+}
+@font-face {
+    font-family: "CM Serif";
+    font-style: normal;
+    font-weight: bold;
+    src: url("/assets/CMSerif-Bold.woff") format("woff");
+}
+@font-face {
+    font-family: "CM Serif";
+    font-style: italic;
+    font-weight: normal;
+    src: url("/assets/CMSerif-Italic.woff") format("woff");
+}
+@font-face {
+    font-family: "CM Serif";
+    font-style: italic;
+    font-weight: bold;
+    src: url("/assets/CMSerif-BoldItalic.woff") format("woff");
+}
+
+/* --- Computer Modern Sans --- */
+@font-face {
+    font-family: "CM Sans";
+    font-style: normal;
+    font-weight: normal;
+    src: url("/assets/CMSans-Regular.woff") format("woff");
+}
+@font-face {
+    font-family: "CM Sans";
+    font-style: normal;
+    font-weight: bold;
+    src: url("/assets/CMSans-Bold.woff") format("woff");
+}
+@font-face {
+    font-family: "CM Sans";
+    font-style: italic;
+    font-weight: normal;
+    src: url("/assets/CMSans-Italic.woff") format("woff");
+}
+@font-face {
+    font-family: "CM Sans";
+    font-style: italic;
+    font-weight: bold;
+    src: url("/assets/CMSans-BoldItalic.woff") format("woff");
+}
+
+/* --- Junction (geometric sans) --- */
+@font-face {
+    font-family: "Junction";
+    font-style: normal;
+    font-weight: 300;
+    src: url("/assets/Junction-Light.woff") format("woff");
+}
+@font-face {
+    font-family: "Junction";
+    font-style: normal;
+    font-weight: normal;
+    src: url("/assets/Junction-Regular.woff") format("woff");
+}
+@font-face {
+    font-family: "Junction";
+    font-style: normal;
+    font-weight: bold;
+    src: url("/assets/Junction-Bold.woff") format("woff");
+}
+
+/* --- Proza Libre (humanist sans) --- */
+@font-face {
+    font-family: "Proza Libre";
+    font-style: normal;
+    font-weight: normal;
+    src: url("/assets/ProzaLibre-Regular.woff2") format("woff2");
+}
+@font-face {
+    font-family: "Proza Libre";
+    font-style: italic;
+    font-weight: normal;
+    src: url("/assets/ProzaLibre-Italic.woff2") format("woff2");
+}
+@font-face {
+    font-family: "Proza Libre";
+    font-style: normal;
+    font-weight: 500;
+    src: url("/assets/ProzaLibre-Medium.woff2") format("woff2");
+}
+@font-face {
+    font-family: "Proza Libre";
+    font-style: normal;
+    font-weight: 600;
+    src: url("/assets/ProzaLibre-SemiBold.woff2") format("woff2");
+}
+@font-face {
+    font-family: "Proza Libre";
+    font-style: normal;
+    font-weight: bold;
+    src: url("/assets/ProzaLibre-Bold.woff2") format("woff2");
+}
+@font-face {
+    font-family: "Proza Libre";
+    font-style: italic;
+    font-weight: bold;
+    src: url("/assets/ProzaLibre-BoldItalic.woff2") format("woff2");
+}
+
+/* ==========================================================================
+   CSS VARIABLES - LIGHT MODE
+
+   CONTRAST OPTIONS: Uncomment ONE of the following sections
+   - ORIGINAL: Rose Pine Dawn defaults (soft, low contrast)
+   - MILD: ~25% darker text, subtle improvement
+   - MODERATE: ~40% darker text, noticeably better contrast
+   ========================================================================== */
+
+/* --- ORIGINAL ROSE PINE DAWN (uncomment to restore) ---
 :root {
     --color-base: #faf4ed;
     --color-surface: #fffaf3;
···
     --color-link: #d7827e;
     --color-highlight: #cecacd;
 
-    --font-body: "IBM Plex", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-    --font-heading: "IBM Plex Sans", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-    --font-mono: "Ioskeley Mono", "IBM Plex Mono", "Berkeley Mono", "Cascadia Code", "Roboto Mono", Consolas, monospace;
+    --font-ui: "Proza Libre", "Junction", system-ui, -apple-system, sans-serif;
+    --font-body: "IBM Plex Sans", system-ui, sans-serif;
+    --font-heading: "IBM Plex Sans", system-ui, sans-serif;
+    --font-mono: "Ioskeley Mono", "IBM Plex Mono", Consolas, monospace;
+
+    --spacing-base: 16px;
+    --spacing-line-height: 1.6;
+    --spacing-scale: 1.25;
+}
+*/
+
+/* --- MILD CONTRAST (uncomment to use) ---
+:root {
+    --color-base: #faf4ed;
+    --color-surface: #fffaf3;
+    --color-overlay: #f2e9e1;
+    --color-text: #453f5c;
+    --color-muted: #7a7589;
+    --color-subtle: #5f5a73;
+    --color-emphasis: #2d2a3d;
+    --color-primary: #907aa9;
+    --color-secondary: #56949f;
+    --color-tertiary: #286983;
+    --color-error: #b4637a;
+    --color-warning: #ea9d34;
+    --color-success: #286983;
+    --color-border: #908caa;
+    --color-link: #d7827e;
+    --color-highlight: #cecacd;
+
+    --font-ui: "Proza Libre", "Junction", system-ui, -apple-system, sans-serif;
+    --font-body: "Latin Modern Roman", "Adobe Caslon Pro", "CM Serif", Georgia, serif;
+    --font-heading: "Proza Libre", "Junction", "CM Sans", system-ui, sans-serif;
+    --font-mono: "Ioskeley Mono", "IBM Plex Mono", "Berkeley Mono", Consolas, monospace;
+
+    --spacing-base: 16px;
+    --spacing-line-height: 1.6;
+    --spacing-scale: 1.25;
+}
+*/
+
+/* --- MODERATE CONTRAST (active) --- */
+:root {
+    --color-base: #faf4ed;
+    --color-surface: #fffaf3;
+    --color-overlay: #f2e9e1;
+    /* Text colors darkened for better contrast */
+    --color-text: #1f1d2e;
+    --color-muted: #635e74;
+    --color-subtle: #4a4560;
+    --color-emphasis: #1e1a2d;
+    /* Accent colors kept at original Rose Pine Dawn values */
+    --color-primary: #907aa9;
+    --color-secondary: #56949f;
+    --color-tertiary: #286983;
+    --color-error: #b4637a;
+    --color-warning: #ea9d34;
+    --color-success: #286983;
+    --color-border: #908caa;
+    --color-link: #d7827e;
+    --color-highlight: #cecacd;
+
+    /* UI FONT - Fixed sans stack for all UI elements (buttons, nav, labels, etc.)
+       This does NOT follow theme - keeps UI consistent across all content themes */
+    --font-ui: "CM Sans", "Junction", "Proza Libre", system-ui, -apple-system, sans-serif;
+
+    /* CONTENT FONT STACKS - Edit these to try different combinations
+       Sans options: "Proza Libre", "Junction", "CM Sans", "IBM Plex Sans"
+       Serif options: "Latin Modern Roman", "Adobe Caslon Pro", "CM Serif"
+    */
+    --font-body: "Adobe Caslon Pro", "Latin Modern Roman", "CM Serif", Georgia, serif;
+    --font-heading: "IBM Plex Sans", "CM Sans", "Junction", "Proza Libre", system-ui, sans-serif;
+    --font-mono: "Ioskeley Mono", "IBM Plex Mono", "Berkeley Mono", Consolas, monospace;
 
     --spacing-base: 16px;
     --spacing-line-height: 1.6;

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

···
                     if is_owner {
                         EntryActions {
                             entry_uri,
+                            entry_cid: entry_view.cid.clone().into_static(),
                             entry_title: title.to_string(),
                             in_notebook: true,
                             notebook_title: Some(book_title.clone()),
···
 /// Card for entries in a feed (e.g., home page)
 /// Takes EntryView directly (not BookEntryView) and always shows author info
 #[component]
-pub fn FeedEntryCard(entry_view: EntryView<'static>, entry: entry::Entry<'static>) -> Element {
+pub fn FeedEntryCard(
+    entry_view: EntryView<'static>,
+    entry: entry::Entry<'static>,
+    #[props(default = false)] show_actions: bool,
+    #[props(default = false)] is_pinned: bool,
+    #[props(default)] on_pinned_changed: Option<EventHandler<bool>>,
+) -> Element {
     use crate::Route;
+    use crate::auth::AuthState;
     use jacquard::from_data;
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 
···
     // Get first author
     let first_author = entry_view.authors.first();
 
+    // Check ownership for actions
+    let auth_state = use_context::<Signal<AuthState>>();
+    let is_owner = {
+        let current_did = auth_state.read().did.clone();
+        match (&current_did, &ident) {
+            (Some(did), AtIdentifier::Did(ident_did)) => *did == *ident_did,
+            _ => false,
+        }
+    };
+
     // Render preview from truncated entry content
     let preview_html = {
         let parser = markdown_weaver::Parser::new(&entry.content);
···
                 div { class: "entry-card-date",
                     time { datetime: "{entry.created_at.as_str()}", "{formatted_date}" }
                 }
+                if show_actions && is_owner {
+                    crate::components::EntryActions {
+                        entry_uri: entry_view.uri.clone().into_static(),
+                        entry_cid: entry_view.cid.clone().into_static(),
+                        entry_title: title.to_string(),
+                        in_notebook: false,
+                        is_pinned,
+                        on_pinned_changed
+                    }
+                }
             }
 
             div { class: "entry-card-preview", dangerous_inner_html: "{preview_html}" }
···
                 h1 { class: "entry-title", "{title}" }
                 EntryActions {
                     entry_uri: entry_uri.clone(),
+                    entry_cid: entry_view.cid.clone().into_static(),
                     entry_title,
                     in_notebook: book_title.is_some(),
                     notebook_title: book_title.clone(),

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

···
-//! Action buttons for entries (edit, delete, remove from notebook).
+//! Action buttons for entries (edit, delete, remove from notebook, pin/unpin).
 
 use crate::Route;
 use crate::auth::AuthState;
···
 use jacquard::smol_str::SmolStr;
 use jacquard::types::aturi::AtUri;
 use jacquard::types::ident::AtIdentifier;
+use jacquard::types::string::Cid;
 use jacquard::IntoStatic;
 use weaver_api::com_atproto::repo::delete_record::DeleteRecord;
 use weaver_api::com_atproto::repo::put_record::PutRecord;
+use weaver_api::com_atproto::repo::strong_ref::StrongRef;
+use weaver_api::sh_weaver::actor::profile::Profile as WeaverProfile;
 
 const ENTRY_ACTIONS_CSS: Asset = asset!("/assets/styling/entry-actions.css");
 
···
 pub struct EntryActionsProps {
     /// The AT-URI of the entry
     pub entry_uri: AtUri<'static>,
+    /// The CID of the entry (for StrongRef when pinning)
+    pub entry_cid: Cid<'static>,
     /// The entry title (for display in confirmation)
     pub entry_title: String,
     /// Whether this entry is in a notebook (enables "remove from notebook")
···
     /// Notebook title (if in_notebook is true, used for edit route)
     #[props(default)]
     pub notebook_title: Option<SmolStr>,
+    /// Whether this entry is currently pinned
+    #[props(default = false)]
+    pub is_pinned: bool,
     /// Callback when entry is removed from notebook (for optimistic UI update)
     #[props(default)]
     pub on_removed: Option<EventHandler<()>>,
+    /// Callback when pin state changes
+    #[props(default)]
+    pub on_pinned_changed: Option<EventHandler<bool>>,
 }
 
 /// Action buttons for an entry: edit, delete, optionally remove from notebook.
···
     let mut show_dropdown = use_signal(|| false);
     let mut deleting = use_signal(|| false);
     let mut removing = use_signal(|| false);
+    let mut pinning = use_signal(|| false);
     let mut error = use_signal(|| None::<String>);
 
     // Check ownership - compare auth DID with entry's authority
···
     let entry_uri_for_remove = props.entry_uri.clone();
     let notebook_title_for_remove = props.notebook_title.clone();
     let on_removed = props.on_removed.clone();
+    let remove_fetcher = fetcher.clone();
     let handle_remove_from_notebook = move |_| {
-        let fetcher = fetcher.clone();
+        let fetcher = remove_fetcher.clone();
         let entry_uri = entry_uri_for_remove.clone();
         let notebook_title = notebook_title_for_remove.clone();
         let on_removed = on_removed.clone();
···
         });
     };
 
+    // Handler for pinning/unpinning
+    let entry_uri_for_pin = props.entry_uri.clone();
+    let entry_cid_for_pin = props.entry_cid.clone();
+    let is_currently_pinned = props.is_pinned;
+    let on_pinned_changed = props.on_pinned_changed.clone();
+    let pin_fetcher = fetcher.clone();
+    let handle_pin_toggle = move |_| {
+        let fetcher = pin_fetcher.clone();
+        let entry_uri = entry_uri_for_pin.clone();
+        let entry_cid = entry_cid_for_pin.clone();
+        let on_pinned_changed = on_pinned_changed.clone();
+
+        spawn(async move {
+            use jacquard::{from_data, prelude::*, to_data, types::string::Nsid};
+            use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+
+            pinning.set(true);
+            error.set(None);
+
+            let client = fetcher.get_client();
+
+            let did = match fetcher.current_did().await {
+                Some(d) => d,
+                None => {
+                    error.set(Some("Not authenticated".to_string()));
+                    pinning.set(false);
+                    return;
+                }
+            };
+
+            let profile_uri_str = format!("at://{}/sh.weaver.actor.profile/self", did);
+
+            // Try to fetch existing weaver profile
+            let weaver_uri = match WeaverProfile::uri(&profile_uri_str) {
+                Ok(u) => u,
+                Err(_) => {
+                    error.set(Some("Invalid profile URI".to_string()));
+                    pinning.set(false);
+                    return;
+                }
+            };
+            let existing_profile: Option<WeaverProfile<'static>> =
+                match client.fetch_record(&weaver_uri).await {
+                    Ok(output) => Some(output.value),
+                    Err(_) => None,
+                };
+
+            // Build the new pinned list
+            let new_pinned: Vec<StrongRef<'static>> = if is_currently_pinned {
+                // Unpin: remove from list
+                existing_profile
+                    .as_ref()
+                    .and_then(|p| p.pinned.as_ref())
+                    .map(|pins| {
+                        pins.iter()
+                            .filter(|r| r.uri.as_ref() != entry_uri.as_ref())
+                            .cloned()
+                            .collect()
+                    })
+                    .unwrap_or_default()
+            } else {
+                // Pin: add to list
+                let new_ref = StrongRef::new()
+                    .uri(entry_uri.clone().into_static())
+                    .cid(entry_cid.clone())
+                    .build();
+                let mut pins = existing_profile
+                    .as_ref()
+                    .and_then(|p| p.pinned.clone())
+                    .unwrap_or_default();
+                // Don't add if already exists
+                if !pins.iter().any(|r| r.uri.as_ref() == entry_uri.as_ref()) {
+                    pins.push(new_ref);
+                }
+                pins
+            };
+
+            // Build the profile to save
+            let profile_to_save = if let Some(existing) = existing_profile {
+                // Update existing profile
+                WeaverProfile {
+                    pinned: Some(new_pinned),
+                    ..existing
+                }
+            } else {
+                // Create new profile from bsky data
+                let bsky_uri_str = format!("at://{}/app.bsky.actor.profile/self", did);
+                let bsky_profile: Option<BskyProfile<'static>> =
+                    match BskyProfile::uri(&bsky_uri_str) {
+                        Ok(bsky_uri) => match client.fetch_record(&bsky_uri).await {
+                            Ok(output) => Some(output.value),
+                            Err(_) => None,
+                        },
+                        Err(_) => None,
+                    };
+
+                WeaverProfile::new()
+                    .maybe_display_name(
+                        bsky_profile
+                            .as_ref()
+                            .and_then(|p| p.display_name.clone()),
+                    )
+                    .maybe_description(
+                        bsky_profile.as_ref().and_then(|p| p.description.clone()),
+                    )
+                    .maybe_avatar(bsky_profile.as_ref().and_then(|p| p.avatar.clone()))
+                    .maybe_banner(bsky_profile.as_ref().and_then(|p| p.banner.clone()))
+                    .bluesky(true)
+                    .created_at(jacquard::types::string::Datetime::now())
+                    .pinned(new_pinned)
+                    .build()
+            };
+
+            // Serialize and save
+            let profile_data = match to_data(&profile_to_save) {
+                Ok(d) => d,
+                Err(e) => {
+                    error.set(Some(format!("Failed to serialize profile: {:?}", e)));
+                    pinning.set(false);
+                    return;
+                }
+            };
+
+            let request = PutRecord::new()
+                .repo(AtIdentifier::Did(did))
+                .collection(Nsid::new_static("sh.weaver.actor.profile").unwrap())
+                .rkey(jacquard::types::string::Rkey::new("self").unwrap())
+                .record(profile_data)
+                .build();
+
+            match client.send(request).await {
+                Ok(_) => {
+                    show_dropdown.set(false);
+                    if let Some(handler) = &on_pinned_changed {
+                        handler.call(!is_currently_pinned);
+                    }
+                }
+                Err(e) => {
+                    error.set(Some(format!("Failed to update profile: {:?}", e)));
+                }
+            }
+            pinning.set(false);
+        });
+    };
+
     rsx! {
         document::Link { rel: "stylesheet", href: ENTRY_ACTIONS_CSS }
 
···
 
                 if show_dropdown() {
                     div { class: "dropdown-menu",
+                        // Pin/Unpin (first)
+                        button {
+                            class: "dropdown-item",
+                            disabled: pinning(),
+                            onclick: handle_pin_toggle,
+                            if pinning() {
+                                "Updating..."
+                            } else if props.is_pinned {
+                                "Unpin"
+                            } else {
+                                "Pin"
+                            }
+                        }
+                        // Remove from notebook (if in notebook)
                         if props.in_notebook {
                             button {
                                 class: "dropdown-item",
···
                                 "Remove from notebook"
                             }
                         }
+                        // Delete (last, danger style)
                         button {
                             class: "dropdown-item dropdown-item-danger",
                             onclick: move |_| {

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

···
 use crate::auth::AuthState;
+use crate::components::css::DefaultNotebookCss;
 use crate::components::{FeedEntryCard, ProfileActions, ProfileActionsMenubar};
 use crate::{Route, data, fetch};
 use dioxus::prelude::*;
···
 }
 
 const NOTEBOOK_CARD_CSS: Asset = asset!("/assets/styling/notebook-card.css");
+const ENTRY_CSS: Asset = asset!("/assets/styling/entry.css");
+const ENTRY_CARD_CSS: Asset = asset!("/assets/styling/entry-card.css");
 
 #[component]
 pub fn Repository(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
     rsx! {
+        DefaultNotebookCss {  }
+        document::Link { rel: "stylesheet", href: NOTEBOOK_CARD_CSS }
+        document::Link { rel: "stylesheet", href: ENTRY_CSS }
+        document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
         div {
             Outlet::<Route> {}
         }
···
     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?;
+    // Use client-only versions to avoid SSR issues with concurrent server futures
+    let (_profile_res, profile) = data::use_profile_data_client(ident);
+    let (_notebooks_res, notebooks) = data::use_notebooks_for_did_client(ident);
+    let (_entries_res, all_entries) = data::use_entries_for_did_client(ident);
 
     // Extract pinned URIs from profile (only Weaver ProfileView has pinned)
     let pinned_uris = use_memo(move || {
···
                                                             class: "pinned-item",
                                                             NotebookCard {
                                                                 notebook: notebook.clone(),
-                                                                entry_refs: entries.clone()
+                                                                entry_refs: entries.clone(),
+                                                                is_pinned: true
                                                             }
                                                         }
                                                     }
···
                                                             class: "pinned-item standalone-entry-item",
                                                             FeedEntryCard {
                                                                 entry_view: entry_view.clone(),
-                                                                entry: entry.clone()
+                                                                entry: entry.clone(),
+                                                                show_actions: true,
+                                                                is_pinned: true
                                                             }
                                                         }
                                                     }
···
                                                         key: "notebook-{notebook.cid}",
                                                         NotebookCard {
                                                             notebook: notebook.clone(),
-                                                            entry_refs: entries.clone()
+                                                            entry_refs: entries.clone(),
+                                                            is_pinned: false
                                                         }
                                                     }
                                                 }
···
                                                         class: "standalone-entry-item",
                                                         FeedEntryCard {
                                                             entry_view: entry_view.clone(),
-                                                            entry: entry.clone()
+                                                            entry: entry.clone(),
+                                                            show_actions: true,
+                                                            is_pinned: false
                                                         }
                                                     }
                                                 }
···
 pub fn NotebookCard(
     notebook: NotebookView<'static>,
     entry_refs: Vec<StrongRef<'static>>,
+    #[props(default = false)] is_pinned: bool,
+    #[props(default)] on_pinned_changed: Option<EventHandler<bool>>,
+    #[props(default)] on_deleted: Option<EventHandler<()>>,
 ) -> Element {
     use jacquard::{IntoStatic, from_data};
     use weaver_api::sh_weaver::notebook::book::Book;
···
         div { class: "notebook-card",
             div { class: "notebook-card-container",
 
-                Link {
-                    to: Route::EntryPage {
-                        ident: ident.clone(),
-                        book_title: notebook_path.clone().into(),
-                        title: "".into() // Will redirect to first entry
-                    },
-                    class: "notebook-card-header-link",
-
-                    div { class: "notebook-card-header",
-                        div { class: "notebook-card-header-top",
+                div { class: "notebook-card-header",
+                    div { class: "notebook-card-header-top",
+                        Link {
+                            to: Route::EntryPage {
+                                ident: ident.clone(),
+                                book_title: notebook_path.clone().into(),
+                                title: "".into() // Will redirect to first entry
+                            },
+                            class: "notebook-card-header-link",
                             h2 { class: "notebook-card-title", "{title}" }
-                            if is_owner {
+                        }
+                        if is_owner {
+                            div { class: "notebook-header-actions",
                                 Link {
                                     to: Route::NewDraft { ident: notebook_ident.clone(), notebook: Some(book_title.clone()) },
-                                    class: "notebook-add-entry",
-                                    "+ Add"
+                                    class: "notebook-action-link",
+                                    crate::components::button::Button {
+                                        variant: crate::components::button::ButtonVariant::Ghost,
+                                        "Add"
+                                    }
+                                }
+                                crate::components::NotebookActions {
+                                    notebook_uri: notebook.uri.clone().into_static(),
+                                    notebook_cid: notebook.cid.clone().into_static(),
+                                    notebook_title: title.to_string(),
+                                    is_pinned,
+                                    on_pinned_changed,
+                                    on_deleted
                                 }
                             }
                         }
+                    }
 
-                        div { class: "notebook-card-date",
-                            time { datetime: "{notebook.indexed_at.as_str()}", "{formatted_date}" }
-                        }
+                    div { class: "notebook-card-date",
+                        time { datetime: "{notebook.indexed_at.as_str()}", "{formatted_date}" }
                     }
                 }
 
···
                                                         if is_owner {
                                                             crate::components::EntryActions {
                                                                 entry_uri,
+                                                                entry_cid: entry_view.entry.cid.clone().into_static(),
                                                                 entry_title: entry_title.to_string(),
                                                                 in_notebook: true,
                                                                 notebook_title: Some(book_title.clone())
···
                                                         if is_owner {
                                                             crate::components::EntryActions {
                                                                 entry_uri,
+                                                                entry_cid: first_entry.entry.cid.clone().into_static(),
                                                                 entry_title: entry_title.to_string(),
                                                                 in_notebook: true,
                                                                 notebook_title: Some(book_title.clone())
···
                                                         if is_owner {
                                                             crate::components::EntryActions {
                                                                 entry_uri,
+                                                                entry_cid: last_entry.entry.cid.clone().into_static(),
                                                                 entry_title: entry_title.to_string(),
                                                                 in_notebook: true,
                                                                 notebook_title: Some(book_title.clone())

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

···
         .with_hash_suffix(false)
         .into_asset_options()
 );
+
+// Adobe Caslon Pro
+#[used]
+static _CASLON_REG: Asset = asset!(
+    "/assets/fonts/adobe-caslon/AdobeCaslonPro-Regular.ttf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+#[used]
+static _CASLON_BOLD: Asset = asset!(
+    "/assets/fonts/adobe-caslon/AdobeCaslonPro-Bold.ttf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+#[used]
+static _CASLON_ITAL: Asset = asset!(
+    "/assets/fonts/adobe-caslon/AdobeCaslonPro-Italic.ttf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+#[used]
+static _CASLON_SEMIBOLD: Asset = asset!(
+    "/assets/fonts/adobe-caslon/AdobeCaslonPro-Semibold.ttf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+#[used]
+static _CASLON_ITAL_BOLD: Asset = asset!(
+    "/assets/fonts/adobe-caslon/AdobeCaslonPro-BoldItalic.ttf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+// Latin Modern Roman
+#[used]
+static _LM_REG: Asset = asset!(
+    "/assets/fonts/latin-modern/LatinModernRoman-Regular.otf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _LM_BOLD: Asset = asset!(
+    "/assets/fonts/latin-modern/LatinModernRoman-Bold.otf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _LM_ITAL: Asset = asset!(
+    "/assets/fonts/latin-modern/LatinModernRoman-Italic.otf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _LM_BOLD_ITAL: Asset = asset!(
+    "/assets/fonts/latin-modern/LatinModernRoman-BoldItalic.otf",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+// Computer Modern Serif
+#[used]
+static _CM_SERIF_REG: Asset = asset!(
+    "/assets/fonts/cm-serif/CMSerif-Regular.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _CM_SERIF_BOLD: Asset = asset!(
+    "/assets/fonts/cm-serif/CMSerif-Bold.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _CM_SERIF_ITAL: Asset = asset!(
+    "/assets/fonts/cm-serif/CMSerif-Italic.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _CM_SERIF_BOLD_ITAL: Asset = asset!(
+    "/assets/fonts/cm-serif/CMSerif-BoldItalic.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+// Computer Modern Sans
+#[used]
+static _CM_SANS_REG: Asset = asset!(
+    "/assets/fonts/cm-sans/CMSans-Regular.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _CM_SANS_BOLD: Asset = asset!(
+    "/assets/fonts/cm-sans/CMSans-Bold.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _CM_SANS_ITAL: Asset = asset!(
+    "/assets/fonts/cm-sans/CMSans-Italic.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _CM_SANS_BOLD_ITAL: Asset = asset!(
+    "/assets/fonts/cm-sans/CMSans-BoldItalic.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+// Junction
+#[used]
+static _JUNCTION_LIGHT: Asset = asset!(
+    "/assets/fonts/junction/Junction-Light.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _JUNCTION_REG: Asset = asset!(
+    "/assets/fonts/junction/Junction-Regular.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _JUNCTION_BOLD: Asset = asset!(
+    "/assets/fonts/junction/Junction-Bold.woff",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
+// Proza Libre
+#[used]
+static _PROZA_REG: Asset = asset!(
+    "/assets/fonts/proza-libre/ProzaLibre-Regular.woff2",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _PROZA_ITAL: Asset = asset!(
+    "/assets/fonts/proza-libre/ProzaLibre-Italic.woff2",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _PROZA_MEDIUM: Asset = asset!(
+    "/assets/fonts/proza-libre/ProzaLibre-Medium.woff2",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _PROZA_SEMIBOLD: Asset = asset!(
+    "/assets/fonts/proza-libre/ProzaLibre-SemiBold.woff2",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _PROZA_BOLD: Asset = asset!(
+    "/assets/fonts/proza-libre/ProzaLibre-Bold.woff2",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+#[used]
+static _PROZA_BOLD_ITAL: Asset = asset!(
+    "/assets/fonts/proza-libre/ProzaLibre-BoldItalic.woff2",
+    AssetOptions::builder()
+        .with_hash_suffix(false)
+        .into_asset_options()
+);
+
 pub mod accordion;
 pub mod button;
 pub mod dialog;
 pub mod editor;
 pub mod entry_actions;
 pub mod input;
+pub mod notebook_actions;
 pub mod profile_actions;
 
 pub use entry_actions::EntryActions;
+pub use notebook_actions::NotebookActions;
 pub use profile_actions::{ProfileActions, ProfileActionsMenubar};
 pub mod toast;

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

···
+//! Action buttons for notebooks (pin/unpin, delete).
+
+use crate::auth::AuthState;
+use crate::components::button::{Button, ButtonVariant};
+use crate::components::dialog::{DialogContent, DialogDescription, DialogRoot, DialogTitle};
+use crate::fetch::Fetcher;
+use dioxus::prelude::*;
+use jacquard::types::aturi::AtUri;
+use jacquard::types::ident::AtIdentifier;
+use jacquard::types::string::Cid;
+use jacquard::IntoStatic;
+use weaver_api::com_atproto::repo::delete_record::DeleteRecord;
+use weaver_api::com_atproto::repo::put_record::PutRecord;
+use weaver_api::com_atproto::repo::strong_ref::StrongRef;
+use weaver_api::sh_weaver::actor::profile::Profile as WeaverProfile;
+
+/// Action buttons for a notebook: pin/unpin, delete.
+#[component]
+pub fn NotebookActions(
+    notebook_uri: AtUri<'static>,
+    notebook_cid: Cid<'static>,
+    notebook_title: String,
+    #[props(default = false)] is_pinned: bool,
+    #[props(default)] on_deleted: Option<EventHandler<()>>,
+    #[props(default)] on_pinned_changed: Option<EventHandler<bool>>,
+) -> Element {
+    let auth_state = use_context::<Signal<AuthState>>();
+    let fetcher = use_context::<Fetcher>();
+
+    let mut show_delete_confirm = use_signal(|| false);
+    let mut show_dropdown = use_signal(|| false);
+    let mut deleting = use_signal(|| false);
+    let mut pinning = use_signal(|| false);
+    let mut error = use_signal(|| None::<String>);
+
+    // Check ownership - compare auth DID with notebook's authority
+    let current_did = auth_state.read().did.clone();
+    let notebook_authority = notebook_uri.authority();
+    let is_owner = match (&current_did, notebook_authority) {
+        (Some(current), AtIdentifier::Did(notebook_did)) => *current == *notebook_did,
+        _ => false,
+    };
+
+    if !is_owner {
+        return rsx! {};
+    }
+
+    let notebook_uri_for_delete = notebook_uri.clone();
+    let title_for_display = notebook_title.clone();
+    let on_deleted_handler = on_deleted.clone();
+
+    let delete_fetcher = fetcher.clone();
+    let handle_delete = move |_| {
+        let fetcher = delete_fetcher.clone();
+        let uri = notebook_uri_for_delete.clone();
+        let on_deleted = on_deleted_handler.clone();
+
+        spawn(async move {
+            use jacquard::prelude::*;
+
+            deleting.set(true);
+            error.set(None);
+
+            let client = fetcher.get_client();
+            let collection = uri.collection();
+            let rkey = uri.rkey();
+
+            if let (Some(collection), Some(rkey)) = (collection, rkey) {
+                let did = match fetcher.current_did().await {
+                    Some(d) => d,
+                    None => {
+                        error.set(Some("Not authenticated".to_string()));
+                        deleting.set(false);
+                        return;
+                    }
+                };
+
+                let request = DeleteRecord::new()
+                    .repo(AtIdentifier::Did(did))
+                    .collection(collection.clone())
+                    .rkey(rkey.clone())
+                    .build();
+
+                match client.send(request).await {
+                    Ok(_) => {
+                        show_delete_confirm.set(false);
+                        if let Some(handler) = &on_deleted {
+                            handler.call(());
+                        }
+                    }
+                    Err(e) => {
+                        error.set(Some(format!("Delete failed: {:?}", e)));
+                    }
+                }
+            } else {
+                error.set(Some("Invalid notebook URI".to_string()));
+            }
+            deleting.set(false);
+        });
+    };
+
+    // Handler for pinning/unpinning
+    let notebook_uri_for_pin = notebook_uri.clone();
+    let notebook_cid_for_pin = notebook_cid.clone();
+    let is_currently_pinned = is_pinned;
+    let on_pinned_changed_handler = on_pinned_changed.clone();
+    let pin_fetcher = fetcher.clone();
+    let handle_pin_toggle = move |_| {
+        let fetcher = pin_fetcher.clone();
+        let notebook_uri = notebook_uri_for_pin.clone();
+        let notebook_cid = notebook_cid_for_pin.clone();
+        let on_pinned_changed = on_pinned_changed_handler.clone();
+
+        spawn(async move {
+            use jacquard::{from_data, prelude::*, to_data, types::string::Nsid};
+            use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+
+            pinning.set(true);
+            error.set(None);
+
+            let client = fetcher.get_client();
+
+            let did = match fetcher.current_did().await {
+                Some(d) => d,
+                None => {
+                    error.set(Some("Not authenticated".to_string()));
+                    pinning.set(false);
+                    return;
+                }
+            };
+
+            let profile_uri_str = format!("at://{}/sh.weaver.actor.profile/self", did);
+
+            // Try to fetch existing weaver profile
+            let weaver_uri = match WeaverProfile::uri(&profile_uri_str) {
+                Ok(u) => u,
+                Err(_) => {
+                    error.set(Some("Invalid profile URI".to_string()));
+                    pinning.set(false);
+                    return;
+                }
+            };
+            let existing_profile: Option<WeaverProfile<'static>> =
+                match client.fetch_record(&weaver_uri).await {
+                    Ok(output) => Some(output.value),
+                    Err(_) => None,
+                };
+
+            // Build the new pinned list
+            let new_pinned: Vec<StrongRef<'static>> = if is_currently_pinned {
+                // Unpin: remove from list
+                existing_profile
+                    .as_ref()
+                    .and_then(|p| p.pinned.as_ref())
+                    .map(|pins| {
+                        pins.iter()
+                            .filter(|r| r.uri.as_ref() != notebook_uri.as_ref())
+                            .cloned()
+                            .collect()
+                    })
+                    .unwrap_or_default()
+            } else {
+                // Pin: add to list
+                let new_ref = StrongRef::new()
+                    .uri(notebook_uri.clone().into_static())
+                    .cid(notebook_cid.clone())
+                    .build();
+                let mut pins = existing_profile
+                    .as_ref()
+                    .and_then(|p| p.pinned.clone())
+                    .unwrap_or_default();
+                // Don't add if already exists
+                if !pins.iter().any(|r| r.uri.as_ref() == notebook_uri.as_ref()) {
+                    pins.push(new_ref);
+                }
+                pins
+            };
+
+            // Build the profile to save
+            let profile_to_save = if let Some(existing) = existing_profile {
+                // Update existing profile
+                WeaverProfile {
+                    pinned: Some(new_pinned),
+                    ..existing
+                }
+            } else {
+                // Create new profile from bsky data
+                let bsky_uri_str = format!("at://{}/app.bsky.actor.profile/self", did);
+                let bsky_profile: Option<BskyProfile<'static>> =
+                    match BskyProfile::uri(&bsky_uri_str) {
+                        Ok(bsky_uri) => match client.fetch_record(&bsky_uri).await {
+                            Ok(output) => Some(output.value),
+                            Err(_) => None,
+                        },
+                        Err(_) => None,
+                    };
+
+                WeaverProfile::new()
+                    .maybe_display_name(
+                        bsky_profile
+                            .as_ref()
+                            .and_then(|p| p.display_name.clone()),
+                    )
+                    .maybe_description(
+                        bsky_profile.as_ref().and_then(|p| p.description.clone()),
+                    )
+                    .maybe_avatar(bsky_profile.as_ref().and_then(|p| p.avatar.clone()))
+                    .maybe_banner(bsky_profile.as_ref().and_then(|p| p.banner.clone()))
+                    .bluesky(true)
+                    .created_at(jacquard::types::string::Datetime::now())
+                    .pinned(new_pinned)
+                    .build()
+            };
+
+            // Serialize and save
+            let profile_data = match to_data(&profile_to_save) {
+                Ok(d) => d,
+                Err(e) => {
+                    error.set(Some(format!("Failed to serialize profile: {:?}", e)));
+                    pinning.set(false);
+                    return;
+                }
+            };
+
+            let request = PutRecord::new()
+                .repo(AtIdentifier::Did(did))
+                .collection(Nsid::new_static("sh.weaver.actor.profile").unwrap())
+                .rkey(jacquard::types::string::Rkey::new("self").unwrap())
+                .record(profile_data)
+                .build();
+
+            match client.send(request).await {
+                Ok(_) => {
+                    show_dropdown.set(false);
+                    if let Some(handler) = &on_pinned_changed {
+                        handler.call(!is_currently_pinned);
+                    }
+                }
+                Err(e) => {
+                    error.set(Some(format!("Failed to update profile: {:?}", e)));
+                }
+            }
+            pinning.set(false);
+        });
+    };
+
+    rsx! {
+        div { class: "notebook-actions",
+            // Dropdown for actions
+            div { class: "notebook-actions-dropdown",
+                Button {
+                    variant: ButtonVariant::Ghost,
+                    onclick: move |_| show_dropdown.toggle(),
+                    "⋮"
+                }
+
+                if show_dropdown() {
+                    div { class: "dropdown-menu",
+                        // Pin/Unpin (first)
+                        button {
+                            class: "dropdown-item",
+                            disabled: pinning(),
+                            onclick: handle_pin_toggle,
+                            if pinning() {
+                                "Updating..."
+                            } else if is_pinned {
+                                "Unpin"
+                            } else {
+                                "Pin"
+                            }
+                        }
+                        // Delete (danger style)
+                        button {
+                            class: "dropdown-item dropdown-item-danger",
+                            onclick: move |_| {
+                                show_dropdown.set(false);
+                                show_delete_confirm.set(true);
+                            },
+                            "Delete"
+                        }
+                    }
+                }
+            }
+
+            // Delete confirmation dialog
+            DialogRoot {
+                open: show_delete_confirm(),
+                on_open_change: move |open: bool| show_delete_confirm.set(open),
+                DialogContent {
+                    DialogTitle { "Delete Notebook?" }
+                    DialogDescription {
+                        "Delete \"{title_for_display}\"? The entries will remain but will no longer be part of this notebook."
+                    }
+                    if let Some(ref err) = error() {
+                        div { class: "dialog-error", "{err}" }
+                    }
+                    div { class: "dialog-actions",
+                        Button {
+                            variant: ButtonVariant::Destructive,
+                            onclick: handle_delete,
+                            disabled: deleting(),
+                            if deleting() { "Deleting..." } else { "Delete" }
+                        }
+                        Button {
+                            variant: ButtonVariant::Ghost,
+                            onclick: move |_| show_delete_confirm.set(false),
+                            "Cancel"
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

crates/weaver-app/src/data.rs

···
     Memo<Option<ProfileDataView<'static>>>,
 ) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    let res = use_resource(use_reactive!(|ident| {
+    let res = use_server_future(use_reactive!(|ident| {
         let fetcher = fetcher.clone();
         async move {
             fetcher
···
         }
     }));
     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
         }
     }));
-    (Ok(res), memo)
+    (res, memo)
 }
 
 /// Fetches profile data client-side only (no SSR)
···
 /// 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)
+}
+
+// ============================================================================
+// Client-only versions (bypass SSR issues on profile page)
+// ============================================================================
+
+/// Fetches profile data client-side only - use when SSR causes issues
+pub fn use_profile_data_client(
+    ident: ReadSignal<AtIdentifier<'static>>,
+) -> (
+    Resource<Option<ProfileDataView<'static>>>,
+    Memo<Option<ProfileDataView<'static>>>,
+) {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let res = use_resource(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_profile(&ident())
+                .await
+                .ok()
+                .map(|arc| (*arc).clone())
+        }
+    });
+    let memo = use_memo(move || res.read().clone().flatten());
+    (res, memo)
+}
+
+/// Fetches notebooks client-side only - use when SSR causes issues
+pub fn use_notebooks_for_did_client(
+    ident: ReadSignal<AtIdentifier<'static>>,
+) -> (
+    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();
+        async move {
+            fetcher
+                .fetch_notebooks_for_did(&ident())
+                .await
+                .ok()
+                .map(|notebooks| {
+                    notebooks
+                        .iter()
+                        .map(|arc| arc.as_ref().clone())
+                        .collect::<Vec<_>>()
+                })
+        }
+    });
+    let memo = use_memo(move || res.read().clone().flatten());
+    (res, memo)
+}
+
+/// Fetches all entries client-side only - use when SSR causes issues
+pub fn use_entries_for_did_client(
     ident: ReadSignal<AtIdentifier<'static>>,
 ) -> (
     Resource<Option<Vec<(EntryView<'static>, Entry<'static>)>>>,

crates/weaver-app/src/fetch.rs

···
         request: http::Request<Vec<u8>>,
     ) -> impl Future<Output = core::result::Result<http::Response<Vec<u8>>, Self::Error>> + Send
     {
-        self.oauth_client.client.send_http(request)
+        self.oauth_client.send_http(request)
     }
 
     #[cfg(target_arch = "wasm32")]
···
         &self,
         request: http::Request<Vec<u8>>,
     ) -> impl Future<Output = core::result::Result<http::Response<Vec<u8>>, Self::Error>> {
-        self.oauth_client.client.send_http(request)
+        self.oauth_client.send_http(request)
     }
 }
 
···
         };
 
         // Fetch all notebook records for this repo
+        tracing::info!(
+            "fetch_notebooks_for_did: pds_url={}, repo_did={}",
+            pds_url,
+            repo_did
+        );
+
         let resp = client
-            .xrpc(pds_url)
+            .xrpc(pds_url.clone())
             .send(
                 &ListRecords::new()
                     .repo(repo_did)
···
                     .build(),
             )
             .await
-            .map_err(|e| dioxus::CapturedError::from_display(e))?;
+            .map_err(|e| {
+                tracing::error!(
+                    "fetch_notebooks_for_did: xrpc failed: {} pds url {}",
+                    e,
+                    pds_url
+                );
+                dioxus::CapturedError::from_display(e)
+            })?;
 
         let mut notebooks = Vec::new();
 
···
         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();
+                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 {

crates/weaver-common/Cargo.toml

···
 tracing = { workspace = true }
 reqwest = { version = "0.12", default-features = false, features = [
     "json",
-    "rustls-tls",
 ] }
 
 markdown-weaver-escape = { workspace = true, features = ["std"] }

crates/weaver-common/src/agent.rs

···
                         AgentError::from(ClientError::invalid_request("Invalid weaver profile URI"))
                     },
                 )?;
-            // let weaver_future = async {
-            //     if let Ok(weaver_record) = self.fetch_record(&weaver_uri).await {
-            //         // Convert blobs to CDN URLs
-            //         let avatar = weaver_record
-            //             .value
-            //             .avatar
-            //             .as_ref()
-            //             .map(|blob| {
-            //                 let cid = blob.blob().cid();
-            //                 jacquard::types::string::Uri::new_owned(format!(
-            //                     "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
-            //                     did, cid
-            //                 ))
-            //             })
-            //             .transpose()
-            //             .map_err(|_| {
-            //                 AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
-            //             })?;
-            //         let banner = weaver_record
-            //             .value
-            //             .banner
-            //             .as_ref()
-            //             .map(|blob| {
-            //                 let cid = blob.blob().cid();
-            //                 jacquard::types::string::Uri::new_owned(format!(
-            //                     "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
-            //                     did, cid
-            //                 ))
-            //             })
-            //             .transpose()
-            //             .map_err(|_| {
-            //                 AgentError::from(ClientError::invalid_request("Invalid banner URI"))
-            //             })?;
+            let weaver_future = async {
+                if let Ok(weaver_record) = self.fetch_record(&weaver_uri).await {
+                    // Convert blobs to CDN URLs
+                    let avatar = weaver_record
+                        .value
+                        .avatar
+                        .as_ref()
+                        .map(|blob| {
+                            let cid = blob.blob().cid();
+                            jacquard::types::string::Uri::new_owned(format!(
+                                "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
+                                did, cid
+                            ))
+                        })
+                        .transpose()
+                        .map_err(|_| {
+                            AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
+                        })?;
+                    let banner = weaver_record
+                        .value
+                        .banner
+                        .as_ref()
+                        .map(|blob| {
+                            let cid = blob.blob().cid();
+                            jacquard::types::string::Uri::new_owned(format!(
+                                "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
+                                did, cid
+                            ))
+                        })
+                        .transpose()
+                        .map_err(|_| {
+                            AgentError::from(ClientError::invalid_request("Invalid banner URI"))
+                        })?;
 
-            //         let profile_view = ProfileView::new()
-            //             .did(did.clone())
-            //             .handle(handle.clone())
-            //             .maybe_display_name(weaver_record.value.display_name.clone())
-            //             .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())
-            //             .maybe_pinned(weaver_record.value.pinned.clone())
-            //             .indexed_at(jacquard::types::string::Datetime::now())
-            //             .maybe_created_at(weaver_record.value.created_at)
-            //             .build();
+                    let profile_view = ProfileView::new()
+                        .did(did.clone())
+                        .handle(handle.clone())
+                        .maybe_display_name(weaver_record.value.display_name.clone())
+                        .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())
+                        .maybe_pinned(weaver_record.value.pinned.clone())
+                        .indexed_at(jacquard::types::string::Datetime::now())
+                        .maybe_created_at(weaver_record.value.created_at)
+                        .build();
 
-            //         Ok((
-            //             Some(weaver_uri.as_uri().clone().into_static()),
-            //             ProfileDataView::new()
-            //                 .inner(ProfileDataViewInner::ProfileView(Box::new(profile_view)))
-            //                 .build()
-            //                 .into_static(),
-            //         ))
-            //     } else {
-            //         Err(WeaverError::Agent(
-            //             ClientError::invalid_request("Invalid weaver profile URI").into(),
-            //         ))
-            //     }
-            // };
+                    Ok((
+                        Some(weaver_uri.as_uri().clone().into_static()),
+                        ProfileDataView::new()
+                            .inner(ProfileDataViewInner::ProfileView(Box::new(profile_view)))
+                            .build()
+                            .into_static(),
+                    ))
+                } else {
+                    Err(WeaverError::Agent(
+                        ClientError::invalid_request("Invalid weaver profile URI").into(),
+                    ))
+                }
+            };
             let bsky_appview_future = async {
                 if let Ok(bsky_resp) = self
                     .send(GetProfile::new().actor(did.clone()).build())
···
                     ))
                 }
             };
-            // Fallback: fetch bsky profile record directly and construct minimal ProfileViewDetailed
-            let bsky_uri = BskyProfile::uri(format!("at://{}/app.bsky.actor.profile/self", did))
-                .map_err(|_| {
-                    AgentError::from(ClientError::invalid_request("Invalid bsky profile URI"))
-                })?;
 
-            // let bsky_future = async {
-            //     let bsky_record = self.fetch_record(&bsky_uri).await?;
-
-            //     let avatar = bsky_record
-            //         .value
-            //         .avatar
-            //         .as_ref()
-            //         .map(|blob| {
-            //             let cid = blob.blob().cid();
-            //             jacquard::types::string::Uri::new_owned(format!(
-            //                 "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
-            //                 did, cid
-            //             ))
-            //         })
-            //         .transpose()
-            //         .map_err(|_| {
-            //             AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
-            //         })?;
-            //     let banner = bsky_record
-            //         .value
-            //         .banner
-            //         .as_ref()
-            //         .map(|blob| {
-            //             let cid = blob.blob().cid();
-            //             jacquard::types::string::Uri::new_owned(format!(
-            //                 "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
-            //                 did, cid
-            //             ))
-            //         })
-            //         .transpose()
-            //         .map_err(|_| {
-            //             AgentError::from(ClientError::invalid_request("Invalid banner URI"))
-            //         })?;
-
-            //     let profile_detailed = ProfileViewDetailed::new()
-            //         .did(did.clone())
-            //         .handle(handle.clone())
-            //         .maybe_display_name(bsky_record.value.display_name.clone())
-            //         .maybe_description(bsky_record.value.description.clone())
-            //         .maybe_avatar(avatar)
-            //         .maybe_banner(banner)
-            //         .indexed_at(jacquard::types::string::Datetime::now())
-            //         .maybe_created_at(bsky_record.value.created_at)
-            //         .build();
-
-            //     Ok((
-            //         Some(bsky_uri.as_uri().clone().into_static()),
-            //         ProfileDataView::new()
-            //             .inner(ProfileDataViewInner::ProfileViewDetailed(Box::new(
-            //                 profile_detailed,
-            //             )))
-            //             .build()
-            //             .into_static(),
-            //     ))
-            // };
-
-            // n0_future::future::or(
-            //     weaver_future,
-            //     n0_future::future::or(bsky_appview_future, bsky_future),
-            // )
-            // .await
-            bsky_appview_future.await
+            if let Ok((profile_uri, weaver_profileview)) = weaver_future.await {
+                return Ok((profile_uri, weaver_profileview));
+            } else if let Ok((profile_uri, bsky_profileview)) = bsky_appview_future.await {
+                return Ok((profile_uri, bsky_profileview));
+            } else {
+                Err(WeaverError::Agent(AgentError::from(
+                    ClientError::invalid_request("couldn't fetch profile"),
+                )))
+            }
         }
     }
 

crates/weaver-renderer/src/css.rs

···
     font-family: var(--font-body);
     color: var(--color-text);
     background-color: var(--color-base);
-    max-width: 90ch;
     margin: 0 auto;
-    padding: 2rem 1rem;
+    padding: 1rem 0rem;
     word-wrap: break-word;
     overflow-wrap: break-word;
 }}
···
 
 /* Code blocks inside pre are handled by syntax theme */
 pre code {{
+
     display: block;
     width: fit-content;
     min-width: 100%;
···
 .embed-fields {{
     display: block;
     margin-top: 0.5rem;
+    font-family: var(--font-ui);
     font-size: 0.85rem;
     color: var(--color-muted);
 }}
···
     padding: 0.5rem;
     text-align: center;
     font-size: 0.85em;
+    font-family: var(--font-ui);
     color: var(--color-muted);
     background: var(--color-overlay);
     border-top: 1px solid var(--color-border);

crates/weaver-renderer/src/theme.rs

···
 
 pub fn default_fonts() -> ThemeFonts<'static> {
     ThemeFonts {
+        // Serif for body text, sans for headings/UI
         body: CowStr::new_static(
-            "'IBM Plex', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+            "'Adobe Caslon Pro', 'Latin Modern Roman',  'CM Serif', Georgia, serif",
         ),
         heading: CowStr::new_static(
-            "'IBM Plex Sans', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+            "'IBM Plex Sans', 'CM Sans','Junction', 'Proza Libre',   system-ui, sans-serif",
         ),
         monospace: CowStr::new_static(
-            "'Ioskeley Mono', 'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace",
+            "'Ioskeley Mono', 'IBM Plex Mono', 'Berkeley Mono', Consolas, monospace",
         ),
         ..Default::default()
     }
···
 }
 
 pub fn default_colour_scheme_light() -> ColourSchemeColours<'static> {
+    // Rose Pine Dawn with moderate contrast text (text/muted/subtle/emphasis darkened)
     ColourSchemeColours {
         base: CowStr::new_static("#faf4ed"),
         surface: CowStr::new_static("#fffaf3"),
         overlay: CowStr::new_static("#f2e9e1"),
-        text: CowStr::new_static("#575279"),
-        muted: CowStr::new_static("#9893a5"),
-        subtle: CowStr::new_static("#797593"),
-        emphasis: CowStr::new_static("#575279"),
+        // Text colors darkened for better contrast
+        text: CowStr::new_static("#1f1d2e"),
+        muted: CowStr::new_static("#635e74"),
+        subtle: CowStr::new_static("#4a4560"),
+        emphasis: CowStr::new_static("#1e1a2d"),
+        // Accent colors kept at original Rose Pine Dawn values
         primary: CowStr::new_static("#907aa9"),
         secondary: CowStr::new_static("#56949f"),
         tertiary: CowStr::new_static("#286983"),