more styling fussing, new font lexicons

crates/weaver-api/lexicons/sh_weaver_notebook_entry.json

···
           "createdAt"
         ],
         "properties": {
+          "authors": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "sh.weaver.actor.defs#author"
+            }
+          },
           "content": {
             "type": "string",
-            "description": "The content of the notebook entry. This should be some flavor of Markdown.",
-            "maxLength": 200000
+            "description": "The content of the notebook entry. This should be some flavor of Markdown."
           },
           "createdAt": {
             "type": "string",

crates/weaver-api/lexicons/sh_weaver_notebook_theme.json

···
   "defs": {
     "codeThemeFile": {
       "type": "object",
+      "description": "Custom syntax highlighting theme file (sublime text/textmate theme format)",
       "required": [
         "name",
         "did",
···
     "codeThemeName": {
       "type": "string"
     },
+    "font": {
+      "type": "object",
+      "required": [
+        "value"
+      ],
+      "properties": {
+        "value": {
+          "type": "union",
+          "description": "Font for a notebook",
+          "refs": [
+            "#fontName",
+            "#fontFile"
+          ]
+        }
+      }
+    },
+    "fontFile": {
+      "type": "object",
+      "description": "Custom woff(2) or ttf font file",
+      "required": [
+        "name",
+        "did",
+        "content"
+      ],
+      "properties": {
+        "content": {
+          "type": "blob",
+          "accept": [
+            "*/*"
+          ],
+          "maxSize": 20000
+        },
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "fontName": {
+      "type": "string"
+    },
     "main": {
       "type": "record",
       "description": "Theme for a notebook",
···
           },
           "fonts": {
             "type": "object",
+            "description": "Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults.",
             "required": [
               "body",
               "heading",
···
             ],
             "properties": {
               "body": {
-                "type": "string"
+                "type": "array",
+                "items": {
+                  "type": "ref",
+                  "ref": "#font"
+                }
               },
               "heading": {
-                "type": "string"
+                "type": "array",
+                "items": {
+                  "type": "ref",
+                  "ref": "#font"
+                }
               },
               "monospace": {
-                "type": "string"
+                "type": "array",
+                "items": {
+                  "type": "ref",
+                  "ref": "#font"
+                }
               }
             }
           },

crates/weaver-api/src/sh_weaver/notebook/entry.rs

···
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Entry<'a> {
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub authors: std::option::Option<Vec<crate::sh_weaver::actor::Author<'a>>>,
     /// The content of the notebook entry. This should be some flavor of Markdown.
     #[serde(borrow)]
     pub content: jacquard_common::CowStr<'a>,
···
 pub struct EntryBuilder<'a, S: entry_state::State> {
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
+        ::core::option::Option<Vec<crate::sh_weaver::actor::Author<'a>>>,
         ::core::option::Option<jacquard_common::CowStr<'a>>,
         ::core::option::Option<jacquard_common::types::string::Datetime>,
         ::core::option::Option<EntryEmbeds<'a>>,
···
     pub fn new() -> Self {
         EntryBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None, None, None, None),
+            __unsafe_private_named: (None, None, None, None, None, None, None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
 }
 
+impl<'a, S: entry_state::State> EntryBuilder<'a, S> {
+    /// Set the `authors` field (optional)
+    pub fn authors(
+        mut self,
+        value: impl Into<Option<Vec<crate::sh_weaver::actor::Author<'a>>>>,
+    ) -> Self {
+        self.__unsafe_private_named.0 = value.into();
+        self
+    }
+    /// Set the `authors` field to an Option value (optional)
+    pub fn maybe_authors(
+        mut self,
+        value: Option<Vec<crate::sh_weaver::actor::Author<'a>>>,
+    ) -> Self {
+        self.__unsafe_private_named.0 = value;
+        self
+    }
+}
+
 impl<'a, S> EntryBuilder<'a, S>
 where
     S: entry_state::State,
···
         mut self,
         value: impl Into<jacquard_common::CowStr<'a>>,
     ) -> EntryBuilder<'a, entry_state::SetContent<S>> {
-        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
         EntryBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
         mut self,
         value: impl Into<jacquard_common::types::string::Datetime>,
     ) -> EntryBuilder<'a, entry_state::SetCreatedAt<S>> {
-        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
         EntryBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
 impl<'a, S: entry_state::State> EntryBuilder<'a, S> {
     /// Set the `embeds` field (optional)
     pub fn embeds(mut self, value: impl Into<Option<EntryEmbeds<'a>>>) -> Self {
-        self.__unsafe_private_named.2 = value.into();
+        self.__unsafe_private_named.3 = value.into();
         self
     }
     /// Set the `embeds` field to an Option value (optional)
     pub fn maybe_embeds(mut self, value: Option<EntryEmbeds<'a>>) -> Self {
-        self.__unsafe_private_named.2 = value;
+        self.__unsafe_private_named.3 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<crate::sh_weaver::notebook::Path<'a>>,
     ) -> EntryBuilder<'a, entry_state::SetPath<S>> {
-        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
         EntryBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
         mut self,
         value: impl Into<Option<crate::sh_weaver::notebook::Tags<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.4 = value.into();
+        self.__unsafe_private_named.5 = value.into();
         self
     }
     /// Set the `tags` field to an Option value (optional)
···
         mut self,
         value: Option<crate::sh_weaver::notebook::Tags<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.4 = value;
+        self.__unsafe_private_named.5 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<crate::sh_weaver::notebook::Title<'a>>,
     ) -> EntryBuilder<'a, entry_state::SetTitle<S>> {
-        self.__unsafe_private_named.5 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.6 = ::core::option::Option::Some(value.into());
         EntryBuilder {
             _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.6 = value.into();
+        self.__unsafe_private_named.7 = value.into();
         self
     }
     /// Set the `updatedAt` field to an Option value (optional)
···
         mut self,
         value: Option<jacquard_common::types::string::Datetime>,
     ) -> Self {
-        self.__unsafe_private_named.6 = value;
+        self.__unsafe_private_named.7 = value;
         self
     }
 }
···
     /// Build the final struct
     pub fn build(self) -> Entry<'a> {
         Entry {
-            content: self.__unsafe_private_named.0.unwrap(),
-            created_at: self.__unsafe_private_named.1.unwrap(),
-            embeds: self.__unsafe_private_named.2,
-            path: self.__unsafe_private_named.3.unwrap(),
-            tags: self.__unsafe_private_named.4,
-            title: self.__unsafe_private_named.5.unwrap(),
-            updated_at: self.__unsafe_private_named.6,
+            authors: self.__unsafe_private_named.0,
+            content: self.__unsafe_private_named.1.unwrap(),
+            created_at: self.__unsafe_private_named.2.unwrap(),
+            embeds: self.__unsafe_private_named.3,
+            path: self.__unsafe_private_named.4.unwrap(),
+            tags: self.__unsafe_private_named.5,
+            title: self.__unsafe_private_named.6.unwrap(),
+            updated_at: self.__unsafe_private_named.7,
             extra_data: Default::default(),
         }
     }
···
         >,
     ) -> Entry<'a> {
         Entry {
-            content: self.__unsafe_private_named.0.unwrap(),
-            created_at: self.__unsafe_private_named.1.unwrap(),
-            embeds: self.__unsafe_private_named.2,
-            path: self.__unsafe_private_named.3.unwrap(),
-            tags: self.__unsafe_private_named.4,
-            title: self.__unsafe_private_named.5.unwrap(),
-            updated_at: self.__unsafe_private_named.6,
+            authors: self.__unsafe_private_named.0,
+            content: self.__unsafe_private_named.1.unwrap(),
+            created_at: self.__unsafe_private_named.2.unwrap(),
+            embeds: self.__unsafe_private_named.3,
+            path: self.__unsafe_private_named.4.unwrap(),
+            tags: self.__unsafe_private_named.5,
+            title: self.__unsafe_private_named.6.unwrap(),
+            updated_at: self.__unsafe_private_named.7,
             extra_data: Some(extra_data),
         }
     }
