css fetch/cache

Cargo.lock

···
  "tokio-util",
  "unicode-normalization",
  "url",
+ "weaver-api",
  "weaver-common",
  "yaml-rust2",
 ]
···
 name = "weaver-server"
 version = "0.1.0"
 dependencies = [
+ "axum",
  "dashmap 6.1.0",
  "dioxus",
  "dioxus-primitives",
···
  "moka",
  "weaver-api",
  "weaver-common",
+ "weaver-renderer",
 ]
 
 [[package]]

crates/weaver-api/lexicons/sh_weaver_embed_video.json

···
           "maxLength": 10000,
           "maxGraphemes": 1000
         },
-        "aspectRatio": {
-          "type": "ref",
-          "ref": "app.bsky.embed.defs#aspectRatio"
-        },
         "captions": {
           "type": "array",
           "items": {
···
             "ref": "#caption"
           },
           "maxLength": 20
+        },
+        "dimensions": {
+          "type": "union",
+          "refs": [
+            "app.bsky.embed.defs#aspectRatio",
+            "sh.weaver.embed.defs#percentSize",
+            "sh.weaver.embed.defs#pixelSize"
+          ]
+        },
+        "name": {
+          "type": "string",
+          "maxLength": 128
         },
         "video": {
           "type": "blob",
···
           "maxLength": 10000,
           "maxGraphemes": 1000
         },
-        "aspectRatio": {
-          "type": "ref",
-          "ref": "app.bsky.embed.defs#aspectRatio"
-        },
         "cid": {
           "type": "string",
           "format": "cid"
+        },
+        "dimensions": {
+          "type": "union",
+          "refs": [
+            "app.bsky.embed.defs#aspectRatio",
+            "sh.weaver.embed.defs#percentSize",
+            "sh.weaver.embed.defs#pixelSize"
+          ]
+        },
+        "name": {
+          "type": "string",
+          "maxLength": 128
         },
         "playlist": {
           "type": "string",

crates/weaver-api/lexicons/sh_weaver_notebook_book.json

···
             "type": "ref",
             "ref": "sh.weaver.notebook.defs#tags"
           },
+          "theme": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          },
           "title": {
             "type": "ref",
             "ref": "sh.weaver.notebook.defs#title"

crates/weaver-api/lexicons/sh_weaver_notebook_theme.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.theme",
+  "defs": {
+    "codeThemeFile": {
+      "type": "object",
+      "required": [
+        "name",
+        "did",
+        "content"
+      ],
+      "properties": {
+        "content": {
+          "type": "blob",
+          "accept": [
+            "*/*"
+          ],
+          "maxSize": 20000
+        },
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "codeThemeName": {
+      "type": "string"
+    },
+    "main": {
+      "type": "record",
+      "description": "Theme for a notebook",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "colours",
+          "fonts",
+          "spacing",
+          "codeTheme"
+        ],
+        "properties": {
+          "codeTheme": {
+            "type": "union",
+            "refs": [
+              "#codeThemeName",
+              "#codeThemeFile"
+            ]
+          },
+          "colours": {
+            "type": "object",
+            "required": [
+              "background",
+              "foreground",
+              "primary",
+              "secondary",
+              "link",
+              "link_hover"
+            ],
+            "properties": {
+              "background": {
+                "type": "string"
+              },
+              "foreground": {
+                "type": "string"
+              },
+              "link": {
+                "type": "string"
+              },
+              "link_hover": {
+                "type": "string"
+              },
+              "primary": {
+                "type": "string"
+              },
+              "secondary": {
+                "type": "string"
+              }
+            }
+          },
+          "fonts": {
+            "type": "object",
+            "required": [
+              "body",
+              "heading",
+              "monospace"
+            ],
+            "properties": {
+              "body": {
+                "type": "string"
+              },
+              "heading": {
+                "type": "string"
+              },
+              "monospace": {
+                "type": "string"
+              }
+            }
+          },
+          "spacing": {
+            "type": "object",
+            "required": [
+              "baseSize",
+              "lineHeight",
+              "scale"
+            ],
+            "properties": {
+              "baseSize": {
+                "type": "string"
+              },
+              "lineHeight": {
+                "type": "string"
+              },
+              "scale": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

crates/weaver-api/src/sh_weaver/embed/video.rs

···
                             }),
                         );
                         map.insert(
-                            ::jacquard_common::smol_str::SmolStr::new_static(
-                                "aspectRatio",
-                            ),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
-                                description: None,
-                                r#ref: ::jacquard_common::CowStr::new_static(
-                                    "app.bsky.embed.defs#aspectRatio",
-                                ),
-                            }),
-                        );
-                        map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static("captions"),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
                                 description: None,
···
                             }),
                         );
                         map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "dimensions",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
+                                description: None,
+                                refs: vec![
+                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.defs#aspectRatio"),
+                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.defs#percentSize"),
+                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.defs#pixelSize")
+                                ],
+                                closed: 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: Some(128usize),
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
+                        map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static("video"),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
                                 description: None,