···
                             #[allow(unused_mut)]
                             let mut map = ::std::collections::BTreeMap::new();
                             map.insert(
+                                ::jacquard_common::smol_str::SmolStr::new_static("authors"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
+                                    description: None,
+                                    items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
+                                        description: None,
+                                        r#ref: ::jacquard_common::CowStr::new_static(
+                                            "sh.weaver.actor.defs#author",
+                                        ),
+                                    }),
+                                    min_length: None,
+                                    max_length: None,
+                                }),
+                            );
+                            map.insert(
                                 ::jacquard_common::smol_str::SmolStr::new_static("content"),
                                 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
                                     description: Some(
···
                                     format: None,
                                     default: None,
                                     min_length: None,
-                                    max_length: Some(200000usize),
+                                    max_length: None,
                                     min_graphemes: None,
                                     max_graphemes: None,
                                     r#enum: None,
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
-        {
-            let value = &self.content;
-            #[allow(unused_comparisons)]
-            if <str>::len(value.as_ref()) > 200000usize {
-                return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
-                    path: ::jacquard_lexicon::validation::ValidationPath::from_field(
-                        "content",
-                    ),
-                    max: 200000usize,
-                    actual: <str>::len(value.as_ref()),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/weaver-api/src/sh_weaver/notebook/theme.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
+/// Custom syntax highlighting theme file (sublime text/textmate theme format)
 #[jacquard_derive::lexicon]
 #[derive(
     serde::Serialize,
···
             map.insert(
                 ::jacquard_common::smol_str::SmolStr::new_static("codeThemeFile"),
                 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                    description: None,
+                    description: Some(
+                        ::jacquard_common::CowStr::new_static(
+                            "Custom syntax highlighting theme file (sublime text/textmate theme format)",
+                        ),
+                    ),
                     required: Some(
                         vec![
                             ::jacquard_common::smol_str::SmolStr::new_static("name"),
···
                 }),
             );
             map.insert(
+                ::jacquard_common::smol_str::SmolStr::new_static("font"),
+                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
+                    description: None,
+                    required: Some(
+                        vec![::jacquard_common::smol_str::SmolStr::new_static("value")],
+                    ),
+                    nullable: None,
+                    properties: {
+                        #[allow(unused_mut)]
+                        let mut map = ::std::collections::BTreeMap::new();
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("value"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
+                                description: Some(
+                                    ::jacquard_common::CowStr::new_static("Font for a notebook"),
+                                ),
+                                refs: vec![
+                                    ::jacquard_common::CowStr::new_static("#fontName"),
+                                    ::jacquard_common::CowStr::new_static("#fontFile")
+                                ],
+                                closed: None,
+                            }),
+                        );
+                        map
+                    },
+                }),
+            );
+            map.insert(
+                ::jacquard_common::smol_str::SmolStr::new_static("fontFile"),
+                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
+                    description: Some(
+                        ::jacquard_common::CowStr::new_static(
+                            "Custom woff(2) or ttf font file",
+                        ),
+                    ),
+                    required: Some(
+                        vec![
+                            ::jacquard_common::smol_str::SmolStr::new_static("name"),
+                            ::jacquard_common::smol_str::SmolStr::new_static("did"),
+                            ::jacquard_common::smol_str::SmolStr::new_static("content")
+                        ],
+                    ),
+                    nullable: None,
+                    properties: {
+                        #[allow(unused_mut)]
+                        let mut map = ::std::collections::BTreeMap::new();
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("content"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
+                                description: None,
+                                accept: None,
+                                max_size: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("did"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: None,
+                                format: Some(
+                                    ::jacquard_lexicon::lexicon::LexStringFormat::Did,
+                                ),
+                                default: None,
+                                min_length: None,
+                                max_length: None,
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("name"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: None,
+                                format: None,
+                                default: None,
+                                min_length: None,
+                                max_length: None,
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
+                        map
+                    },
+                }),
+            );
+            map.insert(
+                ::jacquard_common::smol_str::SmolStr::new_static("fontName"),
+                ::jacquard_lexicon::lexicon::LexUserType::String(::jacquard_lexicon::lexicon::LexString {
+                    description: None,
+                    format: None,
+                    default: None,
+                    min_length: None,
+                    max_length: None,
+                    min_graphemes: None,
+                    max_graphemes: None,
+                    r#enum: None,
+                    r#const: None,
+                    known_values: None,
+                }),
+            );
+            map.insert(
                 ::jacquard_common::smol_str::SmolStr::new_static("main"),
                 ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {
                     description: Some(
···
                             map.insert(
                                 ::jacquard_common::smol_str::SmolStr::new_static("fonts"),
                                 ::jacquard_lexicon::lexicon::LexObjectProperty::Object(::jacquard_lexicon::lexicon::LexObject {
-                                    description: None,
+                                    description: Some(
+                                        ::jacquard_common::CowStr::new_static(
+                                            "Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults.",
+                                        ),
+                                    ),
                                     required: Some(
                                         vec![
                                             ::jacquard_common::smol_str::SmolStr::new_static("body"),
···
                                         let mut map = ::std::collections::BTreeMap::new();
                                         map.insert(
                                             ::jacquard_common::smol_str::SmolStr::new_static("body"),
-                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
                                                 description: None,
-                                                format: None,
-                                                default: None,
+                                                items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
+                                                    description: None,
+                                                    r#ref: ::jacquard_common::CowStr::new_static("#font"),
+                                                }),
                                                 min_length: None,
                                                 max_length: None,
-                                                min_graphemes: None,
-                                                max_graphemes: None,
-                                                r#enum: None,
-                                                r#const: None,
-                                                known_values: None,
                                             }),
                                         );
                                         map.insert(
                                             ::jacquard_common::smol_str::SmolStr::new_static("heading"),
-                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
                                                 description: None,
-                                                format: None,
-                                                default: None,
+                                                items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
+                                                    description: None,
+                                                    r#ref: ::jacquard_common::CowStr::new_static("#font"),
+                                                }),
                                                 min_length: None,
                                                 max_length: None,
-                                                min_graphemes: None,
-                                                max_graphemes: None,
-                                                r#enum: None,
-                                                r#const: None,
-                                                known_values: None,
                                             }),
                                         );
                                         map.insert(
                                             ::jacquard_common::smol_str::SmolStr::new_static(
                                                 "monospace",
                                             ),
-                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
                                                 description: None,
-                                                format: None,
-                                                default: None,
+                                                items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
+                                                    description: None,
+                                                    r#ref: ::jacquard_common::CowStr::new_static("#font"),
+                                                }),
                                                 min_length: None,
                                                 max_length: None,
-                                                min_graphemes: None,
-                                                max_graphemes: None,
-                                                r#enum: None,
-                                                r#const: None,
-                                                known_values: None,
                                             }),
                                         );
                                         map