···
                             }),
                         );
                         map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static("cid"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: None,
+                                format: Some(
+                                    ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                ),
+                                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(
-                                "aspectRatio",
+                                "dimensions",
                             ),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
                                 description: None,
-                                r#ref: ::jacquard_common::CowStr::new_static(
-                                    "app.bsky.embed.defs#aspectRatio",
-                                ),
+                                refs: vec![
+                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.defs#aspectRatio"),
+                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.defs#percentSize"),
+                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.defs#pixelSize")
+                                ],
+                                closed: None,
                             }),
                         );
                         map.insert(
-                            ::jacquard_common::smol_str::SmolStr::new_static("cid"),
+                            ::jacquard_common::smol_str::SmolStr::new_static("name"),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
                                 description: None,
-                                format: Some(
-                                    ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
-                                ),
+                                format: None,
                                 default: None,
                                 min_length: None,
-                                max_length: None,
+                                max_length: Some(128usize),
                                 min_graphemes: None,
                                 max_graphemes: None,
                                 r#enum: None,
···
     pub alt: Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub aspect_ratio: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+    pub captions: Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub dimensions: Option<VideoDimensions<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub captions: Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
+    pub name: Option<jacquard_common::CowStr<'a>>,
     /// The mp4 video file. May be up to 100mb, formerly limited to 50mb.
     #[serde(borrow)]
     pub video: jacquard_common::types::blob::BlobRef<'a>,
···
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
         ::core::option::Option<jacquard_common::CowStr<'a>>,
-        ::core::option::Option<crate::app_bsky::embed::AspectRatio<'a>>,
         ::core::option::Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
+        ::core::option::Option<VideoDimensions<'a>>,
+        ::core::option::Option<jacquard_common::CowStr<'a>>,
         ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
···
     pub fn new() -> Self {
         VideoBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None),
+            __unsafe_private_named: (None, None, None, None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
 }
 
 impl<'a, S: video_state::State> VideoBuilder<'a, S> {
-    /// Set the `aspectRatio` field (optional)
-    pub fn aspect_ratio(
+    /// Set the `captions` field (optional)
+    pub fn captions(
         mut self,
-        value: impl Into<Option<crate::app_bsky::embed::AspectRatio<'a>>>,
+        value: impl Into<Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>>,
     ) -> Self {
         self.__unsafe_private_named.1 = value.into();
         self
     }
-    /// Set the `aspectRatio` field to an Option value (optional)
-    pub fn maybe_aspect_ratio(
+    /// Set the `captions` field to an Option value (optional)
+    pub fn maybe_captions(
         mut self,
-        value: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+        value: Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
     ) -> Self {
         self.__unsafe_private_named.1 = value;
         self
···
 }
 
 impl<'a, S: video_state::State> VideoBuilder<'a, S> {
-    /// Set the `captions` field (optional)
-    pub fn captions(
-        mut self,
-        value: impl Into<Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>>,
-    ) -> Self {
+    /// Set the `dimensions` field (optional)
+    pub fn dimensions(mut self, value: impl Into<Option<VideoDimensions<'a>>>) -> Self {
         self.__unsafe_private_named.2 = value.into();
         self
     }
-    /// Set the `captions` field to an Option value (optional)
-    pub fn maybe_captions(
+    /// Set the `dimensions` field to an Option value (optional)
+    pub fn maybe_dimensions(mut self, value: Option<VideoDimensions<'a>>) -> Self {
+        self.__unsafe_private_named.2 = value;
+        self
+    }
+}
+
+impl<'a, S: video_state::State> VideoBuilder<'a, S> {
+    /// Set the `name` field (optional)
+    pub fn name(
         mut self,
-        value: Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
+        value: impl Into<Option<jacquard_common::CowStr<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.2 = value;
+        self.__unsafe_private_named.3 = value.into();
+        self
+    }
+    /// Set the `name` field to an Option value (optional)
+    pub fn maybe_name(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
+        self.__unsafe_private_named.3 = value;
         self
     }
 }
···
         mut self,
         value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
     ) -> VideoBuilder<'a, video_state::SetVideo<S>> {
-        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
         VideoBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
     pub fn build(self) -> Video<'a> {
         Video {
             alt: self.__unsafe_private_named.0,
-            aspect_ratio: self.__unsafe_private_named.1,
-            captions: self.__unsafe_private_named.2,
-            video: self.__unsafe_private_named.3.unwrap(),
+            captions: self.__unsafe_private_named.1,
+            dimensions: self.__unsafe_private_named.2,
+            name: self.__unsafe_private_named.3,
+            video: self.__unsafe_private_named.4.unwrap(),
             extra_data: Default::default(),
         }
     }
···
     ) -> Video<'a> {
         Video {
             alt: self.__unsafe_private_named.0,
-            aspect_ratio: self.__unsafe_private_named.1,
-            captions: self.__unsafe_private_named.2,
-            video: self.__unsafe_private_named.3.unwrap(),
+            captions: self.__unsafe_private_named.1,
+            dimensions: self.__unsafe_private_named.2,
+            name: self.__unsafe_private_named.3,
+            video: self.__unsafe_private_named.4.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 VideoDimensions<'a> {
+    #[serde(rename = "app.bsky.embed.defs#aspectRatio")]
+    AspectRatio(Box<crate::app_bsky::embed::AspectRatio<'a>>),
+    #[serde(rename = "sh.weaver.embed.defs#percentSize")]
+    PercentSize(Box<crate::sh_weaver::embed::PercentSize<'a>>),
+    #[serde(rename = "sh.weaver.embed.defs#pixelSize")]
+    PixelSize(Box<crate::sh_weaver::embed::PixelSize<'a>>),
+}
+
 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Video<'a> {
     fn nsid() -> &'static str {
         "sh.weaver.embed.video"
···
                 });
             }
         }
+        if let Some(ref value) = self.name {
+            #[allow(unused_comparisons)]
+            if <str>::len(value.as_ref()) > 128usize {
+                return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
+                    path: ::jacquard_lexicon::validation::ValidationPath::from_field(
+                        "name",
+                    ),
+                    max: 128usize,
+                    actual: <str>::len(value.as_ref()),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub alt: Option<jacquard_common::CowStr<'a>>,
+    #[serde(borrow)]
+    pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub aspect_ratio: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+    pub dimensions: Option<ViewDimensions<'a>>,
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub cid: jacquard_common::types::string::Cid<'a>,
+    pub name: Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub playlist: jacquard_common::types::string::Uri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
···
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
         ::core::option::Option<jacquard_common::CowStr<'a>>,
-        ::core::option::Option<crate::app_bsky::embed::AspectRatio<'a>>,
         ::core::option::Option<jacquard_common::types::string::Cid<'a>>,
+        ::core::option::Option<ViewDimensions<'a>>,
+        ::core::option::Option<jacquard_common::CowStr<'a>>,
         ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
         ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
     ),
···
     pub fn new() -> Self {
         ViewBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None, None),
+            __unsafe_private_named: (None, None, None, None, None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
     }
 }
 
-impl<'a, S: view_state::State> ViewBuilder<'a, S> {
-    /// Set the `aspectRatio` field (optional)
-    pub fn aspect_ratio(
-        mut self,
-        value: impl Into<Option<crate::app_bsky::embed::AspectRatio<'a>>>,
-    ) -> Self {
-        self.__unsafe_private_named.1 = value.into();
-        self
-    }
-    /// Set the `aspectRatio` field to an Option value (optional)
-    pub fn maybe_aspect_ratio(
-        mut self,
-        value: Option<crate::app_bsky::embed::AspectRatio<'a>>,
-    ) -> Self {
-        self.__unsafe_private_named.1 = value;
-        self
-    }
-}
-
 impl<'a, S> ViewBuilder<'a, S>
 where
     S: view_state::State,
···
         mut self,
         value: impl Into<jacquard_common::types::string::Cid<'a>>,
     ) -> ViewBuilder<'a, view_state::SetCid<S>> {
-        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
         ViewBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
     }
 }
 
+impl<'a, S: view_state::State> ViewBuilder<'a, S> {
+    /// Set the `dimensions` field (optional)
+    pub fn dimensions(mut self, value: impl Into<Option<ViewDimensions<'a>>>) -> Self {
+        self.__unsafe_private_named.2 = value.into();
+        self
+    }
+    /// Set the `dimensions` field to an Option value (optional)
+    pub fn maybe_dimensions(mut self, value: Option<ViewDimensions<'a>>) -> Self {
+        self.__unsafe_private_named.2 = value;
+        self
+    }
+}
+
+impl<'a, S: view_state::State> ViewBuilder<'a, S> {
+    /// Set the `name` field (optional)
+    pub fn name(
+        mut self,
+        value: impl Into<Option<jacquard_common::CowStr<'a>>>,
+    ) -> Self {
+        self.__unsafe_private_named.3 = value.into();
+        self
+    }
+    /// Set the `name` field to an Option value (optional)
+    pub fn maybe_name(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
+        self.__unsafe_private_named.3 = value;
+        self
+    }
+}
+
 impl<'a, S> ViewBuilder<'a, S>
 where
     S: view_state::State,
···
         mut self,
         value: impl Into<jacquard_common::types::string::Uri<'a>>,
     ) -> ViewBuilder<'a, view_state::SetPlaylist<S>> {
-        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
         ViewBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
         mut self,
         value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.4 = value.into();
+        self.__unsafe_private_named.5 = value.into();
         self
     }
     /// Set the `thumbnail` field to an Option value (optional)
···
         mut self,
         value: Option<jacquard_common::types::string::Uri<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.4 = value;
+        self.__unsafe_private_named.5 = value;
         self
     }
 }
···
     pub fn build(self) -> View<'a> {
         View {
             alt: self.__unsafe_private_named.0,
-            aspect_ratio: self.__unsafe_private_named.1,
-            cid: self.__unsafe_private_named.2.unwrap(),
-            playlist: self.__unsafe_private_named.3.unwrap(),
-            thumbnail: self.__unsafe_private_named.4,
+            cid: self.__unsafe_private_named.1.unwrap(),
+            dimensions: self.__unsafe_private_named.2,
+            name: self.__unsafe_private_named.3,
+            playlist: self.__unsafe_private_named.4.unwrap(),
+            thumbnail: self.__unsafe_private_named.5,
             extra_data: Default::default(),
         }
     }
···
     ) -> View<'a> {
         View {
             alt: self.__unsafe_private_named.0,
-            aspect_ratio: self.__unsafe_private_named.1,
-            cid: self.__unsafe_private_named.2.unwrap(),
-            playlist: self.__unsafe_private_named.3.unwrap(),
-            thumbnail: self.__unsafe_private_named.4,
+            cid: self.__unsafe_private_named.1.unwrap(),
+            dimensions: self.__unsafe_private_named.2,
+            name: self.__unsafe_private_named.3,
+            playlist: self.__unsafe_private_named.4.unwrap(),
+            thumbnail: self.__unsafe_private_named.5,
             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 ViewDimensions<'a> {
+    #[serde(rename = "app.bsky.embed.defs#aspectRatio")]
+    AspectRatio(Box<crate::app_bsky::embed::AspectRatio<'a>>),
+    #[serde(rename = "sh.weaver.embed.defs#percentSize")]
+    PercentSize(Box<crate::sh_weaver::embed::PercentSize<'a>>),
+    #[serde(rename = "sh.weaver.embed.defs#pixelSize")]
+    PixelSize(Box<crate::sh_weaver::embed::PixelSize<'a>>),
 }
 
 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for View<'a> {
···
                         actual: count,
                     });
                 }
+            }
+        }
+        if let Some(ref value) = self.name {
+            #[allow(unused_comparisons)]
+            if <str>::len(value.as_ref()) > 128usize {
+                return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
+                    path: ::jacquard_lexicon::validation::ValidationPath::from_field(
+                        "name",
+                    ),
+                    max: 128usize,
+                    actual: <str>::len(value.as_ref()),
+                });
             }
         }
         Ok(())

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