···
 }
 
 pub type CodeThemeName<'a> = jacquard_common::CowStr<'a>;
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct Font<'a> {
+    /// Font for a notebook
+    #[serde(borrow)]
+    pub value: FontValue<'a>,
+}
+
+pub mod font_state {
+
+    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
+    #[allow(unused)]
+    use ::core::marker::PhantomData;
+    mod sealed {
+        pub trait Sealed {}
+    }
+    /// State trait tracking which required fields have been set
+    pub trait State: sealed::Sealed {
+        type Value;
+    }
+    /// Empty state - all required fields are unset
+    pub struct Empty(());
+    impl sealed::Sealed for Empty {}
+    impl State for Empty {
+        type Value = Unset;
+    }
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetValue<S> {}
+    impl<S: State> State for SetValue<S> {
+        type Value = Set<members::value>;
+    }
+    /// Marker types for field names
+    #[allow(non_camel_case_types)]
+    pub mod members {
+        ///Marker type for the `value` field
+        pub struct value(());
+    }
+}
+
+/// Builder for constructing an instance of this type
+pub struct FontBuilder<'a, S: font_state::State> {
+    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
+    __unsafe_private_named: (::core::option::Option<FontValue<'a>>,),
+    _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> Font<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> FontBuilder<'a, font_state::Empty> {
+        FontBuilder::new()
+    }
+}
+
+impl<'a> FontBuilder<'a, font_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        FontBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None,),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> FontBuilder<'a, S>
+where
+    S: font_state::State,
+    S::Value: font_state::IsUnset,
+{
+    /// Set the `value` field (required)
+    pub fn value(
+        mut self,
+        value: impl Into<FontValue<'a>>,
+    ) -> FontBuilder<'a, font_state::SetValue<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        FontBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> FontBuilder<'a, S>
+where
+    S: font_state::State,
+    S::Value: font_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> Font<'a> {
+        Font {
+            value: self.__unsafe_private_named.0.unwrap(),
+            extra_data: Default::default(),
+        }
+    }
+    /// Build the final struct with custom extra_data
+    pub fn build_with_data(
+        self,
+        extra_data: std::collections::BTreeMap<
+            jacquard_common::smol_str::SmolStr,
+            jacquard_common::types::value::Data<'a>,
+        >,
+    ) -> Font<'a> {
+        Font {
+            value: self.__unsafe_private_named.0.unwrap(),
+            extra_data: Some(extra_data),
+        }
+    }
+}
+
+#[jacquard_derive::open_union]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(tag = "$type")]
+#[serde(bound(deserialize = "'de: 'a"))]
+pub enum FontValue<'a> {
+    #[serde(rename = "sh.weaver.notebook.theme#fontName")]
+    FontName(Box<crate::sh_weaver::notebook::theme::FontName<'a>>),
+    #[serde(rename = "sh.weaver.notebook.theme#fontFile")]
+    FontFile(Box<crate::sh_weaver::notebook::theme::FontFile<'a>>),
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Font<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "font"
+    }
+    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
+        lexicon_doc_sh_weaver_notebook_theme()
+    }
+    fn validate(
+        &self,
+    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
+        Ok(())
+    }
+}
+
+/// Custom woff(2) or ttf font file
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct FontFile<'a> {
+    #[serde(borrow)]
+    pub content: jacquard_common::types::blob::BlobRef<'a>,
+    #[serde(borrow)]
+    pub did: jacquard_common::types::string::Did<'a>,
+    #[serde(borrow)]
+    pub name: jacquard_common::CowStr<'a>,
+}
+
+pub mod font_file_state {
+
+    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
+    #[allow(unused)]
+    use ::core::marker::PhantomData;
+    mod sealed {
+        pub trait Sealed {}
+    }
+    /// State trait tracking which required fields have been set
+    pub trait State: sealed::Sealed {
+        type Name;
+        type Did;
+        type Content;
+    }
+    /// Empty state - all required fields are unset
+    pub struct Empty(());
+    impl sealed::Sealed for Empty {}
+    impl State for Empty {
+        type Name = Unset;
+        type Did = Unset;
+        type Content = Unset;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetName<S> {}
+    impl<S: State> State for SetName<S> {
+        type Name = Set<members::name>;
+        type Did = S::Did;
+        type Content = S::Content;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetDid<S> {}
+    impl<S: State> State for SetDid<S> {
+        type Name = S::Name;
+        type Did = Set<members::did>;
+        type Content = S::Content;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetContent<S> {}
+    impl<S: State> State for SetContent<S> {
+        type Name = S::Name;
+        type Did = S::Did;
+        type Content = Set<members::content>;
+    }
+    /// Marker types for field names
+    #[allow(non_camel_case_types)]
+    pub mod members {
+        ///Marker type for the `name` field
+        pub struct name(());
+        ///Marker type for the `did` field
+        pub struct did(());
+        ///Marker type for the `content` field
+        pub struct content(());
+    }
+}
+
+/// Builder for constructing an instance of this type
+pub struct FontFileBuilder<'a, S: font_file_state::State> {
+    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
+    __unsafe_private_named: (
+        ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
+        ::core::option::Option<jacquard_common::types::string::Did<'a>>,
+        ::core::option::Option<jacquard_common::CowStr<'a>>,
+    ),
+    _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> FontFile<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> FontFileBuilder<'a, font_file_state::Empty> {
+        FontFileBuilder::new()
+    }
+}
+
+impl<'a> FontFileBuilder<'a, font_file_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        FontFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None, None, None),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> FontFileBuilder<'a, S>
+where
+    S: font_file_state::State,
+    S::Content: font_file_state::IsUnset,
+{
+    /// Set the `content` field (required)
+    pub fn content(
+        mut self,
+        value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
+    ) -> FontFileBuilder<'a, font_file_state::SetContent<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        FontFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> FontFileBuilder<'a, S>
+where
+    S: font_file_state::State,
+    S::Did: font_file_state::IsUnset,
+{
+    /// Set the `did` field (required)
+    pub fn did(
+        mut self,
+        value: impl Into<jacquard_common::types::string::Did<'a>>,
+    ) -> FontFileBuilder<'a, font_file_state::SetDid<S>> {
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        FontFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> FontFileBuilder<'a, S>
+where
+    S: font_file_state::State,
+    S::Name: font_file_state::IsUnset,
+{
+    /// Set the `name` field (required)
+    pub fn name(
+        mut self,
+        value: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> FontFileBuilder<'a, font_file_state::SetName<S>> {
+        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
+        FontFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> FontFileBuilder<'a, S>
+where
+    S: font_file_state::State,
+    S::Name: font_file_state::IsSet,
+    S::Did: font_file_state::IsSet,
+    S::Content: font_file_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> FontFile<'a> {
+        FontFile {
+            content: self.__unsafe_private_named.0.unwrap(),
+            did: self.__unsafe_private_named.1.unwrap(),
+            name: self.__unsafe_private_named.2.unwrap(),
+            extra_data: Default::default(),
+        }
+    }
+    /// Build the final struct with custom extra_data
+    pub fn build_with_data(
+        self,
+        extra_data: std::collections::BTreeMap<
+            jacquard_common::smol_str::SmolStr,
+            jacquard_common::types::value::Data<'a>,
+        >,
+    ) -> FontFile<'a> {
+        FontFile {
+            content: self.__unsafe_private_named.0.unwrap(),
+            did: self.__unsafe_private_named.1.unwrap(),
+            name: self.__unsafe_private_named.2.unwrap(),
+            extra_data: Some(extra_data),
+        }
+    }
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for FontFile<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "fontFile"
+    }
+    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
+        lexicon_doc_sh_weaver_notebook_theme()
+    }
+    fn validate(
+        &self,
+    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
+        Ok(())
+    }
+}
+
+pub type FontName<'a> = jacquard_common::CowStr<'a>;
 /// Theme for a notebook
 #[jacquard_derive::lexicon]
 #[derive(
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub default_theme: std::option::Option<jacquard_common::CowStr<'a>>,
+    /// Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults.
     #[serde(borrow)]
     pub fonts: ThemeFonts<'a>,
     /// Syntax highlighting theme for light mode
···
     CodeThemeFile(Box<crate::sh_weaver::notebook::theme::CodeThemeFile<'a>>),
 }
 
+/// Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults.
 #[jacquard_derive::lexicon]
 #[derive(
     serde::Serialize,
···
     Clone,
     PartialEq,
     Eq,
-    jacquard_derive::IntoStatic,
-    Default
+    jacquard_derive::IntoStatic
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ThemeFonts<'a> {
     #[serde(borrow)]
-    pub body: jacquard_common::CowStr<'a>,
+    pub body: Vec<crate::sh_weaver::notebook::theme::Font<'a>>,
     #[serde(borrow)]
-    pub heading: jacquard_common::CowStr<'a>,
+    pub heading: Vec<crate::sh_weaver::notebook::theme::Font<'a>>,
     #[serde(borrow)]
-    pub monospace: jacquard_common::CowStr<'a>,
+    pub monospace: Vec<crate::sh_weaver::notebook::theme::Font<'a>>,
+}
+
+pub mod theme_fonts_state {
+
+    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
+    #[allow(unused)]
+    use ::core::marker::PhantomData;
+    mod sealed {
+        pub trait Sealed {}
+    }
+    /// State trait tracking which required fields have been set
+    pub trait State: sealed::Sealed {
+        type Body;
+        type Heading;
+        type Monospace;
+    }
+    /// Empty state - all required fields are unset
+    pub struct Empty(());
+    impl sealed::Sealed for Empty {}
+    impl State for Empty {
+        type Body = Unset;
+        type Heading = Unset;
+        type Monospace = Unset;
+    }
+    ///State transition - sets the `body` field to Set
+    pub struct SetBody<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetBody<S> {}
+    impl<S: State> State for SetBody<S> {
+        type Body = Set<members::body>;
+        type Heading = S::Heading;
+        type Monospace = S::Monospace;
+    }
+    ///State transition - sets the `heading` field to Set
+    pub struct SetHeading<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetHeading<S> {}
+    impl<S: State> State for SetHeading<S> {
+        type Body = S::Body;
+        type Heading = Set<members::heading>;
+        type Monospace = S::Monospace;
+    }
+    ///State transition - sets the `monospace` field to Set
+    pub struct SetMonospace<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetMonospace<S> {}
+    impl<S: State> State for SetMonospace<S> {
+        type Body = S::Body;
+        type Heading = S::Heading;
+        type Monospace = Set<members::monospace>;
+    }
+    /// Marker types for field names
+    #[allow(non_camel_case_types)]
+    pub mod members {
+        ///Marker type for the `body` field
+        pub struct body(());
+        ///Marker type for the `heading` field
+        pub struct heading(());
+        ///Marker type for the `monospace` field
+        pub struct monospace(());
+    }
+}
+
+/// Builder for constructing an instance of this type
+pub struct ThemeFontsBuilder<'a, S: theme_fonts_state::State> {
+    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
+    __unsafe_private_named: (
+        ::core::option::Option<Vec<crate::sh_weaver::notebook::theme::Font<'a>>>,
+        ::core::option::Option<Vec<crate::sh_weaver::notebook::theme::Font<'a>>>,
+        ::core::option::Option<Vec<crate::sh_weaver::notebook::theme::Font<'a>>>,
+    ),
+    _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> ThemeFonts<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> ThemeFontsBuilder<'a, theme_fonts_state::Empty> {
+        ThemeFontsBuilder::new()
+    }
+}
+
+impl<'a> ThemeFontsBuilder<'a, theme_fonts_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        ThemeFontsBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None, None, None),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeFontsBuilder<'a, S>
+where
+    S: theme_fonts_state::State,
+    S::Body: theme_fonts_state::IsUnset,
+{
+    /// Set the `body` field (required)
+    pub fn body(
+        mut self,
+        value: impl Into<Vec<crate::sh_weaver::notebook::theme::Font<'a>>>,
+    ) -> ThemeFontsBuilder<'a, theme_fonts_state::SetBody<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        ThemeFontsBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeFontsBuilder<'a, S>
+where
+    S: theme_fonts_state::State,
+    S::Heading: theme_fonts_state::IsUnset,
+{
+    /// Set the `heading` field (required)
+    pub fn heading(
+        mut self,
+        value: impl Into<Vec<crate::sh_weaver::notebook::theme::Font<'a>>>,
+    ) -> ThemeFontsBuilder<'a, theme_fonts_state::SetHeading<S>> {
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        ThemeFontsBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeFontsBuilder<'a, S>
+where
+    S: theme_fonts_state::State,
+    S::Monospace: theme_fonts_state::IsUnset,
+{
+    /// Set the `monospace` field (required)
+    pub fn monospace(
+        mut self,
+        value: impl Into<Vec<crate::sh_weaver::notebook::theme::Font<'a>>>,
+    ) -> ThemeFontsBuilder<'a, theme_fonts_state::SetMonospace<S>> {
+        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
+        ThemeFontsBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeFontsBuilder<'a, S>
+where
+    S: theme_fonts_state::State,
+    S::Body: theme_fonts_state::IsSet,
+    S::Heading: theme_fonts_state::IsSet,
+    S::Monospace: theme_fonts_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> ThemeFonts<'a> {
+        ThemeFonts {
+            body: self.__unsafe_private_named.0.unwrap(),
+            heading: self.__unsafe_private_named.1.unwrap(),
+            monospace: self.__unsafe_private_named.2.unwrap(),
+            extra_data: Default::default(),
+        }
+    }
+    /// Build the final struct with custom extra_data
+    pub fn build_with_data(
+        self,
+        extra_data: std::collections::BTreeMap<
+            jacquard_common::smol_str::SmolStr,
+            jacquard_common::types::value::Data<'a>,
+        >,
+    ) -> ThemeFonts<'a> {
+        ThemeFonts {
+            body: self.__unsafe_private_named.0.unwrap(),
+            heading: self.__unsafe_private_named.1.unwrap(),
+            monospace: self.__unsafe_private_named.2.unwrap(),
+            extra_data: Some(extra_data),
+        }
+    }
 }
 
 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThemeFonts<'a> {

crates/weaver-app/assets/styling/cards-base.css

···
+/* Shared card primitives
+   Used by entry-card.css and notebook-card.css */
+
+/* ==========================================================================
+   CARD SURFACE
+   Container with background, shadow (light) or border (dark)
+   ========================================================================== */
+
+.card-surface {
+    background: var(--color-surface);
+    box-shadow: 0 1px 2px color-mix(in srgb, var(--color-text) 6%, transparent);
+}
+
+@media (prefers-color-scheme: dark) {
+    .card-surface {
+        box-shadow: none;
+        border: 1px solid var(--color-border);
+    }
+}
+
+/* ==========================================================================
+   CARD TITLE
+   Heading style for card titles
+   ========================================================================== */
+
+.card-title {
+    font-family: var(--font-heading);
+    font-weight: 600;
+    color: var(--color-primary);
+    margin: 0;
+    transition: color 0.2s ease;
+}
+
+/* ==========================================================================
+   CARD META
+   Muted metadata text (dates, counts, etc.)
+   ========================================================================== */
+
+.card-meta {
+    color: var(--color-muted);
+    font-size: 0.85rem;
+}
+
+/* ==========================================================================
+   CARD TAGS
+   Tag list container and individual tags
+   ========================================================================== */
+
+.card-tags {
+    display: flex;
+    gap: 0.4rem;
+    flex-wrap: wrap;
+}
+
+.card-tag {
+    padding: 0.2rem 0.4rem 0.2rem 0;
+    font-size: 0.75rem;
+    color: var(--color-subtle);
+    border-bottom: 1px solid var(--color-border);
+    transition:
+        color 0.15s ease,
+        border-color 0.15s ease;
+}
+
+/* ==========================================================================
+   CARD PREVIEW
+   Truncated content preview with line clamping
+   ========================================================================== */
+
+.card-preview {
+    color: var(--color-subtle);
+    font-family: var(--font-body);
+    font-size: 0.875rem;
+    line-height: 1.5;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+.card-preview-3 {
+    -webkit-line-clamp: 3;
+}
+
+.card-preview-4 {
+    -webkit-line-clamp: 4;
+}
+
+/* Preview content normalization */
+.card-preview h1,
+.card-preview h2,
+.card-preview h3,
+.card-preview h4,
+.card-preview h5,
+.card-preview h6 {
+    font-size: 0.875rem;
+    font-weight: 600;
+    margin-top: 0;
+    margin-left: 0;
+    margin-right: 0;
+}
+
+.card-preview p {
+    margin: 0;
+    display: inline;
+}
+
+.card-preview code {
+    font-size: 0.8rem;
+    white-space: pre-wrap;
+    word-break: break-all;
+}
+
+.card-preview pre {
+    white-space: pre-wrap;
+    word-break: break-all;
+    max-width: 100%;
+}
+
+/* ==========================================================================
+   CARD HOVER STATES
+   Common hover patterns for cards
+   ========================================================================== */
+
+.card-hover-border:hover {
+    border-left-color: var(--color-secondary);
+}
+
+.card-hover-title:hover .card-title {
+    color: var(--color-secondary);
+}
+
+.card-hover-tags:hover .card-tag {
+    color: var(--color-tertiary);
+    border-color: var(--color-tertiary);
+}
+
+/* ==========================================================================
+   LOADING/ERROR STATES
+   ========================================================================== */
+
+.card-loading,
+.card-error {
+    text-align: center;
+    padding: 2rem;
+    color: var(--color-muted);
+}
+
+.card-error {
+    color: var(--color-error);
+}

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

···
 /* Entry card styling */
-
-/* Notebook layout - sidebar in left gutter on desktop, header on mobile */
-.notebook-layout {
-    display: grid;
-    grid-template-columns: minmax(280px, 1fr) minmax(0, 90rem) minmax(280px, 1fr);
-    gap: 2rem;
-    max-width: calc(90rem + 560px + 4rem); /* content + gutters + gaps */
-    margin: 0 auto;
-    padding: 2.5rem 1.25rem 2.5rem 0;
-}
-
-.notebook-sidebar {
-    grid-column: 1;
-    position: sticky;
-    top: 2rem;
-    align-self: flex-start;
-    max-height: calc(100vh - 4rem);
-    overflow-y: auto;
-}
-
-.notebook-main {
-    grid-column: 2;
-    padding: 0 1rem;
-}
-
-/* Mobile layout - sidebar becomes header */
-@media (max-width: 1400px) {
-    .notebook-layout {
-        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;
-    }
+/* Layout classes (.notebook-layout, etc.) are now in layouts.css */
 
-    .notebook-sidebar {
-        grid-column: 2;
-        position: static;
-        max-height: none;
-        min-width: 0;
-        margin-bottom: 2rem;
-    }
-
-    .notebook-main {
-        grid-column: 2;
-        padding: 0;
-        min-width: 0;
-    }
-}
-
-/* Entries list - width constrained by grid column */
 .entries-list {
 }
 
···
     color: var(--color-subtle);
 }
 