···
 pub mod chapter;
 pub mod entry;
 pub mod page;
+pub mod theme;
 
 #[jacquard_derive::lexicon]
 #[derive(

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

···
     pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
+    pub theme: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
     pub title: Option<crate::sh_weaver::notebook::Title<'a>>,
 }
 
···
         ::core::option::Option<jacquard_common::types::string::Datetime>,
         ::core::option::Option<Vec<crate::com_atproto::repo::strong_ref::StrongRef<'a>>>,
         ::core::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
+        ::core::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
         ::core::option::Option<crate::sh_weaver::notebook::Title<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
···
     pub fn new() -> Self {
         BookBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None, None),
+            __unsafe_private_named: (None, None, None, None, None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
 }
 
 impl<'a, S: book_state::State> BookBuilder<'a, S> {
+    /// Set the `theme` field (optional)
+    pub fn theme(
+        mut self,
+        value: impl Into<Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>>,
+    ) -> Self {
+        self.__unsafe_private_named.4 = value.into();
+        self
+    }
+    /// Set the `theme` field to an Option value (optional)
+    pub fn maybe_theme(
+        mut self,
+        value: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    ) -> Self {
+        self.__unsafe_private_named.4 = value;
+        self
+    }
+}
+
+impl<'a, S: book_state::State> BookBuilder<'a, S> {
     /// Set the `title` field (optional)
     pub fn title(
         mut self,
         value: impl Into<Option<crate::sh_weaver::notebook::Title<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.4 = value.into();
+        self.__unsafe_private_named.5 = value.into();
         self
     }
     /// Set the `title` field to an Option value (optional)
···
         mut self,
         value: Option<crate::sh_weaver::notebook::Title<'a>>,
     ) -> Self {
-        self.__unsafe_private_named.4 = value;
+        self.__unsafe_private_named.5 = value;
         self
     }
 }
···
             created_at: self.__unsafe_private_named.1,
             entry_list: self.__unsafe_private_named.2.unwrap(),
             tags: self.__unsafe_private_named.3,
-            title: self.__unsafe_private_named.4,
+            theme: self.__unsafe_private_named.4,
+            title: self.__unsafe_private_named.5,
             extra_data: Default::default(),
         }
     }
···
             created_at: self.__unsafe_private_named.1,
             entry_list: self.__unsafe_private_named.2.unwrap(),
             tags: self.__unsafe_private_named.3,
-            title: self.__unsafe_private_named.4,
+            theme: self.__unsafe_private_named.4,
+            title: self.__unsafe_private_named.5,
             extra_data: Some(extra_data),
         }
     }
···
                                     description: None,
                                     r#ref: ::jacquard_common::CowStr::new_static(
                                         "sh.weaver.notebook.defs#tags",
+                                    ),
+                                }),
+                            );
+                            map.insert(
+                                ::jacquard_common::smol_str::SmolStr::new_static("theme"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
+                                    description: None,
+                                    r#ref: ::jacquard_common::CowStr::new_static(
+                                        "com.atproto.repo.strongRef",
                                     ),
                                 }),
                             );

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