-a.entry-card-author,
+/* Card-specific author positioning (uses embed-author base styles) */
 .entry-card-author {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
     margin-top: 0.25rem;
-    text-decoration: none;
-}
-
-.entry-card-author .author-name {
-    font-weight: 500;
-    color: var(--color-text);
-    transition: color 0.2s ease;
-}
-
-.entry-card-author .meta-label {
-    color: var(--color-muted);
-    font-size: 0.8rem;
-    transition: color 0.2s ease;
-}
-
-.entry-card-author:hover .author-name,
-.entry-card-author:hover .meta-label,
-.feed-entry-card .entry-card-author:hover .meta-label {
-    color: var(--color-link);
 }
 
 .entry-card-date {
···
 }
 
 .feed-entry-card .entry-card-byline .entry-card-date {
+    margin-left: auto;
+}
+
+/* Date in header (no author) aligns right */
+.feed-entry-card .entry-card-header .entry-card-date {
     margin-left: auto;
 }
 

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

···
+/* Sidebar layouts - 3-column grid with sticky sidebar */
+
+/* Base sidebar layout pattern
+   Uses CSS custom properties for sizing flexibility:
+   --layout-gutter: sidebar/gutter width (default: 240px)
+   --layout-content: main content max-width (default: 95ch)
+   --layout-gap: grid gap (default: 1.5rem)
+   --layout-padding: container padding (default: 2rem 1.25rem 2rem 0)
+*/
+
+.sidebar-layout {
+    display: grid;
+    grid-template-columns:
+        minmax(var(--layout-gutter, 240px), 1fr)
+        minmax(0, var(--layout-content, 95ch))
+        minmax(var(--layout-gutter, 240px), 1fr);
+    gap: var(--layout-gap, 1.5rem);
+    max-width: calc(var(--layout-content, 95ch) + var(--layout-gutter, 240px) * 2 + 4rem);
+    margin: 0 auto;
+    padding: var(--layout-padding, 2rem 1.25rem 2rem 0);
+}
+
+.sidebar-layout-sidebar {
+    grid-column: 1;
+    position: sticky;
+    top: 2rem;
+    align-self: flex-start;
+    max-height: calc(100vh - 4rem);
+    overflow-y: auto;
+}
+
+.sidebar-layout-main {
+    grid-column: 2;
+    padding: 0 1rem;
+}
+
+.sidebar-layout-actions {
+    grid-column: 3;
+    position: sticky;
+    top: 2rem;
+    align-self: flex-start;
+}
+
+/* Mobile: sidebar collapses to header above main content */
+@media (max-width: 1400px) {
+    .sidebar-layout {
+        grid-template-columns: minmax(1rem, 1fr) minmax(0, var(--layout-content, 95ch)) minmax(1rem, 1fr) !important;
+        gap: 0 !important;
+        max-width: 100vw !important;
+        box-sizing: border-box !important;
+    }
+
+    .sidebar-layout-sidebar {
+        grid-column: 2;
+        position: static;
+        max-height: none;
+        min-width: 0;
+        margin-bottom: 2rem;
+    }
+
+    .sidebar-layout-main {
+        grid-column: 2;
+        padding: 0;
+        min-width: 0;
+    }
+
+    .sidebar-layout-actions {
+        display: none;
+    }
+}
+
+/* Variant: notebook layout (wider gutters and content) */
+.sidebar-layout-notebook {
+    --layout-gutter: 280px;
+    --layout-content: 90rem;
+    --layout-gap: 2rem;
+    --layout-padding: 2.5rem 1.25rem 2.5rem 0;
+}
+
+/* Variant: repository/profile layout (standard sizing) */
+.sidebar-layout-repository {
+    --layout-gutter: 240px;
+    --layout-content: 95ch;
+    --layout-gap: 1rem;
+    --layout-padding: 2.25rem 1.25rem 2.25rem 0;
+}
+
+/* ==========================================================================
+   BACKWARD-COMPATIBLE CLASS ALIASES
+   These map existing component class names to the unified layout system.
+   ========================================================================== */
+
+/* Notebook layout (used in notebook.rs) */
+.notebook-layout {
+    display: grid;
+    grid-template-columns:
+        minmax(280px, 1fr)
+        minmax(0, 90rem)
+        minmax(280px, 1fr);
+    gap: 2rem;
+    max-width: calc(90rem + 560px + 4rem);
+    margin: 0 auto;
+    padding: 2.5rem 1.25rem 2.5rem 0;
+}
+
+.notebook-sidebar {
+    grid-column: 1;
+    position: sticky;
+    top: 2rem;
+    align-self: flex-start;
+    max-height: calc(100vh - 4rem);
+    overflow-y: auto;
+}
+
+.notebook-main {
+    grid-column: 2;
+    padding: 0 1rem;
+}
+
+@media (max-width: 1400px) {
+    .notebook-layout {
+        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;
+    }
+
+    .notebook-sidebar {
+        grid-column: 2;
+        position: static;
+        max-height: none;
+        min-width: 0;
+        margin-bottom: 2rem;
+    }
+
+    .notebook-main {
+        grid-column: 2;
+        padding: 0;
+        min-width: 0;
+    }
+}
+
+/* Repository layout (used in identity.rs) */
+.repository-layout {
+    display: grid;
+    grid-template-columns:
+        minmax(240px, 1fr)
+        minmax(0, 95ch)
+        minmax(240px, 1fr);
+    gap: 1rem;
+    max-width: calc(95ch + 480px + 4rem);
+    margin: 0 auto;
+    padding: 2.25rem 1.25rem 2.25rem 0;
+}
+
+.repository-sidebar {
+    grid-column: 1;
+    position: sticky;
+    top: 2rem;
+    align-self: flex-start;
+    overflow-y: auto;
+}
+
+.repository-main {
+    grid-column: 2;
+    padding: 0 1rem;
+}
+
+@media (max-width: 1400px) {
+    .repository-layout {
+        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;
+    }
+
+    .repository-sidebar {
+        grid-column: 2;
+        position: static;
+        max-height: none;
+        min-width: 0;
+        margin-bottom: 2rem;
+    }
+
+    .repository-main {
+        grid-column: 2;
+        padding: 0;
+        min-width: 0;
+    }
+}

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

···
+/* App shell styles - theme-defaults.css must load first */
+
 body {
     background-color: var(--color-base);
     color: var(--color-text);
···
     max-width: 1200px;
 }
 
-.record-view-container {
-    max-width: 1200px;
-    margin: 2rem auto;
-    padding: 0 1rem;
-}
-
-.uri-input-section {
-    margin-bottom: 2.5rem;
-}
-
-.uri-input {
-    font-family: var(--font-mono);
-    font-size: 0.9rem;
-    width: 100%;
-    max-width: 100%;
-    box-sizing: border-box;
-    padding: 0.5rem 0.75rem;
-    background: var(--color-surface, rgba(0, 0, 0, 0.2));
-    border: 1px solid var(--color-border);
-    color: var(--color-text);
-    outline: none;
-    transition: border-color 0.2s;
-}
-
+/* .notebook-content width constraint for rendered content */
 .notebook-content {
     width: 100%;
     max-width: 95ch;
 }
-
-.uri-input:focus {
-    border-color: var(--color-primary);
-}
-
-.uri-input::placeholder {
-    color: var(--color-subtle);
-    opacity: 0.5;
-}
-
-@font-face {
-    font-family: "Ioskeley Mono";
-    font-style: normal;
-    font-weight: normal;
-    src: url("/assets/IoskeleyMono-Regular.woff2") format("woff2");
-}
-@font-face {
-    font-family: "Ioskeley Mono";
-    font-style: normal;
-    font-weight: lighter;
-    src: url("/assets/IoskeleyMono-Light.woff2") format("woff2");
-}
-@font-face {
-    font-family: "Ioskeley Mono";
-    font-style: italic;
-    font-weight: lighter;
-    src: url("/assets/IoskeleyMono-LightItalic.woff2") format("woff2");
-}
-@font-face {
-    font-family: "Ioskeley Mono";
-    font-style: normal;
-    font-weight: bold;
-    src: url("/assets/IoskeleyMono-Bold.woff2") format("woff2");
-}
-@font-face {
-    font-family: "Ioskeley Mono";
-    font-style: italic;
-    font-weight: normal;
-    src: url("/assets/IoskeleyMono-Italic.woff2") format("woff2");
-}
-@font-face {
-    font-family: "Ioskeley Mono";
-    font-style: italic;
-    font-weight: bold;
-    src: url("/assets/IoskeleyMono-BoldItalic.woff2") format("woff2");
-}

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

···
 /* Notebook card styling */
-
-/* Repository layout - sidebar in left gutter on desktop, header on mobile */
-
-.repository-layout {
-    display: grid;
-    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;
-}
-
-.repository-sidebar {
-    grid-column: 1;
-    position: sticky;
-    top: 2rem;
-    align-self: flex-start;
-    overflow-y: auto;
-}
-
-.repository-main {
-    grid-column: 2;
-    padding: 0 1rem;
-}
-
-/* Mobile layout - sidebar becomes header */
-@media (max-width: 1400px) {
-    .repository-layout {
-        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;
-    }
-
-    .repository-sidebar {
-        grid-column: 2;
-        position: static;
-        max-height: none;
-        min-width: 0;
-        margin-bottom: 2rem;
-    }
+/* Layout classes (.repository-layout, etc.) are now in layouts.css */
 
-    .repository-main {
-        grid-column: 2;
-        padding: 0;
-        min-width: 0;
-    }
-}
-
-/* Notebook list - width constrained by grid column */
 .notebooks-list {
     margin-top: 0.25rem;
 }
 
 .notebook-card {
-    margin-bottom: 2.5rem; /* 2 grid units */
+    margin-bottom: calc(1.25rem * var(--spacing-scale, 1.25));
 }
 
 .notebook-card-container {

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

···
     display: none;
 }
 
-.notebook-author {
-    display: flex;
-    align-items: center;
-    gap: 0.75rem;
-}
-
-.notebook-author .avatar {
+/* Cover-specific author sizing (uses embed-author base styles) */
+.notebook-author .embed-avatar {
     width: 48px;
     height: 48px;
-    flex-shrink: 0;
-}
-
-.notebook-author-info {
-    display: flex;
-    flex-direction: column;
-    min-width: 0;
-}
-
-.notebook-author-name {
-    font-weight: 600;
-    color: var(--color-text);
-    font-size: 1rem;
-}
-
-.notebook-author-handle {
-    color: var(--color-subtle);
-    font-size: 0.875rem;
+    min-width: 48px;
+    min-height: 48px;
 }
 
 .notebook-cover-description {

crates/weaver-app/assets/styling/record-view.css

···
 }
 
 /* Array Section Styling */
-.section-header {
+.record-section-header {
     display: flex;
     align-items: baseline;
     gap: 0.5rem;
 }
 
-.array-item .section-header {
+.array-item .record-section-header {
 }
 .array-item .section-content .record-field {
 }

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

···
 use crate::blobcache::BlobCache;
 use crate::{
     components::EntryActions,
-    components::avatar::{Avatar, AvatarImage},
     data::use_handle,
 };
 use dioxus::prelude::*;
···
                     }
                 }
                 if let Some(author) = first_author {
-                    div { class: "entry-card-author",
-                        {
-                            use weaver_api::sh_weaver::actor::ProfileDataViewInner;
+                    {
+                        use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 
-                            match &author.record.inner {
-                                ProfileDataViewInner::ProfileView(profile) => {
-                                    let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
-                                    let handle = profile.handle.clone();
-                                    rsx! {
+                        match &author.record.inner {
+                            ProfileDataViewInner::ProfileView(profile) => {
+                                let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
+                                let handle = profile.handle.clone();
+                                rsx! {
+                                    span { class: "embed-author entry-card-author",
                                         if let Some(ref avatar_url) = profile.avatar {
-                                            Avatar {
-                                                AvatarImage { src: avatar_url.as_ref() }
-                                            }
+                                            img { class: "embed-avatar", src: avatar_url.as_ref(), alt: "" }
+                                        }
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-name", "{display_name}" }
+                                            span { class: "embed-author-handle", "@{handle}" }
                                         }
-                                        span { class: "author-name", "{display_name}" }
-                                        span { class: "meta-label", "@{handle}" }
                                     }
                                 }
-                                ProfileDataViewInner::ProfileViewDetailed(profile) => {
-                                    let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
-                                    let handle = profile.handle.clone();
-                                    rsx! {
+                            }
+                            ProfileDataViewInner::ProfileViewDetailed(profile) => {
+                                let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
+                                let handle = profile.handle.clone();
+                                rsx! {
+                                    span { class: "embed-author entry-card-author",
                                         if let Some(ref avatar_url) = profile.avatar {
-                                            Avatar {
-                                                AvatarImage { src: avatar_url.as_ref() }
-                                            }
+                                            img { class: "embed-avatar", src: avatar_url.as_ref(), alt: "" }
                                         }
-                                        span { class: "author-name", "{display_name}" }
-                                        span { class: "meta-label", "@{handle}" }
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-name", "{display_name}" }
+                                            span { class: "embed-author-handle", "@{handle}" }
+                                        }
                                     }
                                 }
-                                ProfileDataViewInner::TangledProfileView(profile) => {
-                                    rsx! {
-                                        span { class: "author-name", "@{profile.handle.as_ref()}" }
+                            }
+                            ProfileDataViewInner::TangledProfileView(profile) => {
+                                rsx! {
+                                    span { class: "embed-author entry-card-author",
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-handle", "@{profile.handle.as_ref()}" }
+                                        }
                                     }
                                 }
-                                _ => {
-                                    rsx! {
-                                        span { class: "author-name", "Unknown" }
+                            }
+                            _ => {
+                                rsx! {
+                                    span { class: "embed-author entry-card-author",
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-name", "Unknown" }
+                                        }
                                     }
                                 }
                             }
···
 }
 
 /// Card for entries in a feed (e.g., home page)
-/// Takes EntryView directly (not BookEntryView) and always shows author info
+/// Takes EntryView directly (not BookEntryView)
 #[component]
 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 = true)] show_author: bool,
     #[props(default)] on_pinned_changed: Option<EventHandler<bool>>,
 ) -> Element {
     use crate::Route;
···
     // Format date from record's created_at
     let formatted_date = entry.created_at.as_ref().format("%B %d, %Y").to_string();
 
-    // Get first author
-    let first_author = entry_view.authors.first();
+    // Get first author if we're showing it
+    let first_author = if show_author { entry_view.authors.first() } else { None };
 
     // Check ownership for actions
     let auth_state = use_context::<Signal<AuthState>>();
···
 
     rsx! {
         div { class: "entry-card feed-entry-card",
-            // Title
-            Link {
-                to: Route::StandaloneEntry {
-                    ident: ident.clone(),
-                    rkey: rkey.clone().into()
-                },
-                class: "entry-card-title-link",
-                h3 { class: "entry-card-title", "{title}" }
+            // Header: title (and date if no author)
+            div { class: "entry-card-header",
+                Link {
+                    to: Route::StandaloneEntry {
+                        ident: ident.clone(),
+                        rkey: rkey.clone().into()
+                    },
+                    class: "entry-card-title-link",
+                    h3 { class: "entry-card-title", "{title}" }
+                }
+                // Date inline with title when no author shown
+                if first_author.is_none() {
+                    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
+                    }
+                }
             }
 
-            // Byline: author + date
-            div { class: "entry-card-byline",
-                if let Some(author) = first_author {
+            // Byline: author + date (only when author shown)
+            if let Some(author) = first_author {
+                div { class: "entry-card-byline",
                     {
                         match &author.record.inner {
                             ProfileDataViewInner::ProfileView(profile) => {
···
                                 rsx! {
                                     Link {
                                         to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
-                                        class: "entry-card-author",
+                                        class: "embed-author entry-card-author",
                                         if let Some(ref avatar_url) = profile.avatar {
-                                            Avatar {
-                                                AvatarImage { src: avatar_url.as_ref() }
-                                            }
+                                            img { class: "embed-avatar", src: avatar_url.as_ref(), alt: "" }
                                         }
-                                        span { class: "author-name", "{display_name}" }
-                                        span { class: "meta-label", "@{handle}" }
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-name", "{display_name}" }
+                                            span { class: "embed-author-handle", "@{handle}" }
+                                        }
                                     }
                                 }
                             }
···
                                 rsx! {
                                     Link {
                                         to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
-                                        class: "entry-card-author",
+                                        class: "embed-author entry-card-author",
                                         if let Some(ref avatar_url) = profile.avatar {
-                                            Avatar {
-                                                AvatarImage { src: avatar_url.as_ref() }
-                                            }
+                                            img { class: "embed-avatar", src: avatar_url.as_ref(), alt: "" }
                                         }
-                                        span { class: "author-name", "{display_name}" }
-                                        span { class: "meta-label", "@{handle}" }
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-name", "{display_name}" }
+                                            span { class: "embed-author-handle", "@{handle}" }
+                                        }
                                     }
                                 }
                             }
···
                                 rsx! {
                                     Link {
                                         to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
-                                        class: "entry-card-author",
-                                        span { class: "author-name", "@{handle}" }
+                                        class: "embed-author entry-card-author",
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-handle", "@{handle}" }
+                                        }
                                     }
                                 }
                             }
                             _ => {
                                 rsx! {
-                                    div { class: "entry-card-author",
-                                        span { class: "author-name", "Unknown" }
+                                    span { class: "embed-author entry-card-author",
+                                        span { class: "embed-author-info",
+                                            span { class: "embed-author-name", "Unknown" }
+                                        }
                                     }
                                 }
                             }
                         }
                     }
-                }
-                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-date",
+                        time { datetime: "{entry.created_at.as_str()}", "{formatted_date}" }
                     }
                 }
             }
···
                                         rsx! {
                                             Link {
                                                 to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
-                                                div { class: "entry-authors",
-                                                    if let Some(ref avatar_url) = profile.avatar {
-                                                        Avatar {
-                                                            AvatarImage {
-                                                                src: avatar_url.as_ref()
-                                                            }
-                                                        }
-                                                    }
-                                                    span { class: "author-name", "{display_name}" }
-                                                    span { class: "meta-label", "@{handle}" }
+                                                class: "embed-author",
+                                                if let Some(ref avatar_url) = profile.avatar {
+                                                    img { class: "embed-avatar", src: avatar_url.as_ref(), alt: "" }
+                                                }
+                                                span { class: "embed-author-info",
+                                                    span { class: "embed-author-name", "{display_name}" }
+                                                    span { class: "embed-author-handle", "@{handle}" }
                                                 }
                                             }
                                         }
···
                                         rsx! {
                                             Link {
                                                 to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
-                                                div { class: "entry-authors",
-                                                    if let Some(ref avatar_url) = profile.avatar {
-                                                        Avatar {
-                                                            AvatarImage {
-                                                                src: avatar_url.as_ref()
-                                                            }
-                                                        }
-                                                    }
-                                                    span { class: "author-name", "{display_name}" }
-                                                    span { class: "meta-label", "@{handle}" }
+                                                class: "embed-author",
+                                                if let Some(ref avatar_url) = profile.avatar {
+                                                    img { class: "embed-avatar", src: avatar_url.as_ref(), alt: "" }
+                                                }
+                                                span { class: "embed-author-info",
+                                                    span { class: "embed-author-name", "{display_name}" }
+                                                    span { class: "embed-author-handle", "@{handle}" }
                                                 }
                                             }
                                         }
                                     }
                                     ProfileDataViewInner::TangledProfileView(profile) => {
                                         rsx! {
-                                            span { class: "author-name", "@{profile.handle.as_ref()}" }
+                                            span { class: "embed-author",
+                                                span { class: "embed-author-info",
+                                                    span { class: "embed-author-handle", "@{profile.handle.as_ref()}" }
+                                                }
+                                            }
                                         }
                                     }
                                     _ => {
                                         rsx! {
-                                            span { class: "author-name", "Unknown" }
+                                            span { class: "embed-author",
+                                                span { class: "embed-author-info",
+                                                    span { class: "embed-author-name", "Unknown" }
+                                                }
+                                            }
                                         }
                                     }
                                 }

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

···
     }
 }
 
-const NOTEBOOK_CARD_CSS: Asset = asset!("/assets/styling/notebook-card.css");
+// Card styles (entry-card, notebook-card) loaded at navbar level
 const ENTRY_CSS: Asset = asset!("/assets/styling/entry.css");
-const ENTRY_CARD_CSS: Asset = asset!("/assets/styling/entry-card.css");
+const LAYOUTS_CSS: Asset = asset!("/assets/styling/layouts.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: LAYOUTS_CSS }
         document::Link { rel: "stylesheet", href: ENTRY_CSS }
-        document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
         div {
             Outlet::<Route> {}
         }
···
     };
 
     rsx! {
-        document::Stylesheet { href: NOTEBOOK_CARD_CSS }
         {og_meta}
 
         div { class: "repository-layout",
···
                                                                 entry_view: entry_view.clone(),
                                                                 entry: entry.clone(),
                                                                 show_actions: true,
-                                                                is_pinned: true
+                                                                is_pinned: true,
+                                                                show_author: false
                                                             }
                                                         }
                                                     }
···
                                                             entry_view: entry_view.clone(),
                                                             entry: entry.clone(),
                                                             show_actions: true,
-                                                            is_pinned: false
+                                                            is_pinned: false,
+                                                            show_author: false
                                                         }
                                                     }
                                                 }