···
+// @generated by jacquard-lexicon. DO NOT EDIT.
+//
+// Lexicon: sh.weaver.notebook.theme
+//
+// This file was automatically generated from Lexicon schemas.
+// Any manual changes will be overwritten on the next regeneration.
+
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct CodeThemeFile<'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 code_theme_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 CodeThemeFileBuilder<'a, S: code_theme_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> CodeThemeFile<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> CodeThemeFileBuilder<'a, code_theme_file_state::Empty> {
+        CodeThemeFileBuilder::new()
+    }
+}
+
+impl<'a> CodeThemeFileBuilder<'a, code_theme_file_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        CodeThemeFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None, None, None),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> CodeThemeFileBuilder<'a, S>
+where
+    S: code_theme_file_state::State,
+    S::Content: code_theme_file_state::IsUnset,
+{
+    /// Set the `content` field (required)
+    pub fn content(
+        mut self,
+        value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
+    ) -> CodeThemeFileBuilder<'a, code_theme_file_state::SetContent<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        CodeThemeFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> CodeThemeFileBuilder<'a, S>
+where
+    S: code_theme_file_state::State,
+    S::Did: code_theme_file_state::IsUnset,
+{
+    /// Set the `did` field (required)
+    pub fn did(
+        mut self,
+        value: impl Into<jacquard_common::types::string::Did<'a>>,
+    ) -> CodeThemeFileBuilder<'a, code_theme_file_state::SetDid<S>> {
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        CodeThemeFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> CodeThemeFileBuilder<'a, S>
+where
+    S: code_theme_file_state::State,
+    S::Name: code_theme_file_state::IsUnset,
+{
+    /// Set the `name` field (required)
+    pub fn name(
+        mut self,
+        value: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> CodeThemeFileBuilder<'a, code_theme_file_state::SetName<S>> {
+        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
+        CodeThemeFileBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> CodeThemeFileBuilder<'a, S>
+where
+    S: code_theme_file_state::State,
+    S::Name: code_theme_file_state::IsSet,
+    S::Did: code_theme_file_state::IsSet,
+    S::Content: code_theme_file_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> CodeThemeFile<'a> {
+        CodeThemeFile {
+            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>,
+        >,
+    ) -> CodeThemeFile<'a> {
+        CodeThemeFile {
+            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),
+        }
+    }
+}
+
+fn lexicon_doc_sh_weaver_notebook_theme() -> ::jacquard_lexicon::lexicon::LexiconDoc<
+    'static,
+> {
+    ::jacquard_lexicon::lexicon::LexiconDoc {
+        lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
+        id: ::jacquard_common::CowStr::new_static("sh.weaver.notebook.theme"),
+        revision: None,
+        description: None,
+        defs: {
+            let mut map = ::std::collections::BTreeMap::new();
+            map.insert(
+                ::jacquard_common::smol_str::SmolStr::new_static("codeThemeFile"),
+                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
+                    description: None,
+                    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("codeThemeName"),
+                ::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(
+                        ::jacquard_common::CowStr::new_static("Theme for a notebook"),
+                    ),
+                    key: Some(::jacquard_common::CowStr::new_static("tid")),
+                    record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {
+                        description: None,
+                        required: Some(
+                            vec![
+                                ::jacquard_common::smol_str::SmolStr::new_static("colours"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("fonts"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("spacing"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("codeTheme")
+                            ],
+                        ),
+                        nullable: None,
+                        properties: {
+                            #[allow(unused_mut)]
+                            let mut map = ::std::collections::BTreeMap::new();
+                            map.insert(
+                                ::jacquard_common::smol_str::SmolStr::new_static(
+                                    "codeTheme",
+                                ),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
+                                    description: None,
+                                    refs: vec![
+                                        ::jacquard_common::CowStr::new_static("#codeThemeName"),
+                                        ::jacquard_common::CowStr::new_static("#codeThemeFile")
+                                    ],
+                                    closed: None,
+                                }),
+                            );
+                            map.insert(
+                                ::jacquard_common::smol_str::SmolStr::new_static("colours"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Object(::jacquard_lexicon::lexicon::LexObject {
+                                    description: None,
+                                    required: Some(
+                                        vec![
+                                            ::jacquard_common::smol_str::SmolStr::new_static("background"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("foreground"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("primary"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("secondary"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("link"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("link_hover")
+                                        ],
+                                    ),
+                                    nullable: None,
+                                    properties: {
+                                        #[allow(unused_mut)]
+                                        let mut map = ::std::collections::BTreeMap::new();
+                                        map.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "background",
+                                            ),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "foreground",
+                                            ),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static("link"),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "link_hover",
+                                            ),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static("primary"),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "secondary",
+                                            ),
+                                            ::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("fonts"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Object(::jacquard_lexicon::lexicon::LexObject {
+                                    description: None,
+                                    required: Some(
+                                        vec![
+                                            ::jacquard_common::smol_str::SmolStr::new_static("body"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("heading"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("monospace")
+                                        ],
+                                    ),
+                                    nullable: None,
+                                    properties: {
+                                        #[allow(unused_mut)]
+                                        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 {
+                                                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("heading"),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "monospace",
+                                            ),
+                                            ::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("spacing"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Object(::jacquard_lexicon::lexicon::LexObject {
+                                    description: None,
+                                    required: Some(
+                                        vec![
+                                            ::jacquard_common::smol_str::SmolStr::new_static("baseSize"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("lineHeight"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("scale")
+                                        ],
+                                    ),
+                                    nullable: None,
+                                    properties: {
+                                        #[allow(unused_mut)]
+                                        let mut map = ::std::collections::BTreeMap::new();
+                                        map.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "baseSize",
+                                            ),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                                "lineHeight",
+                                            ),
+                                            ::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.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static("scale"),
+                                            ::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
+                        },
+                    }),
+                }),
+            );
+            map
+        },
+    }
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CodeThemeFile<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "codeThemeFile"
+    }
+    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 CodeThemeName<'a> = jacquard_common::CowStr<'a>;
+/// Theme for a notebook
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct Theme<'a> {
+    #[serde(borrow)]
+    pub code_theme: ThemeCodeTheme<'a>,
+    #[serde(borrow)]
+    pub colours: ThemeColours<'a>,
+    #[serde(borrow)]
+    pub fonts: ThemeFonts<'a>,
+    #[serde(borrow)]
+    pub spacing: ThemeSpacing<'a>,
+}
+
+pub mod theme_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 Colours;
+        type Fonts;
+        type Spacing;
+        type CodeTheme;
+    }
+    /// Empty state - all required fields are unset
+    pub struct Empty(());
+    impl sealed::Sealed for Empty {}
+    impl State for Empty {
+        type Colours = Unset;
+        type Fonts = Unset;
+        type Spacing = Unset;
+        type CodeTheme = Unset;
+    }
+    ///State transition - sets the `colours` field to Set
+    pub struct SetColours<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetColours<S> {}
+    impl<S: State> State for SetColours<S> {
+        type Colours = Set<members::colours>;
+        type Fonts = S::Fonts;
+        type Spacing = S::Spacing;
+        type CodeTheme = S::CodeTheme;
+    }
+    ///State transition - sets the `fonts` field to Set
+    pub struct SetFonts<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetFonts<S> {}
+    impl<S: State> State for SetFonts<S> {
+        type Colours = S::Colours;
+        type Fonts = Set<members::fonts>;
+        type Spacing = S::Spacing;
+        type CodeTheme = S::CodeTheme;
+    }
+    ///State transition - sets the `spacing` field to Set
+    pub struct SetSpacing<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetSpacing<S> {}
+    impl<S: State> State for SetSpacing<S> {
+        type Colours = S::Colours;
+        type Fonts = S::Fonts;
+        type Spacing = Set<members::spacing>;
+        type CodeTheme = S::CodeTheme;
+    }
+    ///State transition - sets the `code_theme` field to Set
+    pub struct SetCodeTheme<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetCodeTheme<S> {}
+    impl<S: State> State for SetCodeTheme<S> {
+        type Colours = S::Colours;
+        type Fonts = S::Fonts;
+        type Spacing = S::Spacing;
+        type CodeTheme = Set<members::code_theme>;
+    }
+    /// Marker types for field names
+    #[allow(non_camel_case_types)]
+    pub mod members {
+        ///Marker type for the `colours` field
+        pub struct colours(());
+        ///Marker type for the `fonts` field
+        pub struct fonts(());
+        ///Marker type for the `spacing` field
+        pub struct spacing(());
+        ///Marker type for the `code_theme` field
+        pub struct code_theme(());
+    }
+}
+
+/// Builder for constructing an instance of this type
+pub struct ThemeBuilder<'a, S: theme_state::State> {
+    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
+    __unsafe_private_named: (
+        ::core::option::Option<ThemeCodeTheme<'a>>,
+        ::core::option::Option<ThemeColours<'a>>,
+        ::core::option::Option<ThemeFonts<'a>>,
+        ::core::option::Option<ThemeSpacing<'a>>,
+    ),
+    _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> Theme<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> ThemeBuilder<'a, theme_state::Empty> {
+        ThemeBuilder::new()
+    }
+}
+
+impl<'a> ThemeBuilder<'a, theme_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        ThemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None, None, None, None),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeBuilder<'a, S>
+where
+    S: theme_state::State,
+    S::CodeTheme: theme_state::IsUnset,
+{
+    /// Set the `codeTheme` field (required)
+    pub fn code_theme(
+        mut self,
+        value: impl Into<ThemeCodeTheme<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetCodeTheme<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        ThemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeBuilder<'a, S>
+where
+    S: theme_state::State,
+    S::Colours: theme_state::IsUnset,
+{
+    /// Set the `colours` field (required)
+    pub fn colours(
+        mut self,
+        value: impl Into<ThemeColours<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetColours<S>> {
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        ThemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeBuilder<'a, S>
+where
+    S: theme_state::State,
+    S::Fonts: theme_state::IsUnset,
+{
+    /// Set the `fonts` field (required)
+    pub fn fonts(
+        mut self,
+        value: impl Into<ThemeFonts<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetFonts<S>> {
+        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
+        ThemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeBuilder<'a, S>
+where
+    S: theme_state::State,
+    S::Spacing: theme_state::IsUnset,
+{
+    /// Set the `spacing` field (required)
+    pub fn spacing(
+        mut self,
+        value: impl Into<ThemeSpacing<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetSpacing<S>> {
+        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
+        ThemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ThemeBuilder<'a, S>
+where
+    S: theme_state::State,
+    S::Colours: theme_state::IsSet,
+    S::Fonts: theme_state::IsSet,
+    S::Spacing: theme_state::IsSet,
+    S::CodeTheme: theme_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> Theme<'a> {
+        Theme {
+            code_theme: self.__unsafe_private_named.0.unwrap(),
+            colours: self.__unsafe_private_named.1.unwrap(),
+            fonts: self.__unsafe_private_named.2.unwrap(),
+            spacing: self.__unsafe_private_named.3.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>,
+        >,
+    ) -> Theme<'a> {
+        Theme {
+            code_theme: self.__unsafe_private_named.0.unwrap(),
+            colours: self.__unsafe_private_named.1.unwrap(),
+            fonts: self.__unsafe_private_named.2.unwrap(),
+            spacing: self.__unsafe_private_named.3.unwrap(),
+            extra_data: Some(extra_data),
+        }
+    }
+}
+
+impl<'a> Theme<'a> {
+    pub fn uri(
+        uri: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> Result<
+        jacquard_common::types::uri::RecordUri<'a, ThemeRecord>,
+        jacquard_common::types::uri::UriError,
+    > {
+        jacquard_common::types::uri::RecordUri::try_from_uri(
+            jacquard_common::types::string::AtUri::new_cow(uri.into())?,
+        )
+    }
+}
+
+#[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 ThemeCodeTheme<'a> {
+    #[serde(rename = "sh.weaver.notebook.theme#codeThemeName")]
+    CodeThemeName(Box<crate::sh_weaver::notebook::theme::CodeThemeName<'a>>),
+    #[serde(rename = "sh.weaver.notebook.theme#codeThemeFile")]
+    CodeThemeFile(Box<crate::sh_weaver::notebook::theme::CodeThemeFile<'a>>),
+}
+
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic,
+    Default
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ThemeColours<'a> {
+    #[serde(borrow)]
+    pub background: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub foreground: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub link: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub link_hover: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub primary: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub secondary: jacquard_common::CowStr<'a>,
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThemeColours<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "ThemeColours"
+    }
+    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(())
+    }
+}
+
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic,
+    Default
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ThemeFonts<'a> {
+    #[serde(borrow)]
+    pub body: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub heading: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub monospace: jacquard_common::CowStr<'a>,
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThemeFonts<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "ThemeFonts"
+    }
+    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(())
+    }
+}
+
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic,
+    Default
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ThemeSpacing<'a> {
+    #[serde(borrow)]
+    pub base_size: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub line_height: jacquard_common::CowStr<'a>,
+    #[serde(borrow)]
+    pub scale: jacquard_common::CowStr<'a>,
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThemeSpacing<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "ThemeSpacing"
+    }
+    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(())
+    }
+}
+
+/// Typed wrapper for GetRecord response with this collection's record type.
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ThemeGetRecordOutput<'a> {
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
+    #[serde(borrow)]
+    pub uri: jacquard_common::types::string::AtUri<'a>,
+    #[serde(borrow)]
+    pub value: Theme<'a>,
+}
+
+impl From<ThemeGetRecordOutput<'_>> for Theme<'_> {
+    fn from(output: ThemeGetRecordOutput<'_>) -> Self {
+        use jacquard_common::IntoStatic;
+        output.value.into_static()
+    }
+}
+
+impl jacquard_common::types::collection::Collection for Theme<'_> {
+    const NSID: &'static str = "sh.weaver.notebook.theme";
+    type Record = ThemeRecord;
+}
+
+/// Marker type for deserializing records from this collection.
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct ThemeRecord;
+impl jacquard_common::xrpc::XrpcResp for ThemeRecord {
+    const NSID: &'static str = "sh.weaver.notebook.theme";
+    const ENCODING: &'static str = "application/json";
+    type Output<'de> = ThemeGetRecordOutput<'de>;
+    type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
+}
+
+impl jacquard_common::types::collection::Collection for ThemeRecord {
+    const NSID: &'static str = "sh.weaver.notebook.theme";
+    type Record = ThemeRecord;
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Theme<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.theme"
+    }
+    fn def_name() -> &'static str {
+        "main"
+    }
+    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(())
+    }
+}

crates/weaver-renderer/Cargo.toml

···
 [dependencies]
 n0-future.workspace = true
 weaver-common = { path = "../weaver-common" }
+weaver-api = { path = "../weaver-api" }
 markdown-weaver = { workspace = true }
 compact_string = "0.1.0"
 http = "1.3.1"

crates/weaver-renderer/src/css.rs

···
 use syntect::highlighting::{Theme as SyntectTheme, ThemeSet};
 use syntect::html::{ClassStyle, css_for_theme_with_class_style};
 use syntect::parsing::SyntaxSet;
+use weaver_api::com_atproto::sync::get_blob::GetBlob;
+use weaver_api::sh_weaver::notebook::theme::ThemeCodeTheme;
+use weaver_common::jacquard::client::BasicClient;
+use weaver_common::jacquard::prelude::*;
+use weaver_common::jacquard::xrpc::XrpcExt;
 
 // Embed rose-pine themes at compile time
 const ROSE_PINE_THEME: &str = include_str!("../themes/rose-pine.tmTheme");
···
     margin: 2rem 0;
 }}
 "#,
-        theme.colors.background,
-        theme.colors.foreground,
-        theme.colors.link,
-        theme.colors.link_hover,
-        theme.colors.primary,
-        theme.colors.secondary,
+        theme.colours.background,
+        theme.colours.foreground,
+        theme.colours.link,
+        theme.colours.link_hover,
+        theme.colours.primary,
+        theme.colours.secondary,
         theme.fonts.body,
         theme.fonts.heading,
         theme.fonts.monospace,
-        theme.spacing.base_font_size,
+        theme.spacing.base_size,
         theme.spacing.line_height,
         theme.spacing.scale,
     )
 }
 
-pub fn generate_syntax_css(theme: &Theme, _syntax_set: &SyntaxSet) -> miette::Result<String> {
-    let syntect_theme = if let Some(custom_path) = &theme.custom_syntect_theme_path {
-        // Load custom theme from file
-        ThemeSet::get_theme(custom_path)
-            .into_diagnostic()
-            .map_err(|e| {
-                miette::miette!("Failed to load custom theme from {:?}: {}", custom_path, e)
-            })?
-    } else {
-        // Check for embedded themes first
-        match theme.syntect_theme_name.as_str() {
-            "rose-pine" => {
-                let mut cursor = Cursor::new(ROSE_PINE_THEME.as_bytes());
-                ThemeSet::load_from_reader(&mut cursor)
-                    .into_diagnostic()
-                    .map_err(|e| {
-                        miette::miette!("Failed to load embedded rose-pine theme: {}", e)
-                    })?
-            }
-            "rose-pine-dawn" => {
-                let mut cursor = Cursor::new(ROSE_PINE_DAWN_THEME.as_bytes());
-                ThemeSet::load_from_reader(&mut cursor)
-                    .into_diagnostic()
-                    .map_err(|e| {
-                        miette::miette!("Failed to load embedded rose-pine-dawn theme: {}", e)
-                    })?
-            }
-            _ => {
-                // Fall back to syntect's built-in themes
-                let theme_set = ThemeSet::load_defaults();
-                theme_set
-                    .themes
-                    .get(theme.syntect_theme_name.as_str())
-                    .ok_or_else(|| {
-                        miette::miette!(
-                            "Theme '{}' not found in defaults",
-                            theme.syntect_theme_name
-                        )
-                    })?
-                    .clone()
+pub async fn generate_syntax_css(theme: &Theme<'_>) -> miette::Result<String> {
+    let syntect_theme = match &theme.code_theme {
+        ThemeCodeTheme::CodeThemeName(name) => {
+            match name.as_str() {
+                "rose-pine" => {
+                    let mut cursor = Cursor::new(ROSE_PINE_THEME.as_bytes());
+                    ThemeSet::load_from_reader(&mut cursor)
+                        .into_diagnostic()
+                        .map_err(|e| {
+                            miette::miette!("Failed to load embedded rose-pine theme: {}", e)
+                        })?
+                }
+                "rose-pine-dawn" => {
+                    let mut cursor = Cursor::new(ROSE_PINE_DAWN_THEME.as_bytes());
+                    ThemeSet::load_from_reader(&mut cursor)
+                        .into_diagnostic()
+                        .map_err(|e| {
+                            miette::miette!("Failed to load embedded rose-pine-dawn theme: {}", e)
+                        })?
+                }
+                _ => {
+                    // Fall back to syntect's built-in themes
+                    let theme_set = ThemeSet::load_defaults();
+                    theme_set
+                        .themes
+                        .get(name.as_str())
+                        .ok_or_else(|| miette::miette!("Theme '{}' not found in defaults", name))?
+                        .clone()
+                }
             }
+        }
+        ThemeCodeTheme::CodeThemeFile(file) => {
+            let client = BasicClient::unauthenticated();
+            let pds = client.pds_for_did(&file.did).await?;
+            let blob = client
+                .xrpc(pds)
+                .send(
+                    &GetBlob::new()
+                        .did(file.did.clone())
+                        .cid(file.content.blob().cid().clone())
+                        .build(),
+                )
+                .await?
+                .buffer()
+                .clone();
+            let mut cursor = Cursor::new(blob);
+            ThemeSet::load_from_reader(&mut cursor)
+                .into_diagnostic()
+                .map_err(|e| miette::miette!("Failed to download theme: {}", e))?
+        }
+        _ => {
+            let mut cursor = Cursor::new(ROSE_PINE_THEME.as_bytes());
+            ThemeSet::load_from_reader(&mut cursor)
+                .into_diagnostic()
+                .map_err(|e| miette::miette!("Failed to load embedded rose-pine theme: {}", e))?
         }
     };
 

crates/weaver-renderer/src/static_site.rs

···
         document::{CssMode, write_document_footer, write_document_head},
         writer::StaticPageWriter,
     },
+    theme::defaultTheme,
     utils::flatten_dir_to_just_one_parent,
     walker::{WalkOptions, vault_contents},
 };
···
         // Generate CSS files for multi-file mode
         self.generate_css_files().await?;
 
-        let mut writers =
-            Vec::with_capacity(self.context.dir_contents.clone().unwrap_or_default().len());
-
         for file in self
             .context
             .dir_contents
···
             .filter(|file| file.starts_with(&self.context.start_at))
         {
             let context = self.context.clone();
-            let file = file.clone();
-            // we'll see if this is a problem or not
-            writers.push(n0_future::task::spawn(async move {
-                let relative_path = file
-                    .strip_prefix(context.start_at.clone())
-                    .expect("file should always be nested under root")
-                    .to_path_buf();
+            let relative_path = file
+                .strip_prefix(context.start_at.clone())
+                .expect("file should always be nested under root")
+                .to_path_buf();
 
-                // Check if this is a markdown file
-                let is_markdown = file
-                    .extension()
-                    .and_then(|ext| ext.to_str())
-                    .map(|ext| ext == "md" || ext == "markdown")
-                    .unwrap_or(false);
+            // Check if this is a markdown file
+            let is_markdown = file
+                .extension()
+                .and_then(|ext| ext.to_str())
+                .map(|ext| ext == "md" || ext == "markdown")
+                .unwrap_or(false);
 
-                if !is_markdown {
-                    // Copy non-markdown files directly
-                    let output_path = if context
-                        .options
-                        .contains(StaticSiteOptions::FLATTEN_STRUCTURE)
-                    {
-                        let path_str = relative_path.to_string_lossy();
-                        let (parent, fname) = flatten_dir_to_just_one_parent(&path_str);
-                        let parent = if parent.is_empty() { "entry" } else { parent };
-                        context
-                            .destination
-                            .join(String::from(parent))
-                            .join(String::from(fname))
-                    } else {
-                        context.destination.join(relative_path.clone())
-                    };
-
-                    // Create parent directory if needed
-                    if let Some(parent) = output_path.parent() {
-                        tokio::fs::create_dir_all(parent).await.into_diagnostic()?;
-                    }
-
-                    tokio::fs::copy(&file, &output_path)
-                        .await
-                        .into_diagnostic()?;
-                    return Ok(());
-                }
-
-                // Process markdown files
-                // Check if this is the designated index file
-                if let Some(index) = &context.index_file {
-                    if &relative_path == index {
-                        let output_path = context.destination.join("index.html");
-                        return write_page(context.clone(), file, output_path).await;
-                    }
-                }
-
-                if context
+            if !is_markdown {
+                // Copy non-markdown files directly
+                let output_path = if context
                     .options
                     .contains(StaticSiteOptions::FLATTEN_STRUCTURE)
                 {
                     let path_str = relative_path.to_string_lossy();
                     let (parent, fname) = flatten_dir_to_just_one_parent(&path_str);
                     let parent = if parent.is_empty() { "entry" } else { parent };
-                    let output_path = context
+                    context
                         .destination
                         .join(String::from(parent))
-                        .join(String::from(fname));
-
-                    write_page(context.clone(), file.clone(), output_path).await?;
+                        .join(String::from(fname))
                 } else {
-                    let output_path = context.destination.join(relative_path.clone());
+                    context.destination.join(relative_path.clone())
+                };
 
-                    write_page(context.clone(), file.clone(), output_path).await?;
+                // Create parent directory if needed
+                if let Some(parent) = output_path.parent() {
+                    tokio::fs::create_dir_all(parent).await.into_diagnostic()?;
                 }
-                Ok::<(), miette::Report>(())
-            }));
-        }
+
+                tokio::fs::copy(&file, &output_path)
+                    .await
+                    .into_diagnostic()?;
+                return Ok(());
+            }
 
-        // def want to scope these so we wait until they all complete before we return
-        // and then we def want the errors, or at least the first error
-        for fut in n0_future::join_all(writers).await.into_iter() {
-            fut.into_diagnostic()??;
+            // Process markdown files
+            // Check if this is the designated index file
+            if let Some(index) = &context.index_file {
+                if &relative_path == index {
+                    let output_path = context.destination.join("index.html");
+                    return write_page(context.clone(), file, output_path).await;
+                }
+            }
+
+            if context
+                .options
+                .contains(StaticSiteOptions::FLATTEN_STRUCTURE)
+            {
+                let path_str = relative_path.to_string_lossy();
+                let (parent, fname) = flatten_dir_to_just_one_parent(&path_str);
+                let parent = if parent.is_empty() { "entry" } else { parent };
+                let output_path = context
+                    .destination
+                    .join(String::from(parent))
+                    .join(String::from(fname));
+
+                write_page(context.clone(), file.clone(), output_path).await?;
+            } else {
+                let output_path = context.destination.join(relative_path.clone());
+
+                write_page(context.clone(), file.clone(), output_path).await?;
+            }
         }
 
         // Generate default index if requested and no custom index specified
···
 
     async fn generate_css_files(&self) -> Result<(), miette::Report> {
         use crate::css::{generate_base_css, generate_syntax_css};
-        use crate::theme::Theme;
 
         let css_dir = self.context.destination.join("css");
         tokio::fs::create_dir_all(&css_dir)
             .await
             .into_diagnostic()?;
 
-        let default_theme = Theme::default();
+        let default_theme = defaultTheme();
         let theme = self.context.theme.as_deref().unwrap_or(&default_theme);
 
         // Write base.css
···
             .into_diagnostic()?;
 
         // Write syntax.css
-        let syntax_css = generate_syntax_css(theme, &self.context.syntax_set)?;
+        let syntax_css = generate_syntax_css(theme).await?;
         tokio::fs::write(css_dir.join("syntax.css"), syntax_css)
             .await
             .into_diagnostic()?;

crates/weaver-renderer/src/static_site/context.rs

···
     pub client: Option<reqwest::Client>,
     agent: Option<Arc<Agent<A>>>,
 
-    pub theme: Option<Arc<Theme>>,
+    pub theme: Option<Arc<Theme<'static>>>,
     pub katex_source: Option<KaTeXSource>,
     pub syntax_set: Arc<SyntaxSet>,
     pub index_file: Option<PathBuf>,
···
         }
     }
 
-    pub fn with_theme(mut self, theme: Theme) -> Self {
+    pub fn with_theme(mut self, theme: Theme<'static>) -> Self {
         self.theme = Some(Arc::new(theme));
         self
     }

crates/weaver-renderer/src/static_site/document.rs

···
 use crate::css::{generate_base_css, generate_syntax_css};
 use crate::static_site::context::{KaTeXSource, StaticSiteContext};
-use crate::theme::Theme;
+use crate::theme::{Theme, defaultTheme};
 use miette::IntoDiagnostic;
 use weaver_common::jacquard::client::AgentSession;
 
···
                 .into_diagnostic()?;
         }
         CssMode::Inline => {
-            let default_theme = Theme::default();
+            let default_theme = defaultTheme();
             let theme = context.theme.as_deref().unwrap_or(&default_theme);
 
             writer.write_all(b"  <style>\n").await.into_diagnostic()?;
···
             writer.write_all(b"  </style>\n").await.into_diagnostic()?;
 
             writer.write_all(b"  <style>\n").await.into_diagnostic()?;
-            let syntax_css = generate_syntax_css(theme, &context.syntax_set)?;
+            let syntax_css = generate_syntax_css(theme).await?;
             writer
                 .write_all(syntax_css.as_bytes())
                 .await

crates/weaver-renderer/src/theme.rs

···
-use smol_str::SmolStr;
-use std::path::PathBuf;
+pub use weaver_api::sh_weaver::notebook::theme::{
+    Theme, ThemeCodeTheme, ThemeColours, ThemeFonts, ThemeSpacing,
+};
+use weaver_common::jacquard::CowStr;
+use weaver_common::jacquard::cowstr::ToCowStr;
 
-#[derive(Debug, Clone)]
-pub struct Theme {
-    pub colors: ColorScheme,
-    pub fonts: FontScheme,
-    pub spacing: SpacingScheme,
-    pub syntect_theme_name: SmolStr,
-    pub custom_syntect_theme_path: Option<PathBuf>,
-}
-
-#[derive(Debug, Clone)]
-pub struct ColorScheme {
-    pub background: SmolStr,
-    pub foreground: SmolStr,
-    pub link: SmolStr,
-    pub link_hover: SmolStr,
-    pub primary: SmolStr,
-    pub secondary: SmolStr,
-}
-
-#[derive(Debug, Clone)]
-pub struct FontScheme {
-    pub body: SmolStr,
-    pub heading: SmolStr,
-    pub monospace: SmolStr,
-}
-
-#[derive(Debug, Clone)]
-pub struct SpacingScheme {
-    pub base_font_size: SmolStr,
-    pub line_height: SmolStr,
-    pub scale: SmolStr,
-}
-
-impl Default for Theme {
-    fn default() -> Self {
-        Self {
-            colors: ColorScheme::default(),
-            fonts: FontScheme::default(),
-            spacing: SpacingScheme::default(),
-            syntect_theme_name: SmolStr::new("rose-pine-dawn"),
-            custom_syntect_theme_path: None,
-        }
-    }
-}
-
-impl Default for ColorScheme {
-    fn default() -> Self {
-        Self {
-            background: SmolStr::new("#faf4ed"),
-            foreground: SmolStr::new("#2b303b"),
-            link: SmolStr::new("#286983"),
-            link_hover: SmolStr::new("#56949f"),
-            primary: SmolStr::new("#c4a7e7"),
-            secondary: SmolStr::new("#3e8fb0"),
-        }
-    }
-}
+pub fn defaultTheme() -> Theme<'static> {
+    Theme::new()
+        .code_theme(ThemeCodeTheme::CodeThemeName(Box::new(
+            "rose-pine".to_cowstr(),
+        )))
+        .colours(ThemeColours {
+            background: CowStr::new_static("#faf4ed"),
+            foreground: CowStr::new_static("#2b303b"),
+            link: CowStr::new_static("#286983"),
+            link_hover: CowStr::new_static("#56949f"),
+            primary: CowStr::new_static("#c4a7e7"),
+            secondary: CowStr::new_static("#3e8fb0"),
 
-impl Default for FontScheme {
-    fn default() -> Self {
-        Self {
-            body: SmolStr::new(
+            ..Default::default()
+        }).fonts(ThemeFonts {
+            body: CowStr::new_static(
                 "IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
             ),
-            heading: SmolStr::new(
+            heading:CowStr::new_static(
                 "IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
             ),
-            monospace: SmolStr::new(
+            monospace: CowStr::new_static(
                 "'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace",
             ),
-        }
-    }
-}
-
-impl Default for SpacingScheme {
-    fn default() -> Self {
-        Self {
-            base_font_size: SmolStr::new("16px"),
-            line_height: SmolStr::new("1.6"),
-            scale: SmolStr::new("1.25"),
-        }
-    }
+            ..Default::default()
+        }).spacing(ThemeSpacing {
+            base_size: CowStr::new_static("16px"),
+            line_height: CowStr::new_static("1.6"),
+            scale: CowStr::new_static("1.25"),
+            ..Default::default()
+        }).build()
 }

crates/weaver-renderer/src/utils.rs

···
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use tokio::fs::{self, File};
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub async fn create_file(dest: &Path) -> miette::Result<File> {
     let file = File::create(dest)
         .or_else(async |err| {

crates/weaver-server/Cargo.toml

···
 jacquard-axum = { workspace = true, optional = true }
 weaver-api = { path = "../weaver-api", features = ["streaming"] }
 markdown-weaver = { workspace = true }
+weaver-renderer = { path = "../weaver-renderer" }
 moka = { version = "0.12", features = ["future"], optional = true }
 mini-moka = { version = "0.10" }
 dioxus-primitives = { git = "https://github.com/DioxusLabs/components", version = "0.0.1", default-features = false }
+axum = {version = "0.8.6", optional = true}
 
 [features]
 default = ["web"]
···
 # The feature that are only required for the mobile = ["dioxus/mobile"] build target should be optional and only enabled in the mobile = ["dioxus/mobile"] feature
 mobile = ["dioxus/mobile"]
 # The feature that are only required for the server = ["dioxus/server"] build target should be optional and only enabled in the server = ["dioxus/server"] feature
-server = ["dioxus/server", "dep:jacquard-axum", "dep:moka"]
+server = ["dioxus/server", "dep:jacquard-axum", "dep:moka", "dep:axum"]

crates/weaver-server/src/blobcache.rs

···
+use dioxus::{CapturedError, Result};
+use jacquard::{
+    bytes::Bytes,
+    client::BasicClient,
+    prelude::*,
+    smol_str::SmolStr,
+    types::{cid::Cid, ident::AtIdentifier},
+};
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+use weaver_api::com_atproto::sync::get_blob::GetBlob;
+
+#[derive(Clone)]
+pub struct BlobCache {
+    client: Arc<BasicClient>,
+    cache: mini_moka::sync::Cache<Cid<'static>, Bytes>,
+    map: mini_moka::sync::Cache<SmolStr, Cid<'static>>,
+}
+
+impl BlobCache {
+    pub fn new(client: Arc<BasicClient>) -> Self {
+        let cache = mini_moka::sync::Cache::builder()
+            .max_capacity(100)
+            .time_to_idle(Duration::from_secs(1200))
+            .build();
+        let map = mini_moka::sync::Cache::builder()
+            .max_capacity(500)
+            .time_to_idle(Duration::from_secs(1200))
+            .build();
+
+        Self { client, cache, map }
+    }
+
+    pub async fn cache(
+        &self,
+        ident: AtIdentifier<'static>,
+        cid: Cid<'static>,
+        name: Option<SmolStr>,
+    ) -> Result<()> {
+        let (repo_did, pds_url) = match ident {
+            AtIdentifier::Did(did) => {
+                let pds = self.client.pds_for_did(&did).await?;
+                (did.clone(), pds)
+            }
+            AtIdentifier::Handle(handle) => self.client.pds_for_handle(&handle).await?,
+        };
+        let blob = self
+            .client
+            .xrpc(pds_url)
+            .send(&GetBlob::new().cid(cid.clone()).did(repo_did).build())
+            .await?
+            .buffer()
+            .clone();
+
+        self.cache.insert(cid.clone(), blob);
+        if let Some(name) = name {
+            self.map.insert(name, cid);
+        }
+
+        Ok(())
+    }
+
+    pub fn get_cid(&self, cid: &Cid<'static>) -> Option<Bytes> {
+        self.cache.get(cid)
+    }
+
+    pub fn get_named(&self, name: &SmolStr) -> Option<Bytes> {
+        self.map.get(name).and_then(|cid| self.cache.get(&cid))
+    }
+}

crates/weaver-server/src/components/css.rs

···
+#[allow(unused_imports)]
+use crate::fetch;
+use dioxus::prelude::*;
+#[allow(unused_imports)]
+use dioxus::{fullstack::extract::Extension, fullstack::get_server_url, CapturedError};
+use jacquard::smol_str::SmolStr;
+#[allow(unused_imports)]
+use std::sync::Arc;
+#[allow(unused_imports)]
+use weaver_renderer::theme::Theme;
+
+#[component]
+pub fn NotebookCss(ident: SmolStr, notebook: SmolStr) -> Element {
+    rsx! {
+        document::Stylesheet {
+            href: "{get_server_url()}/css/{ident}/{notebook}"
+        }
+    }
+}
+
+#[get("/css/{ident}/{notebook}", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
+pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<String> {
+    use jacquard::client::AgentSessionExt;
+    use jacquard::types::ident::AtIdentifier;
+    use jacquard::{from_data, CowStr};
+
+    use weaver_api::sh_weaver::notebook::book::Book;
+    use weaver_renderer::css::{generate_base_css, generate_syntax_css};
+    use weaver_renderer::theme::defaultTheme;
+
+    let ident = AtIdentifier::new_owned(ident)?;
+    let theme = if let Some(notebook) = fetcher.get_notebook(ident, notebook).await? {
+        let book: Book = from_data(&notebook.0.record).unwrap();
+        if let Some(theme) = book.theme {
+            if let Ok(theme) = fetcher.client.get_record::<Theme>(&theme.uri).await {
+                theme
+                    .into_output()
+                    .map(|t| t.value)
+                    .unwrap_or(defaultTheme())
+            } else {
+                defaultTheme()
+            }
+        } else {
+            defaultTheme()
+        }
+    } else {
+        defaultTheme()
+    };
+    let mut css = generate_base_css(&theme);
+    css.push_str(
+        &generate_syntax_css(&theme)
+            .await
+            .map_err(|e| CapturedError::from_display(e))
+            .unwrap_or_default(),
+    );
+    Ok(css)
+}

crates/weaver-server/src/components/cssblob.rs

···
-use dioxus::prelude::*;
-use weaver_common::jacquard::smol_str::SmolStr;

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

···
 //! They can be used to defined common UI elements like buttons, forms, and modals. In this template, we define a Hero
 //! component and an Echo component for fullstack apps to be used in our app.
 
-mod cssblob;
+mod css;
+pub use css::NotebookCss;
 
 mod entry;
 pub use entry::{Entry, EntryCard};

crates/weaver-server/src/fetch.rs

···
 
 #[derive(Clone)]
 pub struct CachedFetcher {
-    client: Arc<BasicClient>,
-
+    pub client: Arc<BasicClient>,
+    #[cfg(not(feature = "server"))]
     book_cache: Arc<
         Mutex<
             mini_moka::unsync::Cache<
···
             >,
         >,
     >,
+    #[cfg(not(feature = "server"))]
     entry_cache: Arc<
         Mutex<
             mini_moka::unsync::Cache<
···
             >,
         >,
     >,
+    #[cfg(feature = "server")]
+    book_cache: Arc<
+        Mutex<
+            mini_moka::sync::Cache<
+                (AtIdentifier<'static>, SmolStr),
+                Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
+            >,
+        >,
+    >,
+    #[cfg(feature = "server")]
+    entry_cache: Arc<
+        Mutex<
+            mini_moka::sync::Cache<
+                (AtIdentifier<'static>, SmolStr),
+                Arc<(BookEntryView<'static>, Entry<'static>)>,
+            >,
+        >,
+    >,
 }
 
 impl CachedFetcher {
+    #[cfg(not(feature = "server"))]
     pub fn new(client: Arc<BasicClient>) -> Self {
         let book_cache = mini_moka::unsync::Cache::builder()
             .max_capacity(100)
···
         }
     }
 
+    #[cfg(feature = "server")]
+    pub fn new(client: Arc<BasicClient>) -> Self {
+        let book_cache = mini_moka::sync::Cache::builder()
+            .max_capacity(100)
+            .time_to_idle(Duration::from_secs(1200))
+            .build();
+        let entry_cache = mini_moka::sync::Cache::builder()
+            .max_capacity(100)
+            .time_to_idle(Duration::from_secs(600))
+            .build();
+
+        Self {
+            client,
+            book_cache: Arc::new(Mutex::new(book_cache)),
+            entry_cache: Arc::new(Mutex::new(entry_cache)),
+        }
+    }
+
     pub async fn get_notebook(
         &self,
         ident: AtIdentifier<'static>,
···
         }
     }
 
+    #[cfg(not(feature = "server"))]
     pub fn list_recent_entries(&self) -> Vec<Arc<(BookEntryView<'static>, Entry<'static>)>> {
         if let Ok(entry_cache) = self.entry_cache.lock() {
             let mut entries = Vec::new();
···
         }
     }
 
+    #[cfg(not(feature = "server"))]
     pub fn list_recent_notebooks(
         &self,
     ) -> Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
         if let Ok(book_cache) = self.book_cache.lock() {
             let mut entries = Vec::new();
             for (_, entry) in book_cache.iter() {
+                entries.push(entry.clone());
+            }
+            entries
+        } else {
+            Vec::new()
+        }
+    }
+
+    #[cfg(feature = "server")]
+    pub fn list_recent_entries(&self) -> Vec<Arc<(BookEntryView<'static>, Entry<'static>)>> {
+        if let Ok(entry_cache) = self.entry_cache.lock() {
+            let mut entries = Vec::new();
+            for entry in entry_cache.iter() {
+                entries.push(entry.clone());
+            }
+            entries
+        } else {
+            Vec::new()
+        }
+    }
+
+    #[cfg(feature = "server")]
+    pub fn list_recent_notebooks(
+        &self,
+    ) -> Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
+        if let Ok(book_cache) = self.book_cache.lock() {
+            let mut entries = Vec::new();
+            for entry in book_cache.iter() {
                 entries.push(entry.clone());
             }
             entries

crates/weaver-server/src/main.rs

···
 use std::sync::Arc;
 use views::{Home, Navbar, Notebook, NotebookIndex, NotebookPage};
 
+mod blobcache;
 /// Define a components module that contains all shared components for our app.
 mod components;
 mod fetch;
···
     // Run `serve()` on the server only
     #[cfg(feature = "server")]
     dioxus::serve(|| async move {
+        use axum::{extract::Request, middleware, middleware::Next};
         // Create a new router for our app using the `router` function
-        let mut router = dioxus::server::router(App);
+        let mut router = dioxus::server::router(App).layer(middleware::from_fn(
+            |mut req: Request, next: Next| async move {
+                // Attach some extra state to the request
+
+                use crate::fetch::CachedFetcher;
+                use std::convert::Infallible;
+                use std::sync::Arc;
+                req.extensions_mut()
+                    .insert(Arc::new(CachedFetcher::new(Arc::new(
+                        BasicClient::unauthenticated(),
+                    ))));
+
+                // And then return the response with `next.run()
+                Ok::<_, Infallible>(next.run(req).await)
+            },
+        ));
 
         // .. customize the router, adding layers and new routes
 

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

···
-use crate::{fetch, Route};
+use crate::{components::NotebookCss, fetch, Route};
 use dioxus::prelude::*;
 use jacquard::{
-    client::BasicClient,
-    smol_str::SmolStr,
-    types::{ident::AtIdentifier, tid::Tid},
-    CowStr,
+    smol_str::{SmolStr, ToSmolStr},
+    types::ident::AtIdentifier,
 };
-use std::sync::Arc;
-
-const BLOG_CSS: Asset = asset!("/assets/styling/blog.css");
 
 /// The Blog page component that will be rendered when the current route is `[Route::Blog]`
 ///
···
 /// re-run and the rendered HTML will be updated.
 #[component]
 pub fn Notebook(ident: AtIdentifier<'static>, book_title: SmolStr) -> Element {
-    let fetcher = use_context::<fetch::CachedFetcher>();
     rsx! {
-        document::Link { rel: "stylesheet", href: BLOG_CSS }
+        NotebookCss { ident: ident.to_smolstr(), notebook: book_title }
         Outlet::<Route> {}
     }
 }

crates/weaver-server/src/views/notebookpage.rs

···
 use dioxus::prelude::*;
 use jacquard::types::tid::Tid;
 
-const BLOG_CSS: Asset = asset!("/assets/styling/blog.css");
-
 /// The Blog page component that will be rendered when the current route is `[Route::Blog]`
 ///
 /// The component takes a `id` prop of type `i32` from the route enum. Whenever the id changes, the component function will be
···
 #[component]
 pub fn NotebookPage(id: Tid, children: Element) -> Element {
     rsx! {
-        document::Link { rel: "stylesheet", href: BLOG_CSS }
-
         div {
             id: "blog",
 

lexicons/embed/video.json

···
       "type": "object",
       "required": ["video"],
       "properties": {
+        "name": {
+          "type": "string",
+          "maxLength": 128
+        },
         "video": {
           "type": "blob",
           "description": "The mp4 video file. May be up to 100mb, formerly limited to 50mb.",
···
           "maxGraphemes": 1000,
           "maxLength": 10000
         },
-        "aspectRatio": {
-          "type": "ref",
-          "ref": "app.bsky.embed.defs#aspectRatio"
+        "dimensions": {
+          "type": "union",
+          "refs": [
+            "app.bsky.embed.defs#aspectRatio",
+            "sh.weaver.embed.defs#percentSize",
+            "sh.weaver.embed.defs#pixelSize"
+          ]
         }
       }
     },
···
           "maxGraphemes": 1000,
           "maxLength": 10000
         },
-        "aspectRatio": {
-          "type": "ref",
-          "ref": "app.bsky.embed.defs#aspectRatio"
+        "name": {
+          "type": "string",
+          "maxLength": 128
+        },
+        "dimensions": {
+          "type": "union",
+          "refs": [
+            "app.bsky.embed.defs#aspectRatio",
+            "sh.weaver.embed.defs#percentSize",
+            "sh.weaver.embed.defs#pixelSize"
+          ]
         }
       }
     }

lexicons/notebook/book.json

···
               "ref": "com.atproto.repo.strongRef"
             }
           },
+          "theme": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime",

lexicons/notebook/theme.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.theme",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "Theme for a notebook",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["colours", "fonts", "spacing", "codeTheme"],
+        "properties": {
+          "colours": {
+            "type": "object",
+            "required": ["background", "foreground", "primary", "secondary", "link", "link_hover"],
+            "properties": {
+              "background": {
+                "type": "string"
+              },
+              "foreground": {
+                "type": "string"
+              },
+              "primary": {
+                "type": "string"
+              },
+              "secondary": {
+                "type": "string"
+              },
+              "link": {
+                "type": "string"
+              },
+              "link_hover": {
+                "type": "string"
+              }
+            }
+          },
+          "fonts": {
+            "type": "object",
+            "required": ["body", "heading", "monospace"],
+            "properties": {
+              "body": {
+                "type": "string"
+              },
+              "heading": {
+                "type": "string"
+              },
+              "monospace": {
+                "type": "string"
+              }
+            }
+          },
+          "spacing": {
+            "type": "object",
+            "required": ["baseSize", "lineHeight", "scale"],
+            "properties": {
+              "baseSize": {
+                "type": "string"
+              },
+              "lineHeight": {
+                "type": "string"
+              },
+              "scale": {
+                "type": "string"
+              }
+            }
+          },
+          "codeTheme": {
+            "type": "union",
+            "refs": ["#codeThemeName", "#codeThemeFile"]
+          }
+        }
+      }
+    },
+    "codeThemeName": {
+      "type": "string"
+    },
+    "codeThemeFile": {
+      "type": "object",
+      "required": ["name", "did", "content"],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "content": {
+          "type": "blob",
+          "accept": ["*/*"],
+          "maxSize": 20000
+        }
+      }
+    }
+  }
+}