···
     notebook: NotebookView<'static>,
     entry_refs: Vec<StrongRef<'static>>,
     #[props(default = false)] is_pinned: bool,
+    #[props(default)] show_author: Option<bool>,
     #[props(default)] on_pinned_changed: Option<EventHandler<bool>>,
     #[props(default)] on_deleted: Option<EventHandler<()>>,
 ) -> Element {
···
     // Format date
     let formatted_date = notebook.indexed_at.as_ref().format("%B %d, %Y").to_string();
 
-    // Show authors only if multiple
-    let show_authors = notebook.authors.len() > 1;
+    // Show authors: explicit prop overrides, otherwise show only if multiple
+    let show_authors = show_author.unwrap_or(notebook.authors.len() > 1);
 
     let ident = notebook.uri.authority().clone().into_static();
     let book_title: SmolStr = notebook_path.clone().into();

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

···
 #![allow(non_snake_case)]
 
 use crate::Route;
-use crate::components::avatar::{Avatar, AvatarImage};
 use crate::components::button::{Button, ButtonVariant};
 use dioxus::prelude::*;
 use jacquard::smol_str::SmolStr;
···
                 .unwrap_or("Unknown");
 
             rsx! {
-                div { class: "notebook-author",
+                span { class: "embed-author notebook-author",
                     if let Some(ref avatar) = p.avatar {
-                        Avatar {
-                            AvatarImage { src: avatar.as_ref() }
-                        }
+                        img { class: "embed-avatar", src: avatar.as_ref(), alt: "" }
                     }
-                    div { class: "notebook-author-info",
-                        div { class: "notebook-author-name", "{display_name}" }
-                        div { class: "notebook-author-handle", "@{p.handle}" }
+                    span { class: "embed-author-info",
+                        span { class: "embed-author-name", "{display_name}" }
+                        span { class: "embed-author-handle", "@{p.handle}" }
                     }
                 }
             }
···
                 .unwrap_or("Unknown");
 
             rsx! {
-                div { class: "notebook-author",
+                span { class: "embed-author notebook-author",
                     if let Some(ref avatar) = p.avatar {
-                        Avatar {
-                            AvatarImage { src: avatar.as_ref() }
-                        }
+                        img { class: "embed-avatar", src: avatar.as_ref(), alt: "" }
                     }
-                    div { class: "notebook-author-info",
-                        div { class: "notebook-author-name", "{display_name}" }
-                        div { class: "notebook-author-handle", "@{p.handle}" }
+                    span { class: "embed-author-info",
+                        span { class: "embed-author-name", "{display_name}" }
+                        span { class: "embed-author-handle", "@{p.handle}" }
                     }
                 }
             }
         }
         ProfileDataViewInner::TangledProfileView(p) => {
             rsx! {
-                div { class: "notebook-author",
-                    div { class: "notebook-author-name", "@{p.handle.as_ref()}" }
+                span { class: "embed-author notebook-author",
+                    span { class: "embed-author-info",
+                        span { class: "embed-author-handle", "@{p.handle.as_ref()}" }
+                    }
                 }
             }
         }
         _ => rsx! {
-            div { class: "notebook-author",
-                "Unknown author"
+            span { class: "embed-author notebook-author",
+                span { class: "embed-author-info",
+                    span { class: "embed-author-name", "Unknown" }
+                }
             }
         },
     }

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

···
                     default_open: true,
                     index: 0,
                     AccordionTrigger {
-                        div { class: "section-header",
+                        div { class: "record-section-header",
                             div { class: "section-label",
                                 {
                                     let parts: Vec<&str> = path.split('.').collect();
···
                         default_open: true,
                         index: 0,
                         AccordionTrigger {
-                            div { class: "section-header",
+                            div { class: "record-section-header",
                                 div { class: "section-label",
                                     {
                                         let parts: Vec<&str> = path.split('.').collect();

crates/weaver-app/src/main.rs

···
 
     rsx! {
         document::Link { rel: "icon", href: FAVICON }
-        document::Link { rel: "stylesheet", href: MAIN_CSS }
-        document::Link { rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&family=IBM+Plex+Sans:ital,wght@0,100..700;1,100..700&family=IBM+Plex+Serif:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&display=swap" }
+        // Preconnect for external fonts (before loading them)
         document::Link { rel: "preconnect", href: "https://fonts.googleapis.com" }
         document::Link { rel: "preconnect", href: "https://fonts.gstatic.com" }
-
+        // Theme defaults first: CSS variables, font-faces, reset
         document::Link { rel: "stylesheet", href: THEME_DEFAULTS_CSS }
+        document::Link { rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&family=IBM+Plex+Sans:ital,wght@0,100..700;1,100..700&family=IBM+Plex+Serif:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&display=swap" }
+        // App shell styles (depends on theme variables)
+        document::Link { rel: "stylesheet", href: MAIN_CSS }
         components::toast::ToastProvider {
             Router::<Route> {}
         }

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

···
     }
 }
 
-const NOTEBOOK_CARD_CSS: Asset = asset!("/assets/styling/notebook-card.css");
+// Card styles (entry-card, notebook-card) loaded at navbar level
 const ENTRY_CSS: Asset = asset!("/assets/styling/entry.css");
-const ENTRY_CARD_CSS: Asset = asset!("/assets/styling/entry-card.css");
 const HOME_CSS: Asset = asset!("/assets/styling/home.css");
 
 /// The Home page component that will be rendered when the current route is `[Route::Home]`
···
         SiteOgMeta {}
 
         document::Link { rel: "stylesheet", href: HOME_CSS }
-        document::Link { rel: "stylesheet", href: NOTEBOOK_CARD_CSS }
         document::Link { rel: "stylesheet", href: ENTRY_CSS }
-        document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
         DefaultNotebookCss {  }
         div {
             class: "home-container",
···
         Some((view, entries)) => rsx! {
             NotebookCard {
                 notebook: view.clone(),
-                entry_refs: entries.clone()
+                entry_refs: entries.clone(),
+                show_author: Some(true)
             }
         },
         None => rsx! {

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

···
 use jacquard::types::string::Did;
 
 const NAVBAR_CSS: Asset = asset!("/assets/styling/navbar.css");
+const CARDS_BASE_CSS: Asset = asset!("/assets/styling/cards-base.css");
+const ENTRY_CARD_CSS: Asset = asset!("/assets/styling/entry-card.css");
+const NOTEBOOK_CARD_CSS: Asset = asset!("/assets/styling/notebook-card.css");
 
 /// The Navbar component that will be rendered on all pages of our app since every page is under the layout.
 ///
···
     rsx! {
         document::Link { rel: "stylesheet", href: NAVBAR_CSS }
         document::Link { rel: "stylesheet", href: asset!("/assets/styling/button.css") }
+        document::Link { rel: "stylesheet", href: CARDS_BASE_CSS }
+        document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
+        document::Link { rel: "stylesheet", href: NOTEBOOK_CARD_CSS }
         div {
             id: "navbar",
             nav { class: "breadcrumbs",

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

···
     }
 }
 
-const ENTRY_CARD_CSS: Asset = asset!("/assets/styling/entry-card.css");
+// Card styles loaded at navbar level
+const LAYOUTS_CSS: Asset = asset!("/assets/styling/layouts.css");
 
 /// The Blog page component that will be rendered when the current route is `[Route::Blog]`
 ///
···
     };
 
     rsx! {
-        document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
+        document::Link { rel: "stylesheet", href: LAYOUTS_CSS }
 
         match (&*notebook_data.read(), &*entries_resource.read()) {
             (Some(data), Some(entries)) => {

crates/weaver-renderer/src/css.rs

···
 use crate::theme::{ResolvedTheme, ThemeDarkCodeTheme, ThemeLightCodeTheme};
 use miette::IntoDiagnostic;
+use smol_str::format_smolstr;
 use std::io::Cursor;
 use syntect::highlighting::ThemeSet;
 use syntect::html::{ClassStyle, css_for_theme_with_class_style};
 use weaver_api::com_atproto::sync::get_blob::GetBlob;
+use weaver_api::sh_weaver::notebook::theme::FontValue;
 use weaver_common::jacquard::client::BasicClient;
 use weaver_common::jacquard::prelude::*;
 use weaver_common::jacquard::xrpc::XrpcExt;
···
     let light = &theme.light_scheme;
     let fonts = &theme.fonts;
     let spacing = &theme.spacing;
+
+    // interim until handle fonts from blobs
+    let body = fonts
+        .body
+        .iter()
+        .filter_map(|f| match &f.value {
+            FontValue::FontName(cow_str) => Some(format_smolstr!("'{cow_str}'")),
+            FontValue::FontFile(_font_file) => None,
+            FontValue::Unknown(_data) => None,
+        })
+        .collect::<Vec<_>>()
+        .join(",");
+    let monospace = fonts
+        .monospace
+        .iter()
+        .filter_map(|f| match &f.value {
+            FontValue::FontName(cow_str) => Some(format_smolstr!("'{cow_str}'")),
+            FontValue::FontFile(_font_file) => None,
+            FontValue::Unknown(_data) => None,
+        })
+        .collect::<Vec<_>>()
+        .join(",");
+    let heading = fonts
+        .heading
+        .iter()
+        .filter_map(|f| match &f.value {
+            FontValue::FontName(cow_str) => Some(format_smolstr!("'{cow_str}'")),
+            FontValue::FontFile(_font_file) => None,
+            FontValue::Unknown(_data) => None,
+        })
+        .collect::<Vec<_>>()
+        .join(",");
 
     format!(
         r#"/* CSS Reset */
···
         light.link,
         light.highlight,
         // Fonts and spacing
-        fonts.body,
-        fonts.heading,
-        fonts.monospace,
+        body,
+        heading,
+        monospace,
         spacing.base_size,
         spacing.line_height,
         spacing.scale,

crates/weaver-renderer/src/theme.rs

···
 use miette::IntoDiagnostic;
 pub use weaver_api::sh_weaver::notebook::colour_scheme::{ColourScheme, ColourSchemeColours};
+use weaver_api::sh_weaver::notebook::theme::Font;
+use weaver_api::sh_weaver::notebook::theme::FontName;
+use weaver_api::sh_weaver::notebook::theme::FontValue;
 pub use weaver_api::sh_weaver::notebook::theme::{
     Theme, ThemeDarkCodeTheme, ThemeFonts, ThemeLightCodeTheme, ThemeSpacing,
 };
···
 pub fn default_fonts() -> ThemeFonts<'static> {
     ThemeFonts {
         // Serif for body text, sans for headings/UI
-        body: CowStr::new_static(
-            "'Adobe Caslon Pro', 'Latin Modern Roman',  'CM Serif', Georgia, serif",
-        ),
-        heading: CowStr::new_static(
-            "'IBM Plex Sans', 'CM Sans','Junction', 'Proza Libre',   system-ui, sans-serif",
-        ),
-        monospace: CowStr::new_static(
-            "'Ioskeley Mono', 'IBM Plex Mono', 'Berkeley Mono', Consolas, monospace",
-        ),
-        ..Default::default()
+        body: vec![
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("Adobe Caslon Pro").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("Latin Modern Roman").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("Times New Roman").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(CowStr::new_static("serif").into()))
+                .build(),
+        ],
+        heading: vec![
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("IBM Plex Sans").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(CowStr::new_static("system-ui").into()))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(CowStr::new_static("sans-serif").into()))
+                .build(),
+        ],
+        monospace: vec![
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("Ioskeley Mono").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("IBM Plex Mono").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(
+                    CowStr::new_static("Berkeley Mono").into(),
+                ))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(CowStr::new_static("Consolas").into()))
+                .build(),
+            Font::new()
+                .value(FontValue::FontName(CowStr::new_static("monospace").into()))
+                .build(),
+        ],
+        extra_data: None,
     }
 }
 

lexicons/notebook/theme.json

···
           "fonts": {
             "type": "object",
             "required": ["body", "heading", "monospace"],
-            "description": "Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults."
+            "description": "Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults.",
             "properties": {
               "body": {
                 "type": "array",
···
     },
     "codeThemeFile": {
       "type": "object",
-      "required": ["name", "content"],
+      "required": ["name", "did", "content"],
       "description": "Custom syntax highlighting theme file (sublime text/textmate theme format)",
       "properties": {
         "name": {
           "type": "string"
+        },
+        "did": {
+          "type": "string",
+          "format": "did"
         },
         "content": {
           "type": "blob",
···
     },
     "fontFile": {
       "type": "object",
-      "required": ["name", "content"],
-      "description": "Custom woff(2) or ttf font file"
+      "required": ["name", "did", "content"],
+      "description": "Custom woff(2) or ttf font file",
       "properties": {
         "name": {
           "type": "string"
+        },
+        "did": {
+          "type": "string",
+          "format": "did"
         },
         "content": {
           "type": "blob",