new theming scheme, better css, blob cdn endpoints

Cargo.lock

···
  "global-hotkey",
  "infer",
  "jni",
- "lazy-js-bundle",
+ "lazy-js-bundle 0.7.0",
  "libc",
  "muda",
  "ndk",
···
  "futures-channel",
  "futures-util",
  "generational-box",
- "lazy-js-bundle",
+ "lazy-js-bundle 0.7.0",
  "serde",
  "serde_json",
  "tracing",
···
  "futures-util",
  "generational-box",
  "keyboard-types",
- "lazy-js-bundle",
+ "lazy-js-bundle 0.7.0",
  "rustversion",
  "serde",
  "serde_json",
···
  "dioxus-core-types",
  "dioxus-html",
  "js-sys",
- "lazy-js-bundle",
+ "lazy-js-bundle 0.7.0",
  "rustc-hash 2.1.1",
  "serde",
  "sledgehammer_bindgen",
···
 ]
 
 [[package]]
+name = "dioxus-primitives"
+version = "0.0.1"
+source = "git+https://github.com/DioxusLabs/components#8e25631c7d4234ee070509156ed2abebb7b1d6e9"
+dependencies = [
+ "dioxus",
+ "dioxus-time",
+ "lazy-js-bundle 0.6.2",
+ "num-integer",
+ "time",
+ "tracing",
+]
+
+[[package]]
 name = "dioxus-router"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "dioxus-time"
+version = "0.7.0"
+source = "git+https://github.com/ealmloff/dioxus-std?branch=0.7#e5a74354cd36be440febdd6b701f584bd552bd62"
+dependencies = [
+ "dioxus",
+ "futures",
+ "gloo-timers",
+ "tokio",
+]
+
+[[package]]
 name = "dioxus-web"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "generational-box",
  "gloo-timers",
  "js-sys",
- "lazy-js-bundle",
+ "lazy-js-bundle 0.7.0",
  "rustc-hash 2.1.1",
  "send_wrapper",
  "serde",
···
  "static-regular-grammar",
  "thiserror 1.0.69",
 ]
+
+[[package]]
+name = "lazy-js-bundle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e49596223b9d9d4947a14a25c142a6e7d8ab3f27eb3ade269d238bb8b5c267e2"
 
 [[package]]
 name = "lazy-js-bundle"
···
  "console_error_panic_hook",
  "dashmap",
  "dioxus",
+ "dioxus-primitives",
  "jacquard",
  "jacquard-axum",
  "markdown-weaver",
+ "mime-sniffer",
  "mini-moka",
  "n0-future",
+ "serde_json",
  "time",
  "weaver-api",
  "weaver-common",

crates/weaver-api/lexicons/com_atproto_lexicon_resolveLexicon.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.lexicon.resolveLexicon",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Resolves an atproto lexicon (NSID) to a schema.",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "nsid"
+        ],
+        "properties": {
+          "nsid": {
+            "type": "string",
+            "description": "The lexicon NSID to resolve.",
+            "format": "nsid"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "uri",
+            "cid",
+            "schema"
+          ],
+          "properties": {
+            "cid": {
+              "type": "string",
+              "description": "The CID of the lexicon schema record.",
+              "format": "cid"
+            },
+            "schema": {
+              "type": "ref",
+              "description": "The resolved lexicon schema record.",
+              "ref": "com.atproto.lexicon.schema#main"
+            },
+            "uri": {
+              "type": "string",
+              "description": "The AT-URI of the lexicon schema record.",
+              "format": "at-uri"
+            }
+          }
+        }
+      },
+      "errors": [
+        {
+          "description": "No lexicon was resolved for the NSID.",
+          "name": "LexiconNotFound"
+        }
+      ]
+    }
+  }
+}

crates/weaver-api/lexicons/sh_weaver_notebook_colourScheme.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.colourScheme",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A colour palette for notebook theming",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "name",
+          "variant",
+          "colours"
+        ],
+        "properties": {
+          "colours": {
+            "type": "object",
+            "required": [
+              "base",
+              "surface",
+              "overlay",
+              "text",
+              "muted",
+              "subtle",
+              "emphasis",
+              "primary",
+              "secondary",
+              "tertiary",
+              "error",
+              "warning",
+              "success",
+              "border",
+              "link",
+              "highlight"
+            ],
+            "properties": {
+              "base": {
+                "type": "string",
+                "description": "Primary background for page/frame"
+              },
+              "border": {
+                "type": "string",
+                "description": "Border/divider colour"
+              },
+              "emphasis": {
+                "type": "string",
+                "description": "Emphasized text (bold, important)"
+              },
+              "error": {
+                "type": "string",
+                "description": "Error state colour"
+              },
+              "highlight": {
+                "type": "string",
+                "description": "Selection/highlight colour"
+              },
+              "link": {
+                "type": "string",
+                "description": "Hyperlink colour"
+              },
+              "muted": {
+                "type": "string",
+                "description": "De-emphasized text (disabled, metadata)"
+              },
+              "overlay": {
+                "type": "string",
+                "description": "Tertiary background for popovers/dialogs"
+              },
+              "primary": {
+                "type": "string",
+                "description": "Primary brand/accent colour"
+              },
+              "secondary": {
+                "type": "string",
+                "description": "Secondary accent colour"
+              },
+              "subtle": {
+                "type": "string",
+                "description": "Medium emphasis text (comments, labels)"
+              },
+              "success": {
+                "type": "string",
+                "description": "Success state colour"
+              },
+              "surface": {
+                "type": "string",
+                "description": "Secondary background for panels/cards"
+              },
+              "tertiary": {
+                "type": "string",
+                "description": "Tertiary accent colour"
+              },
+              "text": {
+                "type": "string",
+                "description": "Primary readable text colour"
+              },
+              "warning": {
+                "type": "string",
+                "description": "Warning state colour"
+              }
+            }
+          },
+          "name": {
+            "type": "string",
+            "description": "Human-readable name for the colour scheme"
+          },
+          "variant": {
+            "type": "string",
+            "description": "Whether this is a dark or light colour scheme",
+            "enum": [
+              "dark",
+              "light"
+            ]
+          }
+        }
+      }
+    }
+  }
+}

crates/weaver-api/lexicons/sh_weaver_notebook_theme.json

···
       "record": {
         "type": "object",
         "required": [
-          "colours",
+          "darkScheme",
+          "lightScheme",
           "fonts",
           "spacing",
-          "codeTheme"
+          "darkCodeTheme",
+          "lightCodeTheme"
         ],
         "properties": {
-          "codeTheme": {
+          "darkCodeTheme": {
             "type": "union",
+            "description": "Syntax highlighting theme for dark mode",
             "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"
-              }
-            }
+          "darkScheme": {
+            "type": "ref",
+            "description": "Reference to a dark colour scheme",
+            "ref": "com.atproto.repo.strongRef"
           },
           "fonts": {
             "type": "object",
···
                 "type": "string"
               }
             }
+          },
+          "lightCodeTheme": {
+            "type": "union",
+            "description": "Syntax highlighting theme for light mode",
+            "refs": [
+              "#codeThemeName",
+              "#codeThemeFile"
+            ]
+          },
+          "lightScheme": {
+            "type": "ref",
+            "description": "Reference to a light colour scheme",
+            "ref": "com.atproto.repo.strongRef"
           },
           "spacing": {
             "type": "object",

crates/weaver-api/src/com_atproto/lexicon.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
+pub mod resolve_lexicon;
 pub mod schema;

crates/weaver-api/src/com_atproto/lexicon/resolve_lexicon.rs

···
+// @generated by jacquard-lexicon. DO NOT EDIT.
+//
+// Lexicon: com.atproto.lexicon.resolveLexicon
+//
+// This file was automatically generated from Lexicon schemas.
+// Any manual changes will be overwritten on the next regeneration.
+
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ResolveLexicon<'a> {
+    #[serde(borrow)]
+    pub nsid: jacquard_common::types::string::Nsid<'a>,
+}
+
+pub mod resolve_lexicon_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 Nsid;
+    }
+    /// Empty state - all required fields are unset
+    pub struct Empty(());
+    impl sealed::Sealed for Empty {}
+    impl State for Empty {
+        type Nsid = Unset;
+    }
+    ///State transition - sets the `nsid` field to Set
+    pub struct SetNsid<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetNsid<S> {}
+    impl<S: State> State for SetNsid<S> {
+        type Nsid = Set<members::nsid>;
+    }
+    /// Marker types for field names
+    #[allow(non_camel_case_types)]
+    pub mod members {
+        ///Marker type for the `nsid` field
+        pub struct nsid(());
+    }
+}
+
+/// Builder for constructing an instance of this type
+pub struct ResolveLexiconBuilder<'a, S: resolve_lexicon_state::State> {
+    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
+    __unsafe_private_named: (
+        ::core::option::Option<jacquard_common::types::string::Nsid<'a>>,
+    ),
+    _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> ResolveLexicon<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> ResolveLexiconBuilder<'a, resolve_lexicon_state::Empty> {
+        ResolveLexiconBuilder::new()
+    }
+}
+
+impl<'a> ResolveLexiconBuilder<'a, resolve_lexicon_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        ResolveLexiconBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None,),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ResolveLexiconBuilder<'a, S>
+where
+    S: resolve_lexicon_state::State,
+    S::Nsid: resolve_lexicon_state::IsUnset,
+{
+    /// Set the `nsid` field (required)
+    pub fn nsid(
+        mut self,
+        value: impl Into<jacquard_common::types::string::Nsid<'a>>,
+    ) -> ResolveLexiconBuilder<'a, resolve_lexicon_state::SetNsid<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        ResolveLexiconBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ResolveLexiconBuilder<'a, S>
+where
+    S: resolve_lexicon_state::State,
+    S::Nsid: resolve_lexicon_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> ResolveLexicon<'a> {
+        ResolveLexicon {
+            nsid: self.__unsafe_private_named.0.unwrap(),
+        }
+    }
+}
+
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ResolveLexiconOutput<'a> {
+    /// The CID of the lexicon schema record.
+    #[serde(borrow)]
+    pub cid: jacquard_common::types::string::Cid<'a>,
+    /// The resolved lexicon schema record.
+    #[serde(borrow)]
+    pub schema: crate::com_atproto::lexicon::schema::Schema<'a>,
+    /// The AT-URI of the lexicon schema record.
+    #[serde(borrow)]
+    pub uri: jacquard_common::types::string::AtUri<'a>,
+}
+
+#[jacquard_derive::open_union]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    thiserror::Error,
+    miette::Diagnostic,
+    jacquard_derive::IntoStatic
+)]
+#[serde(tag = "error", content = "message")]
+#[serde(bound(deserialize = "'de: 'a"))]
+pub enum ResolveLexiconError<'a> {
+    /// No lexicon was resolved for the NSID.
+    #[serde(rename = "LexiconNotFound")]
+    LexiconNotFound(std::option::Option<String>),
+}
+
+impl std::fmt::Display for ResolveLexiconError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::LexiconNotFound(msg) => {
+                write!(f, "LexiconNotFound")?;
+                if let Some(msg) = msg {
+                    write!(f, ": {}", msg)?;
+                }
+                Ok(())
+            }
+            Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
+        }
+    }
+}
+
+/// Response type for
+///com.atproto.lexicon.resolveLexicon
+pub struct ResolveLexiconResponse;
+impl jacquard_common::xrpc::XrpcResp for ResolveLexiconResponse {
+    const NSID: &'static str = "com.atproto.lexicon.resolveLexicon";
+    const ENCODING: &'static str = "application/json";
+    type Output<'de> = ResolveLexiconOutput<'de>;
+    type Err<'de> = ResolveLexiconError<'de>;
+}
+
+impl<'a> jacquard_common::xrpc::XrpcRequest for ResolveLexicon<'a> {
+    const NSID: &'static str = "com.atproto.lexicon.resolveLexicon";
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ResolveLexiconResponse;
+}
+
+/// Endpoint type for
+///com.atproto.lexicon.resolveLexicon
+pub struct ResolveLexiconRequest;
+impl jacquard_common::xrpc::XrpcEndpoint for ResolveLexiconRequest {
+    const PATH: &'static str = "/xrpc/com.atproto.lexicon.resolveLexicon";
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Request<'de> = ResolveLexicon<'de>;
+    type Response = ResolveLexiconResponse;
+}

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

···
 pub mod authors;
 pub mod book;
 pub mod chapter;
+pub mod colour_scheme;
 pub mod entry;
 pub mod page;
 pub mod theme;

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

···
+// @generated by jacquard-lexicon. DO NOT EDIT.
+//
+// Lexicon: sh.weaver.notebook.colourScheme
+//
+// This file was automatically generated from Lexicon schemas.
+// Any manual changes will be overwritten on the next regeneration.
+
+/// A colour palette for notebook theming
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ColourScheme<'a> {
+    #[serde(borrow)]
+    pub colours: ColourSchemeColours<'a>,
+    /// Human-readable name for the colour scheme
+    #[serde(borrow)]
+    pub name: jacquard_common::CowStr<'a>,
+    /// Whether this is a dark or light colour scheme
+    #[serde(borrow)]
+    pub variant: jacquard_common::CowStr<'a>,
+}
+
+pub mod colour_scheme_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 Variant;
+        type Colours;
+    }
+    /// Empty state - all required fields are unset
+    pub struct Empty(());
+    impl sealed::Sealed for Empty {}
+    impl State for Empty {
+        type Name = Unset;
+        type Variant = Unset;
+        type Colours = 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 Variant = S::Variant;
+        type Colours = S::Colours;
+    }
+    ///State transition - sets the `variant` field to Set
+    pub struct SetVariant<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetVariant<S> {}
+    impl<S: State> State for SetVariant<S> {
+        type Name = S::Name;
+        type Variant = Set<members::variant>;
+        type Colours = S::Colours;
+    }
+    ///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 Name = S::Name;
+        type Variant = S::Variant;
+        type Colours = Set<members::colours>;
+    }
+    /// 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 `variant` field
+        pub struct variant(());
+        ///Marker type for the `colours` field
+        pub struct colours(());
+    }
+}
+
+/// Builder for constructing an instance of this type
+pub struct ColourSchemeBuilder<'a, S: colour_scheme_state::State> {
+    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
+    __unsafe_private_named: (
+        ::core::option::Option<ColourSchemeColours<'a>>,
+        ::core::option::Option<jacquard_common::CowStr<'a>>,
+        ::core::option::Option<jacquard_common::CowStr<'a>>,
+    ),
+    _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> ColourScheme<'a> {
+    /// Create a new builder for this type
+    pub fn new() -> ColourSchemeBuilder<'a, colour_scheme_state::Empty> {
+        ColourSchemeBuilder::new()
+    }
+}
+
+impl<'a> ColourSchemeBuilder<'a, colour_scheme_state::Empty> {
+    /// Create a new builder with all fields unset
+    pub fn new() -> Self {
+        ColourSchemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: (None, None, None),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ColourSchemeBuilder<'a, S>
+where
+    S: colour_scheme_state::State,
+    S::Colours: colour_scheme_state::IsUnset,
+{
+    /// Set the `colours` field (required)
+    pub fn colours(
+        mut self,
+        value: impl Into<ColourSchemeColours<'a>>,
+    ) -> ColourSchemeBuilder<'a, colour_scheme_state::SetColours<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        ColourSchemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ColourSchemeBuilder<'a, S>
+where
+    S: colour_scheme_state::State,
+    S::Name: colour_scheme_state::IsUnset,
+{
+    /// Set the `name` field (required)
+    pub fn name(
+        mut self,
+        value: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> ColourSchemeBuilder<'a, colour_scheme_state::SetName<S>> {
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        ColourSchemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ColourSchemeBuilder<'a, S>
+where
+    S: colour_scheme_state::State,
+    S::Variant: colour_scheme_state::IsUnset,
+{
+    /// Set the `variant` field (required)
+    pub fn variant(
+        mut self,
+        value: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> ColourSchemeBuilder<'a, colour_scheme_state::SetVariant<S>> {
+        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
+        ColourSchemeBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> ColourSchemeBuilder<'a, S>
+where
+    S: colour_scheme_state::State,
+    S::Name: colour_scheme_state::IsSet,
+    S::Variant: colour_scheme_state::IsSet,
+    S::Colours: colour_scheme_state::IsSet,
+{
+    /// Build the final struct
+    pub fn build(self) -> ColourScheme<'a> {
+        ColourScheme {
+            colours: self.__unsafe_private_named.0.unwrap(),
+            name: self.__unsafe_private_named.1.unwrap(),
+            variant: 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>,
+        >,
+    ) -> ColourScheme<'a> {
+        ColourScheme {
+            colours: self.__unsafe_private_named.0.unwrap(),
+            name: self.__unsafe_private_named.1.unwrap(),
+            variant: self.__unsafe_private_named.2.unwrap(),
+            extra_data: Some(extra_data),
+        }
+    }
+}
+
+impl<'a> ColourScheme<'a> {
+    pub fn uri(
+        uri: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> Result<
+        jacquard_common::types::uri::RecordUri<'a, ColourSchemeRecord>,
+        jacquard_common::types::uri::UriError,
+    > {
+        jacquard_common::types::uri::RecordUri::try_from_uri(
+            jacquard_common::types::string::AtUri::new_cow(uri.into())?,
+        )
+    }
+}
+
+#[jacquard_derive::lexicon]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic,
+    Default
+)]
+#[serde(rename_all = "camelCase")]
+pub struct ColourSchemeColours<'a> {
+    /// Primary background for page/frame
+    #[serde(borrow)]
+    pub base: jacquard_common::CowStr<'a>,
+    /// Border/divider colour
+    #[serde(borrow)]
+    pub border: jacquard_common::CowStr<'a>,
+    /// Emphasized text (bold, important)
+    #[serde(borrow)]
+    pub emphasis: jacquard_common::CowStr<'a>,
+    /// Error state colour
+    #[serde(borrow)]
+    pub error: jacquard_common::CowStr<'a>,
+    /// Selection/highlight colour
+    #[serde(borrow)]
+    pub highlight: jacquard_common::CowStr<'a>,
+    /// Hyperlink colour
+    #[serde(borrow)]
+    pub link: jacquard_common::CowStr<'a>,
+    /// De-emphasized text (disabled, metadata)
+    #[serde(borrow)]
+    pub muted: jacquard_common::CowStr<'a>,
+    /// Tertiary background for popovers/dialogs
+    #[serde(borrow)]
+    pub overlay: jacquard_common::CowStr<'a>,
+    /// Primary brand/accent colour
+    #[serde(borrow)]
+    pub primary: jacquard_common::CowStr<'a>,
+    /// Secondary accent colour
+    #[serde(borrow)]
+    pub secondary: jacquard_common::CowStr<'a>,
+    /// Medium emphasis text (comments, labels)
+    #[serde(borrow)]
+    pub subtle: jacquard_common::CowStr<'a>,
+    /// Success state colour
+    #[serde(borrow)]
+    pub success: jacquard_common::CowStr<'a>,
+    /// Secondary background for panels/cards
+    #[serde(borrow)]
+    pub surface: jacquard_common::CowStr<'a>,
+    /// Tertiary accent colour
+    #[serde(borrow)]
+    pub tertiary: jacquard_common::CowStr<'a>,
+    /// Primary readable text colour
+    #[serde(borrow)]
+    pub text: jacquard_common::CowStr<'a>,
+    /// Warning state colour
+    #[serde(borrow)]
+    pub warning: jacquard_common::CowStr<'a>,
+}
+
+fn lexicon_doc_sh_weaver_notebook_colourScheme() -> ::jacquard_lexicon::lexicon::LexiconDoc<
+    'static,
+> {
+    ::jacquard_lexicon::lexicon::LexiconDoc {
+        lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
+        id: ::jacquard_common::CowStr::new_static("sh.weaver.notebook.colourScheme"),
+        revision: None,
+        description: None,
+        defs: {
+            let mut map = ::std::collections::BTreeMap::new();
+            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(
+                            "A colour palette for notebook theming",
+                        ),
+                    ),
+                    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("name"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("variant"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("colours")
+                            ],
+                        ),
+                        nullable: None,
+                        properties: {
+                            #[allow(unused_mut)]
+                            let mut map = ::std::collections::BTreeMap::new();
+                            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("base"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("surface"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("overlay"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("text"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("muted"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("subtle"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("emphasis"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("primary"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("secondary"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("tertiary"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("error"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("warning"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("success"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("border"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("link"),
+                                            ::jacquard_common::smol_str::SmolStr::new_static("highlight")
+                                        ],
+                                    ),
+                                    nullable: None,
+                                    properties: {
+                                        #[allow(unused_mut)]
+                                        let mut map = ::std::collections::BTreeMap::new();
+                                        map.insert(
+                                            ::jacquard_common::smol_str::SmolStr::new_static("base"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Primary background for page/frame",
+                                                    ),
+                                                ),
+                                                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("border"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Border/divider colour",
+                                                    ),
+                                                ),
+                                                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(
+                                                "emphasis",
+                                            ),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Emphasized text (bold, important)",
+                                                    ),
+                                                ),
+                                                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("error"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static("Error state colour"),
+                                                ),
+                                                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(
+                                                "highlight",
+                                            ),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Selection/highlight colour",
+                                                    ),
+                                                ),
+                                                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: Some(
+                                                    ::jacquard_common::CowStr::new_static("Hyperlink colour"),
+                                                ),
+                                                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("muted"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "De-emphasized text (disabled, metadata)",
+                                                    ),
+                                                ),
+                                                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("overlay"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Tertiary background for popovers/dialogs",
+                                                    ),
+                                                ),
+                                                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: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Primary brand/accent colour",
+                                                    ),
+                                                ),
+                                                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: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Secondary accent colour",
+                                                    ),
+                                                ),
+                                                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("subtle"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Medium emphasis text (comments, labels)",
+                                                    ),
+                                                ),
+                                                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("success"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Success state colour",
+                                                    ),
+                                                ),
+                                                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("surface"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Secondary background for panels/cards",
+                                                    ),
+                                                ),
+                                                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(
+                                                "tertiary",
+                                            ),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Tertiary accent colour",
+                                                    ),
+                                                ),
+                                                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("text"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Primary readable text colour",
+                                                    ),
+                                                ),
+                                                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("warning"),
+                                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                                description: Some(
+                                                    ::jacquard_common::CowStr::new_static(
+                                                        "Warning state colour",
+                                                    ),
+                                                ),
+                                                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("name"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                    description: Some(
+                                        ::jacquard_common::CowStr::new_static(
+                                            "Human-readable name for the colour scheme",
+                                        ),
+                                    ),
+                                    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("variant"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                    description: Some(
+                                        ::jacquard_common::CowStr::new_static(
+                                            "Whether this is a dark or light colour scheme",
+                                        ),
+                                    ),
+                                    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
+        },
+    }
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ColourSchemeColours<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.colourScheme"
+    }
+    fn def_name() -> &'static str {
+        "ColourSchemeColours"
+    }
+    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
+        lexicon_doc_sh_weaver_notebook_colourScheme()
+    }
+    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 ColourSchemeGetRecordOutput<'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: ColourScheme<'a>,
+}
+
+impl From<ColourSchemeGetRecordOutput<'_>> for ColourScheme<'_> {
+    fn from(output: ColourSchemeGetRecordOutput<'_>) -> Self {
+        use jacquard_common::IntoStatic;
+        output.value.into_static()
+    }
+}
+
+impl jacquard_common::types::collection::Collection for ColourScheme<'_> {
+    const NSID: &'static str = "sh.weaver.notebook.colourScheme";
+    type Record = ColourSchemeRecord;
+}
+
+/// Marker type for deserializing records from this collection.
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct ColourSchemeRecord;
+impl jacquard_common::xrpc::XrpcResp for ColourSchemeRecord {
+    const NSID: &'static str = "sh.weaver.notebook.colourScheme";
+    const ENCODING: &'static str = "application/json";
+    type Output<'de> = ColourSchemeGetRecordOutput<'de>;
+    type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
+}
+
+impl jacquard_common::types::collection::Collection for ColourSchemeRecord {
+    const NSID: &'static str = "sh.weaver.notebook.colourScheme";
+    type Record = ColourSchemeRecord;
+}
+
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ColourScheme<'a> {
+    fn nsid() -> &'static str {
+        "sh.weaver.notebook.colourScheme"
+    }
+    fn def_name() -> &'static str {
+        "main"
+    }
+    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
+        lexicon_doc_sh_weaver_notebook_colourScheme()
+    }
+    fn validate(
+        &self,
+    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
+        Ok(())
+    }
+}

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

···
                         description: None,
                         required: Some(
                             vec![
-                                ::jacquard_common::smol_str::SmolStr::new_static("colours"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("darkScheme"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("lightScheme"),
                                 ::jacquard_common::smol_str::SmolStr::new_static("fonts"),
                                 ::jacquard_common::smol_str::SmolStr::new_static("spacing"),
-                                ::jacquard_common::smol_str::SmolStr::new_static("codeTheme")
+                                ::jacquard_common::smol_str::SmolStr::new_static("darkCodeTheme"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("lightCodeTheme")
                             ],
                         ),
                         nullable: None,
···
                             let mut map = ::std::collections::BTreeMap::new();
                             map.insert(
                                 ::jacquard_common::smol_str::SmolStr::new_static(
-                                    "codeTheme",
+                                    "darkCodeTheme",
                                 ),
                                 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
-                                    description: None,
+                                    description: Some(
+                                        ::jacquard_common::CowStr::new_static(
+                                            "Syntax highlighting theme for dark mode",
+                                        ),
+                                    ),
                                     refs: vec![
                                         ::jacquard_common::CowStr::new_static("#codeThemeName"),
                                         ::jacquard_common::CowStr::new_static("#codeThemeFile")
···
                                 }),
                             );
                             map.insert(
-                                ::jacquard_common::smol_str::SmolStr::new_static("colours"),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::Object(::jacquard_lexicon::lexicon::LexObject {
+                                ::jacquard_common::smol_str::SmolStr::new_static(
+                                    "darkScheme",
+                                ),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
                                     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")
-                                        ],
+                                    r#ref: ::jacquard_common::CowStr::new_static(
+                                        "com.atproto.repo.strongRef",
                                     ),
-                                    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(
···
                                 }),
                             );
                             map.insert(
+                                ::jacquard_common::smol_str::SmolStr::new_static(
+                                    "lightCodeTheme",
+                                ),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
+                                    description: Some(
+                                        ::jacquard_common::CowStr::new_static(
+                                            "Syntax highlighting theme for light mode",
+                                        ),
+                                    ),
+                                    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(
+                                    "lightScheme",
+                                ),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
+                                    description: None,
+                                    r#ref: ::jacquard_common::CowStr::new_static(
+                                        "com.atproto.repo.strongRef",
+                                    ),
+                                }),
+                            );
+                            map.insert(
                                 ::jacquard_common::smol_str::SmolStr::new_static("spacing"),
                                 ::jacquard_lexicon::lexicon::LexObjectProperty::Object(::jacquard_lexicon::lexicon::LexObject {
                                     description: None,
···
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Theme<'a> {
+    /// Syntax highlighting theme for dark mode
     #[serde(borrow)]
-    pub code_theme: ThemeCodeTheme<'a>,
+    pub dark_code_theme: ThemeDarkCodeTheme<'a>,
+    /// Reference to a dark colour scheme
     #[serde(borrow)]
-    pub colours: ThemeColours<'a>,
+    pub dark_scheme: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(borrow)]
     pub fonts: ThemeFonts<'a>,
+    /// Syntax highlighting theme for light mode
+    #[serde(borrow)]
+    pub light_code_theme: ThemeLightCodeTheme<'a>,
+    /// Reference to a light colour scheme
+    #[serde(borrow)]
+    pub light_scheme: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(borrow)]
     pub spacing: ThemeSpacing<'a>,
 }
···
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Colours;
+        type DarkScheme;
+        type LightScheme;
         type Fonts;
         type Spacing;
-        type CodeTheme;
+        type DarkCodeTheme;
+        type LightCodeTheme;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Colours = Unset;
+        type DarkScheme = Unset;
+        type LightScheme = Unset;
         type Fonts = Unset;
         type Spacing = Unset;
-        type CodeTheme = Unset;
+        type DarkCodeTheme = Unset;
+        type LightCodeTheme = 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>;
+    ///State transition - sets the `dark_scheme` field to Set
+    pub struct SetDarkScheme<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetDarkScheme<S> {}
+    impl<S: State> State for SetDarkScheme<S> {
+        type DarkScheme = Set<members::dark_scheme>;
+        type LightScheme = S::LightScheme;
         type Fonts = S::Fonts;
         type Spacing = S::Spacing;
-        type CodeTheme = S::CodeTheme;
+        type DarkCodeTheme = S::DarkCodeTheme;
+        type LightCodeTheme = S::LightCodeTheme;
+    }
+    ///State transition - sets the `light_scheme` field to Set
+    pub struct SetLightScheme<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetLightScheme<S> {}
+    impl<S: State> State for SetLightScheme<S> {
+        type DarkScheme = S::DarkScheme;
+        type LightScheme = Set<members::light_scheme>;
+        type Fonts = S::Fonts;
+        type Spacing = S::Spacing;
+        type DarkCodeTheme = S::DarkCodeTheme;
+        type LightCodeTheme = S::LightCodeTheme;
     }
     ///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 DarkScheme = S::DarkScheme;
+        type LightScheme = S::LightScheme;
         type Fonts = Set<members::fonts>;
         type Spacing = S::Spacing;
-        type CodeTheme = S::CodeTheme;
+        type DarkCodeTheme = S::DarkCodeTheme;
+        type LightCodeTheme = S::LightCodeTheme;
     }
     ///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 DarkScheme = S::DarkScheme;
+        type LightScheme = S::LightScheme;
         type Fonts = S::Fonts;
         type Spacing = Set<members::spacing>;
-        type CodeTheme = S::CodeTheme;
+        type DarkCodeTheme = S::DarkCodeTheme;
+        type LightCodeTheme = S::LightCodeTheme;
+    }
+    ///State transition - sets the `dark_code_theme` field to Set
+    pub struct SetDarkCodeTheme<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetDarkCodeTheme<S> {}
+    impl<S: State> State for SetDarkCodeTheme<S> {
+        type DarkScheme = S::DarkScheme;
+        type LightScheme = S::LightScheme;
+        type Fonts = S::Fonts;
+        type Spacing = S::Spacing;
+        type DarkCodeTheme = Set<members::dark_code_theme>;
+        type LightCodeTheme = S::LightCodeTheme;
     }
-    ///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;
+    ///State transition - sets the `light_code_theme` field to Set
+    pub struct SetLightCodeTheme<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetLightCodeTheme<S> {}
+    impl<S: State> State for SetLightCodeTheme<S> {
+        type DarkScheme = S::DarkScheme;
+        type LightScheme = S::LightScheme;
         type Fonts = S::Fonts;
         type Spacing = S::Spacing;
-        type CodeTheme = Set<members::code_theme>;
+        type DarkCodeTheme = S::DarkCodeTheme;
+        type LightCodeTheme = Set<members::light_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 `dark_scheme` field
+        pub struct dark_scheme(());
+        ///Marker type for the `light_scheme` field
+        pub struct light_scheme(());
         ///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(());
+        ///Marker type for the `dark_code_theme` field
+        pub struct dark_code_theme(());
+        ///Marker type for the `light_code_theme` field
+        pub struct light_code_theme(());
     }
 }
 
···
 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<ThemeDarkCodeTheme<'a>>,
+        ::core::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
         ::core::option::Option<ThemeFonts<'a>>,
+        ::core::option::Option<ThemeLightCodeTheme<'a>>,
+        ::core::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
         ::core::option::Option<ThemeSpacing<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
···
     pub fn new() -> Self {
         ThemeBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None),
+            __unsafe_private_named: (None, None, None, None, None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
 impl<'a, S> ThemeBuilder<'a, S>
 where
     S: theme_state::State,
-    S::CodeTheme: theme_state::IsUnset,
+    S::DarkCodeTheme: theme_state::IsUnset,
 {
-    /// Set the `codeTheme` field (required)
-    pub fn code_theme(
+    /// Set the `darkCodeTheme` field (required)
+    pub fn dark_code_theme(
         mut self,
-        value: impl Into<ThemeCodeTheme<'a>>,
-    ) -> ThemeBuilder<'a, theme_state::SetCodeTheme<S>> {
+        value: impl Into<ThemeDarkCodeTheme<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetDarkCodeTheme<S>> {
         self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
         ThemeBuilder {
             _phantom_state: ::core::marker::PhantomData,
···
 impl<'a, S> ThemeBuilder<'a, S>
 where
     S: theme_state::State,
-    S::Colours: theme_state::IsUnset,
+    S::DarkScheme: theme_state::IsUnset,
 {
-    /// Set the `colours` field (required)
-    pub fn colours(
+    /// Set the `darkScheme` field (required)
+    pub fn dark_scheme(
         mut self,
-        value: impl Into<ThemeColours<'a>>,
-    ) -> ThemeBuilder<'a, theme_state::SetColours<S>> {
+        value: impl Into<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetDarkScheme<S>> {
         self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
         ThemeBuilder {
             _phantom_state: ::core::marker::PhantomData,
···
 impl<'a, S> ThemeBuilder<'a, S>
 where
     S: theme_state::State,
+    S::LightCodeTheme: theme_state::IsUnset,
+{
+    /// Set the `lightCodeTheme` field (required)
+    pub fn light_code_theme(
+        mut self,
+        value: impl Into<ThemeLightCodeTheme<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetLightCodeTheme<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::LightScheme: theme_state::IsUnset,
+{
+    /// Set the `lightScheme` field (required)
+    pub fn light_scheme(
+        mut self,
+        value: impl Into<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    ) -> ThemeBuilder<'a, theme_state::SetLightScheme<S>> {
+        self.__unsafe_private_named.4 = ::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)
···
         mut self,
         value: impl Into<ThemeSpacing<'a>>,
     ) -> ThemeBuilder<'a, theme_state::SetSpacing<S>> {
-        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.5 = ::core::option::Option::Some(value.into());
         ThemeBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
 impl<'a, S> ThemeBuilder<'a, S>
 where
     S: theme_state::State,
-    S::Colours: theme_state::IsSet,
+    S::DarkScheme: theme_state::IsSet,
+    S::LightScheme: theme_state::IsSet,
     S::Fonts: theme_state::IsSet,
     S::Spacing: theme_state::IsSet,
-    S::CodeTheme: theme_state::IsSet,
+    S::DarkCodeTheme: theme_state::IsSet,
+    S::LightCodeTheme: 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(),
+            dark_code_theme: self.__unsafe_private_named.0.unwrap(),
+            dark_scheme: self.__unsafe_private_named.1.unwrap(),
             fonts: self.__unsafe_private_named.2.unwrap(),
-            spacing: self.__unsafe_private_named.3.unwrap(),
+            light_code_theme: self.__unsafe_private_named.3.unwrap(),
+            light_scheme: self.__unsafe_private_named.4.unwrap(),
+            spacing: self.__unsafe_private_named.5.unwrap(),
             extra_data: Default::default(),
         }
     }
···
         >,
     ) -> Theme<'a> {
         Theme {
-            code_theme: self.__unsafe_private_named.0.unwrap(),
-            colours: self.__unsafe_private_named.1.unwrap(),
+            dark_code_theme: self.__unsafe_private_named.0.unwrap(),
+            dark_scheme: self.__unsafe_private_named.1.unwrap(),
             fonts: self.__unsafe_private_named.2.unwrap(),
-            spacing: self.__unsafe_private_named.3.unwrap(),
+            light_code_theme: self.__unsafe_private_named.3.unwrap(),
+            light_scheme: self.__unsafe_private_named.4.unwrap(),
+            spacing: self.__unsafe_private_named.5.unwrap(),
             extra_data: Some(extra_data),
         }
     }
···
 )]
 #[serde(tag = "$type")]
 #[serde(bound(deserialize = "'de: 'a"))]
-pub enum ThemeCodeTheme<'a> {
+pub enum ThemeDarkCodeTheme<'a> {
     #[serde(rename = "sh.weaver.notebook.theme#codeThemeName")]
     CodeThemeName(Box<crate::sh_weaver::notebook::theme::CodeThemeName<'a>>),
     #[serde(rename = "sh.weaver.notebook.theme#codeThemeFile")]
···
     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>,
+pub struct ThemeFonts<'a> {
     #[serde(borrow)]
-    pub link: jacquard_common::CowStr<'a>,
+    pub body: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
-    pub link_hover: jacquard_common::CowStr<'a>,
+    pub heading: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
-    pub primary: jacquard_common::CowStr<'a>,
-    #[serde(borrow)]
-    pub secondary: jacquard_common::CowStr<'a>,
+    pub monospace: jacquard_common::CowStr<'a>,
 }
 
-impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThemeColours<'a> {
+impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThemeFonts<'a> {
     fn nsid() -> &'static str {
         "sh.weaver.notebook.theme"
     }
     fn def_name() -> &'static str {
-        "ThemeColours"
+        "ThemeFonts"
     }
     fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
         lexicon_doc_sh_weaver_notebook_theme()
···
     }
 }
 
-#[jacquard_derive::lexicon]
+#[jacquard_derive::open_union]
 #[derive(
     serde::Serialize,
     serde::Deserialize,
···
     Clone,
     PartialEq,
     Eq,
-    jacquard_derive::IntoStatic,
-    Default
+    jacquard_derive::IntoStatic
 )]
-#[serde(rename_all = "camelCase")]
-pub struct ThemeFonts<'a> {
-    #[serde(borrow)]
-    pub body: jacquard_common::CowStr<'a>,
-    #[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(())
-    }
+#[serde(tag = "$type")]
+#[serde(bound(deserialize = "'de: 'a"))]
+pub enum ThemeLightCodeTheme<'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]

crates/weaver-common/src/lib.rs

···
         &self,
         ident: &jacquard::types::ident::AtIdentifier<'_>,
         title: &str,
-    ) -> impl Future<Output = Result<Option<(view::NotebookView<'static>, Vec<StrongRef<'static>>)>, WeaverError>>;
+    ) -> impl Future<
+        Output = Result<
+            Option<(view::NotebookView<'static>, Vec<StrongRef<'static>>)>,
+            WeaverError,
+        >,
+    >;
 }
 
 impl<A: AgentSession + IdentityResolver> WeaverExt for Agent<A> {
···
         url_path: &'a str,
         prev: Option<Tid>,
     ) -> Result<(StrongRef<'a>, PublishedBlob<'a>), WeaverError> {
-        let mime_type = MimeType::new_owned(
-            blob.sniff_mime_type()
-                .unwrap_or("applicaction/octet-stream"),
-        );
+        let mime_type =
+            MimeType::new_owned(blob.sniff_mime_type().unwrap_or("application/octet-stream"));
 
         let blob = self.upload_blob(blob, mime_type).await?;
         let publish_record = PublishedBlob::new()
···
         if let Ok(list) = resp.parse() {
             for record in list.records {
                 let notebook: Book = jacquard::from_data(&record.value).map_err(|_| {
-                    AgentError::from(ClientError::invalid_request("Failed to parse notebook record"))
+                    AgentError::from(ClientError::invalid_request(
+                        "Failed to parse notebook record",
+                    ))
                 })?;
                 if let Some(book_title) = notebook.title
                     && book_title == title
···
 
         // Add to notebook's entry_list
         use weaver_api::sh_weaver::notebook::book::Book;
-        let new_ref = StrongRef::new()
-            .uri(response.uri)
-            .cid(response.cid)
-            .build();
+        let new_ref = StrongRef::new().uri(response.uri).cid(response.cid).build();
 
         self.update_record::<Book>(&notebook_uri, |book| {
             book.entry_list.push(new_ref);
···
         &self,
         uri: &AtUri<'_>,
     ) -> Result<(view::NotebookView<'static>, Vec<StrongRef<'static>>), WeaverError> {
+        use jacquard::to_data;
         use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+        use weaver_api::sh_weaver::notebook::AuthorListView;
         use weaver_api::sh_weaver::notebook::book::Book;
-        use weaver_api::sh_weaver::notebook::AuthorListView;
-        use jacquard::to_data;
 
         let notebook = self
             .get_record::<Book>(uri)
···
         let mut authors = Vec::new();
 
         for (index, author) in notebook.value.authors.iter().enumerate() {
-            let author_uri = BskyProfile::uri(format!("at://{}/app.bsky.actor.profile/self", author.did))
-                .map_err(|_| AgentError::from(ClientError::invalid_request("Invalid author profile URI")))?;
+            let author_uri =
+                BskyProfile::uri(format!("at://{}/app.bsky.actor.profile/self", author.did))
+                    .map_err(|_| {
+                        AgentError::from(ClientError::invalid_request("Invalid author profile URI"))
+                    })?;
             let author_profile = self.fetch_record(&author_uri).await?;
 
             authors.push(
                 AuthorListView::new()
                     .uri(author_uri.as_uri().clone())
                     .record(to_data(&author_profile).map_err(|_| {
-                        AgentError::from(ClientError::invalid_request("Failed to serialize author profile"))
+                        AgentError::from(ClientError::invalid_request(
+                            "Failed to serialize author profile",
+                        ))
                     })?)
                     .index(index as i64)
                     .build(),
···
         notebook: &view::NotebookView<'a>,
         entry_ref: &StrongRef<'_>,
     ) -> Result<view::EntryView<'a>, WeaverError> {
-        use weaver_api::sh_weaver::notebook::entry::Entry;
         use jacquard::to_data;
+        use weaver_api::sh_weaver::notebook::entry::Entry;
 
         let entry_uri = Entry::uri(entry_ref.uri.clone())
             .map_err(|_| AgentError::from(ClientError::invalid_request("Invalid entry URI")))?;
···
         entries: &[StrongRef<'_>],
         title: &str,
     ) -> Result<Option<(view::BookEntryView<'a>, entry::Entry<'a>)>, WeaverError> {
-        use weaver_api::sh_weaver::notebook::entry::Entry;
         use weaver_api::sh_weaver::notebook::BookEntryRef;
+        use weaver_api::sh_weaver::notebook::entry::Entry;
 
         for (index, entry_ref) in entries.iter().enumerate() {
             let resp = self
···
         ident: &jacquard::types::ident::AtIdentifier<'_>,
         title: &str,
     ) -> Result<Option<(view::NotebookView<'static>, Vec<StrongRef<'static>>)>, WeaverError> {
+        use jacquard::to_data;
         use jacquard::types::collection::Collection;
         use jacquard::types::nsid::Nsid;
         use jacquard::xrpc::XrpcExt;
+        use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
         use weaver_api::com_atproto::repo::list_records::ListRecords;
-        use weaver_api::sh_weaver::notebook::book::Book;
-        use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
         use weaver_api::sh_weaver::notebook::AuthorListView;
-        use jacquard::to_data;
+        use weaver_api::sh_weaver::notebook::book::Book;
 
         let (repo_did, pds_url) = match ident {
             jacquard::types::ident::AtIdentifier::Did(did) => {
                 let pds = self.pds_for_did(did).await.map_err(|e| {
-                    AgentError::from(ClientError::from(e).with_context("Failed to resolve PDS for DID"))
+                    AgentError::from(
+                        ClientError::from(e).with_context("Failed to resolve PDS for DID"),
+                    )
                 })?;
                 (did.clone(), pds)
             }
-            jacquard::types::ident::AtIdentifier::Handle(handle) => self.pds_for_handle(handle).await.map_err(|e| {
-                AgentError::from(ClientError::from(e).with_context("Failed to resolve handle"))
-            })?,
+            jacquard::types::ident::AtIdentifier::Handle(handle) => {
+                self.pds_for_handle(handle).await.map_err(|e| {
+                    AgentError::from(ClientError::from(e).with_context("Failed to resolve handle"))
+                })?
+            }
         };
 
         // TODO: use the cursor to search through all records with this NSID for the repo
···
         if let Ok(list) = resp.parse() {
             for record in list.records {
                 let notebook: Book = jacquard::from_data(&record.value).map_err(|_| {
-                    AgentError::from(ClientError::invalid_request("Failed to parse notebook record"))
+                    AgentError::from(ClientError::invalid_request(
+                        "Failed to parse notebook record",
+                    ))
                 })?;
                 if let Some(book_title) = notebook.title
                     && book_title == title
···
                             "at://{}/app.bsky.actor.profile/self",
                             author.did
                         ))
-                        .map_err(|_| AgentError::from(ClientError::invalid_request("Invalid author profile URI")))?;
+                        .map_err(|_| {
+                            AgentError::from(ClientError::invalid_request(
+                                "Invalid author profile URI",
+                            ))
+                        })?;
                         let author_profile = self.fetch_record(&author_uri).await?;
 
                         authors.push(
                             AuthorListView::new()
                                 .uri(author_uri.as_uri().clone())
                                 .record(to_data(&author_profile).map_err(|_| {
-                                    AgentError::from(ClientError::invalid_request("Failed to serialize author profile"))
+                                    AgentError::from(ClientError::invalid_request(
+                                        "Failed to serialize author profile",
+                                    ))
                                 })?)
                                 .index(index as i64)
                                 .build(),

crates/weaver-renderer/src/atproto/writer.rs

···
 ///
 /// This writer is designed for client-side rendering where embeds may have
 /// pre-rendered content in their attributes.
-pub struct ClientWriter<W: StrWrite, E = ()> {
+pub struct ClientWriter<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E = ()> {
+    events: I,
     writer: W,
     end_newline: bool,
     in_non_writing_block: bool,
···
     embed_provider: Option<E>,
 
     code_buffer: Option<(Option<String>, String)>, // (lang, content)
+    _phantom: std::marker::PhantomData<&'a ()>,
 }
 
 #[derive(Debug, Clone, Copy)]
···
     Body,
 }
 
-impl<W: StrWrite, E: EmbedContentProvider> ClientWriter<W, E> {
-    pub fn new(writer: W) -> Self {
+impl<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E: EmbedContentProvider> ClientWriter<'a, I, W, E> {
+    pub fn new(events: I, writer: W) -> Self {
         Self {
+            events,
             writer,
             end_newline: true,
             in_non_writing_block: false,
···
             numbers: HashMap::new(),
             embed_provider: None,
             code_buffer: None,
+            _phantom: std::marker::PhantomData,
         }
     }
 
     /// Add an embed content provider
-    pub fn with_embed_provider(self, provider: E) -> ClientWriter<W, E> {
+    pub fn with_embed_provider(self, provider: E) -> ClientWriter<'a, I, W, E> {
         ClientWriter {
+            events: self.events,
             writer: self.writer,
             end_newline: self.end_newline,
             in_non_writing_block: self.in_non_writing_block,
···
             numbers: self.numbers,
             embed_provider: Some(provider),
             code_buffer: self.code_buffer,
+            _phantom: std::marker::PhantomData,
         }
     }
-}
-
-impl<W: StrWrite, E: EmbedContentProvider> ClientWriter<W, E> {
     #[inline]
     fn write_newline(&mut self) -> Result<(), W::Error> {
         self.end_newline = true;
···
     }
 
     /// Process markdown events and write HTML
-    pub fn run<'a>(mut self, events: impl Iterator<Item = Event<'a>>) -> Result<W, W::Error> {
-        for event in events {
+    pub fn run(mut self) -> Result<W, W::Error> {
+        while let Some(event) = self.events.next() {
             self.process_event(event)?;
         }
         Ok(self.writer)
     }
 
+    // Consume raw text events until end tag, for alt attributes
+    fn raw_text(&mut self) -> Result<(), W::Error> {
+        use Event::*;
+        let mut nest = 0;
+        while let Some(event) = self.events.next() {
+            match event {
+                Start(_) => nest += 1,
+                End(_) => {
+                    if nest == 0 {
+                        break;
+                    }
+                    nest -= 1;
+                }
+                Html(_) => {}
+                InlineHtml(text) | Code(text) | Text(text) => {
+                    // Don't use escape_html_body_text here.
+                    // The output of this function is used in the `alt` attribute.
+                    escape_html(&mut self.writer, &text)?;
+                    self.end_newline = text.ends_with('\n');
+                }
+                InlineMath(text) => {
+                    self.write("$")?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("$")?;
+                }
+                DisplayMath(text) => {
+                    self.write("$$")?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("$$")?;
+                }
+                SoftBreak | HardBreak | Rule => {
+                    self.write(" ")?;
+                }
+                FootnoteReference(name) => {
+                    let len = self.numbers.len() + 1;
+                    let number = *self.numbers.entry(name.into_string()).or_insert(len);
+                    write!(&mut self.writer, "[{}]", number)?;
+                }
+                TaskListMarker(true) => self.write("[x]")?,
+                TaskListMarker(false) => self.write("[ ]")?,
+                WeaverBlock(_) => {}
+            }
+        }
+        Ok(())
+    }
+
     fn process_event(&mut self, event: Event<'_>) -> Result<(), W::Error> {
         use Event::*;
         match event {
···
                 self.write("<img src=\"")?;
                 escape_href(&mut self.writer, &dest_url)?;
                 self.write("\" alt=\"")?;
+                // Consume text events for alt attribute
+                self.raw_text()?;
+                self.write("\"")?;
                 if !title.is_empty() {
+                    self.write(" title=\"")?;
                     escape_html(&mut self.writer, &title)?;
+                    self.write("\"")?;
                 }
                 if let Some(attrs) = attrs {
                     if !attrs.classes.is_empty() {
-                        self.write("\" class=\"")?;
+                        self.write(" class=\"")?;
                         for (i, class) in attrs.classes.iter().enumerate() {
                             if i > 0 {
                                 self.write(" ")?;
                             }
                             escape_html(&mut self.writer, class)?;
                         }
+                        self.write("\"")?;
                     }
-                    self.write("\"")?;
                     for (attr, value) in &attrs.attrs {
                         self.write(" ")?;
                         escape_html(&mut self.writer, attr)?;
···
                         escape_html(&mut self.writer, value)?;
                         self.write("\"")?;
                     }
-                } else {
-                    self.write("\"")?;
                 }
                 self.write(" />")
             }
···
             TagEnd::Strong => self.write("</strong>"),
             TagEnd::Strikethrough => self.write("</del>"),
             TagEnd::Link => self.write("</a>"),
-            TagEnd::Image => Ok(()),
+            TagEnd::Image => Ok(()), // No-op: raw_text() already consumed the End(Image) event
             TagEnd::Embed => Ok(()),
             TagEnd::WeaverBlock(_) => {
                 self.in_non_writing_block = false;
···
     }
 }
 
-impl<W: StrWrite, E: EmbedContentProvider> ClientWriter<W, E> {
+impl<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E: EmbedContentProvider> ClientWriter<'a, I, W, E> {
     fn write_embed(
         &mut self,
         embed_type: EmbedType,

crates/weaver-renderer/src/code_pretty.rs

···
             .find_syntax_by_first_line(code.as_ref())
             .unwrap_or_else(|| syn_set.find_syntax_plain_text())
     };
-    writer.write_str("<pre><code class=\"language-")?;
+    writer.write_str("<pre><code class=\"wvrcode-code language-")?;
     writer.write_str(&lang_syn.name)?;
     writer.write_str("\">")?;
 

crates/weaver-renderer/src/css.rs

···
-use crate::theme::Theme;
+use crate::theme::{ResolvedTheme, ThemeDarkCodeTheme, ThemeLightCodeTheme};
 use miette::IntoDiagnostic;
 use std::io::Cursor;
 use syntect::highlighting::ThemeSet;
 use syntect::html::{ClassStyle, css_for_theme_with_class_style};
 use weaver_api::com_atproto::sync::get_blob::GetBlob;
-use weaver_api::sh_weaver::notebook::theme::ThemeCodeTheme;
 use weaver_common::jacquard::client::BasicClient;
 use weaver_common::jacquard::prelude::*;
 use weaver_common::jacquard::xrpc::XrpcExt;
···
 const ROSE_PINE_THEME: &str = include_str!("../themes/rose-pine.tmTheme");
 const ROSE_PINE_DAWN_THEME: &str = include_str!("../themes/rose-pine-dawn.tmTheme");
 
-pub fn generate_base_css(theme: &Theme) -> String {
+pub fn generate_base_css(theme: &ResolvedTheme) -> String {
+    let dark = &theme.dark_scheme;
+    let light = &theme.light_scheme;
+    let fonts = &theme.fonts;
+    let spacing = &theme.spacing;
+
     format!(
         r#"/* CSS Reset */
 *, *::before, *::after {{
···
     padding: 0;
 }}
 
-/* CSS Variables */
+/* CSS Variables - Light Mode (default) */
 :root {{
-    --color-background: {};
-    --color-foreground: {};
-    --color-link: {};
-    --color-link-hover: {};
+    --color-base: {};
+    --color-surface: {};
+    --color-overlay: {};
+    --color-text: {};
+    --color-muted: {};
+    --color-subtle: {};
+    --color-emphasis: {};
     --color-primary: {};
     --color-secondary: {};
+    --color-tertiary: {};
+    --color-error: {};
+    --color-warning: {};
+    --color-success: {};
+    --color-border: {};
+    --color-link: {};
+    --color-highlight: {};
 
     --font-body: {};
     --font-heading: {};
···
     --spacing-scale: {};
 }}
 
+/* CSS Variables - Dark Mode */
+@media (prefers-color-scheme: dark) {{
+    :root {{
+        --color-base: {};
+        --color-surface: {};
+        --color-overlay: {};
+        --color-text: {};
+        --color-muted: {};
+        --color-subtle: {};
+        --color-emphasis: {};
+        --color-primary: {};
+        --color-secondary: {};
+        --color-tertiary: {};
+        --color-error: {};
+        --color-warning: {};
+        --color-success: {};
+        --color-border: {};
+        --color-link: {};
+        --color-highlight: {};
+    }}
+}}
+
 /* Base Styles */
 html {{
     font-size: var(--spacing-base);
···
 
 body {{
     font-family: var(--font-body);
-    color: var(--color-foreground);
-    background-color: var(--color-background);
+    color: var(--color-text);
+    background-color: var(--color-base);
     max-width: 90ch;
     margin: 0 auto;
     padding: 2rem 1rem;
···
 }}
 
 a:hover {{
-    color: var(--color-link-hover);
+    color: var(--color-emphasis);
     text-decoration: underline;
+}}
+
+/* Selection */
+::selection {{
+    background: var(--color-highlight);
+    color: var(--color-text);
 }}
 
 /* Lists */
···
 /* Code */
 code {{
     font-family: var(--font-mono);
-    background-color: rgba(0, 0, 0, 0.05);
+    background: var(--color-surface);
     padding: 0.125rem 0.25rem;
-    border-radius: 3px;
+    border-radius: 4px;
     font-size: 0.9em;
 }}
 
 pre {{
     overflow-x: auto;
     margin-bottom: 1rem;
+    border-radius: 5px;
+    border: 1px solid var(--color-border);
+    box-sizing: border-box;
 }}
 
+/* Code blocks inside pre are handled by syntax theme */
 pre code {{
     display: block;
+    width: fit-content;
+    min-width: 100%;
     padding: 1rem;
-    background-color: rgba(0, 0, 0, 0.03);
-    border-radius: 5px;
+    background: var(--color-surface);
 }}
 
 /* Math */
···
 
 /* Blockquotes */
 blockquote {{
-    border-left: 4px solid var(--color-link);
+    border-left: 2px solid var(--color-secondary);
+    background: var(--color-surface);
     padding-left: 1rem;
     padding-right: 1rem;
+    padding-top: 0.5rem;
+    padding-bottom: 0.04rem;
     margin: 1rem 0;
-    font-style: italic;
+    font-size: 0.95em;
+    border-bottom-right-radius: 5px;
+    border-top-right-radius: 5px;
+}}
 }}
 
 /* Tables */
···
 }}
 
 th, td {{
-    border: 1px solid rgba(0, 0, 0, 0.1);
+    border: 1px solid var(--color-border);
     padding: 0.5rem;
     text-align: left;
 }}
 
 th {{
-    background-color: rgba(0, 0, 0, 0.05);
+    background: var(--color-surface);
     font-weight: 600;
 }}
 
+tr:hover {{
+    background: var(--color-surface);
+}}
+
 /* Footnotes */
 .footnote-reference {{
     font-size: 0.8em;
+    color: var(--color-subtle);
 }}
 
 .footnote-definition {{
     margin-top: 2rem;
     padding-top: 0.5rem;
-    border-top: 1px solid rgba(0, 0, 0, 0.1);
+    border-top: 1px solid var(--color-border);
     font-size: 0.9em;
 }}
 
 .footnote-definition-label {{
     font-weight: 600;
     margin-right: 0.5rem;
+    color: var(--color-primary);
 }}
 
 /* Images */
···
     height: auto;
     display: block;
     margin: 1rem 0;
+    border-radius: 4px;
 }}
 
 /* Horizontal Rule */
 hr {{
     border: none;
-    border-top: 1px solid rgba(0, 0, 0, 0.1);
+    border-top: 2px solid var(--color-border);
     margin: 2rem 0;
 }}
 "#,
-        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_size,
-        theme.spacing.line_height,
-        theme.spacing.scale,
+        // Light mode colours
+        light.base,
+        light.surface,
+        light.overlay,
+        light.text,
+        light.muted,
+        light.subtle,
+        light.emphasis,
+        light.primary,
+        light.secondary,
+        light.tertiary,
+        light.error,
+        light.warning,
+        light.success,
+        light.border,
+        light.link,
+        light.highlight,
+        // Fonts and spacing
+        fonts.body,
+        fonts.heading,
+        fonts.monospace,
+        spacing.base_size,
+        spacing.line_height,
+        spacing.scale,
+        // Dark mode colours
+        dark.base,
+        dark.surface,
+        dark.overlay,
+        dark.text,
+        dark.muted,
+        dark.subtle,
+        dark.emphasis,
+        dark.primary,
+        dark.secondary,
+        dark.tertiary,
+        dark.error,
+        dark.warning,
+        dark.success,
+        dark.border,
+        dark.link,
+        dark.highlight,
     )
 }
 
-pub async fn generate_syntax_css(theme: &Theme<'_>) -> miette::Result<String> {
-    let syntect_theme = match &theme.code_theme {
-        ThemeCodeTheme::CodeThemeName(name) => {
+async fn load_syntect_dark_theme(
+    code_theme: &ThemeDarkCodeTheme<'_>,
+) -> miette::Result<syntect::highlighting::Theme> {
+    match code_theme {
+        ThemeDarkCodeTheme::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))
+                        .cloned()
+                }
+            }
+        }
+        ThemeDarkCodeTheme::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))
+        }
+    }
+}
+
+async fn load_syntect_light_theme(
+    code_theme: &ThemeLightCodeTheme<'_>,
+) -> miette::Result<syntect::highlighting::Theme> {
+    match code_theme {
+        ThemeLightCodeTheme::CodeThemeName(name) => {
             match name.as_str() {
                 "rose-pine" => {
                     let mut cursor = Cursor::new(ROSE_PINE_THEME.as_bytes());
···
                         .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());
···
                         .into_diagnostic()
                         .map_err(|e| {
                             miette::miette!("Failed to load embedded rose-pine-dawn theme: {}", e)
-                        })?
+                        })
                 }
                 _ => {
                     // Fall back to syntect's built-in themes
···
                     theme_set
                         .themes
                         .get(name.as_str())
-                        .ok_or_else(|| miette::miette!("Theme '{}' not found in defaults", name))?
-                        .clone()
+                        .ok_or_else(|| miette::miette!("Theme '{}' not found in defaults", name))
+                        .cloned()
                 }
             }
         }
-        ThemeCodeTheme::CodeThemeFile(file) => {
+        ThemeLightCodeTheme::CodeThemeFile(file) => {
             let client = BasicClient::unauthenticated();
             let pds = client.pds_for_did(&file.did).await?;
             let blob = client
···
             let mut cursor = Cursor::new(blob);
             ThemeSet::load_from_reader(&mut cursor)
                 .into_diagnostic()
-                .map_err(|e| miette::miette!("Failed to download theme: {}", e))?
+                .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))?
+                .map_err(|e| miette::miette!("Failed to load embedded rose-pine theme: {}", e))
         }
-    };
+    }
+}
+
+pub async fn generate_syntax_css(theme: &ResolvedTheme<'_>) -> miette::Result<String> {
+    // Load both themes
+    let dark_syntect_theme = load_syntect_dark_theme(&theme.dark_code_theme).await?;
+    let light_syntect_theme = load_syntect_light_theme(&theme.light_code_theme).await?;
+
+    // Generate dark mode CSS (default)
+    let dark_css = css_for_theme_with_class_style(
+        &dark_syntect_theme,
+        ClassStyle::SpacedPrefixed {
+            prefix: crate::code_pretty::CSS_PREFIX,
+        },
+    )
+    .into_diagnostic()?;
 
-    let css = css_for_theme_with_class_style(
-        &syntect_theme,
+    // Generate light mode CSS
+    let light_css = css_for_theme_with_class_style(
+        &light_syntect_theme,
         ClassStyle::SpacedPrefixed {
             prefix: crate::code_pretty::CSS_PREFIX,
         },
     )
     .into_diagnostic()?;
 
-    Ok(css)
+    // Combine with media queries
+    let mut result = String::new();
+    result.push_str("/* Syntax highlighting - Light Mode (default) */\n");
+    result.push_str(&light_css);
+    result.push_str("\n\n/* Syntax highlighting - Dark Mode */\n");
+    result.push_str("@media (prefers-color-scheme: dark) {\n");
+    result.push_str(&dark_css);
+    result.push_str("}\n");
+
+    Ok(result)
 }

crates/weaver-renderer/src/static_site.rs

···
         document::{CssMode, write_document_footer, write_document_head},
         writer::StaticPageWriter,
     },
-    theme::default_theme,
+    theme::default_resolved_theme,
     utils::flatten_dir_to_just_one_parent,
     walker::{WalkOptions, vault_contents},
 };
···
             .await
             .into_diagnostic()?;
 
-        let default_theme = default_theme();
+        let default_theme = default_resolved_theme();
         let theme = self.context.theme.as_deref().unwrap_or(&default_theme);
 
         // Write base.css

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

···
 use crate::static_site::{StaticSiteOptions};
-use crate::theme::Theme;
+use crate::theme::ResolvedTheme;
 use crate::{Frontmatter, NotebookContext,default_md_options};
 use dashmap::DashMap;
 use markdown_weaver::{CowStr, EmbedType, Tag, WeaverAttributes};
···
     pub client: Option<reqwest::Client>,
     agent: Option<Arc<Agent<A>>>,
 
-    pub theme: Option<Arc<Theme<'static>>>,
+    pub theme: Option<Arc<ResolvedTheme<'static>>>,
     pub katex_source: Option<KaTeXSource>,
     pub syntax_set: Arc<SyntaxSet>,
     pub index_file: Option<PathBuf>,
···
         }
     }
     pub fn new(root: PathBuf, destination: PathBuf, session: Option<A>) -> Self {
+        use crate::theme::default_resolved_theme;
+
         Self {
             start_at: root.clone(),
             root,
···
             position: 0,
             client: Some(reqwest::Client::default()),
             agent: session.map(|session| Arc::new(Agent::new(session))),
-            theme: None,
+            theme: Some(Arc::new(default_resolved_theme())),
             katex_source: None,
             syntax_set: Arc::new(SyntaxSet::load_defaults_newlines()),
             index_file: None,
         }
     }
 
-    pub fn with_theme(mut self, theme: Theme<'static>) -> Self {
+    pub fn with_theme(mut self, theme: ResolvedTheme<'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, default_theme};
+use crate::theme::default_resolved_theme;
 use miette::IntoDiagnostic;
 use weaver_common::jacquard::client::AgentSession;
 
···
                 .into_diagnostic()?;
         }
         CssMode::Inline => {
-            let default_theme = default_theme();
+            let default_theme = default_resolved_theme();
             let theme = context.theme.as_deref().unwrap_or(&default_theme);
 
             writer.write_all(b"  <style>\n").await.into_diagnostic()?;

crates/weaver-renderer/src/theme.rs

···
+use miette::IntoDiagnostic;
+pub use weaver_api::sh_weaver::notebook::colour_scheme::{ColourScheme, ColourSchemeColours};
 pub use weaver_api::sh_weaver::notebook::theme::{
-    Theme, ThemeCodeTheme, ThemeColours, ThemeFonts, ThemeSpacing,
+    Theme, ThemeDarkCodeTheme, ThemeFonts, ThemeLightCodeTheme, ThemeSpacing,
 };
 use weaver_common::jacquard::CowStr;
+use weaver_common::jacquard::IntoStatic;
+use weaver_common::jacquard::client::AgentSession;
 use weaver_common::jacquard::cowstr::ToCowStr;
+use weaver_common::jacquard::prelude::*;
+
+/// A theme with resolved colour schemes (no strongRefs, actual data)
+#[derive(Clone, Debug)]
+pub struct ResolvedTheme<'a> {
+    pub dark_scheme: ColourSchemeColours<'a>,
+    pub light_scheme: ColourSchemeColours<'a>,
+    pub fonts: ThemeFonts<'a>,
+    pub spacing: ThemeSpacing<'a>,
+    pub dark_code_theme: ThemeDarkCodeTheme<'a>,
+    pub light_code_theme: ThemeLightCodeTheme<'a>,
+}
+
+pub fn default_colour_scheme_dark() -> ColourSchemeColours<'static> {
+    ColourSchemeColours {
+        base: CowStr::new_static("#191724"),
+        surface: CowStr::new_static("#1f1d2e"),
+        overlay: CowStr::new_static("#26233a"),
+        text: CowStr::new_static("#e0def4"),
+        muted: CowStr::new_static("#6e6a86"),
+        subtle: CowStr::new_static("#908caa"),
+        emphasis: CowStr::new_static("#e0def4"),
+        primary: CowStr::new_static("#c4a7e7"),
+        secondary: CowStr::new_static("#3e8fb0"),
+        tertiary: CowStr::new_static("#9ccfd8"),
+        error: CowStr::new_static("#eb6f92"),
+        warning: CowStr::new_static("#f6c177"),
+        success: CowStr::new_static("#31748f"),
+        border: CowStr::new_static("#403d52"),
+        link: CowStr::new_static("#ebbcba"),
+        highlight: CowStr::new_static("#524f67"),
+        ..Default::default()
+    }
+}
 
-pub fn default_theme() -> Theme<'static> {
-    Theme::new()
-        .code_theme(ThemeCodeTheme::CodeThemeName(Box::new(
-            "rose-pine".to_cowstr(),
-        )))
-        .colours(ThemeColours {
-            background: CowStr::new_static("#191724"),
-            foreground: CowStr::new_static("#e0def4"),
-            link: CowStr::new_static("#31748f"),
-            link_hover: CowStr::new_static("#9ccfd8"),
-            primary: CowStr::new_static("#c4a7e7"),
-            secondary: CowStr::new_static("#3e8fb0"),
+pub fn default_fonts() -> ThemeFonts<'static> {
+    ThemeFonts {
+        body: CowStr::new_static(
+            "IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+        ),
+        heading: CowStr::new_static(
+            "IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+        ),
+        monospace: CowStr::new_static(
+            "'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace",
+        ),
+        ..Default::default()
+    }
+}
+
+pub fn default_spacing() -> ThemeSpacing<'static> {
+    ThemeSpacing {
+        base_size: CowStr::new_static("16px"),
+        line_height: CowStr::new_static("1.6"),
+        scale: CowStr::new_static("1.25"),
+        ..Default::default()
+    }
+}
+
+pub fn default_colour_scheme_light() -> ColourSchemeColours<'static> {
+    ColourSchemeColours {
+        base: CowStr::new_static("#faf4ed"),
+        surface: CowStr::new_static("#fffaf3"),
+        overlay: CowStr::new_static("#f2e9e1"),
+        text: CowStr::new_static("#575279"),
+        muted: CowStr::new_static("#9893a5"),
+        subtle: CowStr::new_static("#797593"),
+        emphasis: CowStr::new_static("#575279"),
+        primary: CowStr::new_static("#907aa9"),
+        secondary: CowStr::new_static("#56949f"),
+        tertiary: CowStr::new_static("#286983"),
+        error: CowStr::new_static("#b4637a"),
+        warning: CowStr::new_static("#ea9d34"),
+        success: CowStr::new_static("#286983"),
+        border: CowStr::new_static("#dfdad9"),
+        link: CowStr::new_static("#d7827e"),
+        highlight: CowStr::new_static("#cecacd"),
+        ..Default::default()
+    }
+}
+
+pub fn default_resolved_theme() -> ResolvedTheme<'static> {
+    ResolvedTheme {
+        dark_scheme: default_colour_scheme_dark(),
+        light_scheme: default_colour_scheme_light(),
+        fonts: default_fonts(),
+        spacing: default_spacing(),
+        dark_code_theme: ThemeDarkCodeTheme::CodeThemeName(Box::new("rose-pine".to_cowstr())),
+        light_code_theme: ThemeLightCodeTheme::CodeThemeName(Box::new(
+            "rose-pine-dawn".to_cowstr(),
+        )),
+    }
+}
+
+/// Resolve a theme by fetching its colour scheme records from the PDS
+pub async fn resolve_theme<A: AgentSession + IdentityResolver>(
+    agent: &A,
+    theme: &Theme<'_>,
+) -> miette::Result<ResolvedTheme<'static>> {
+    use weaver_common::jacquard::client::AgentSessionExt;
+
+    // Fetch dark scheme
+    let dark_response = agent
+        .get_record::<ColourScheme>(&theme.dark_scheme.uri)
+        .await
+        .into_diagnostic()?;
+
+    let dark_scheme: ColourScheme = dark_response.into_output().into_diagnostic()?.into();
+
+    // Fetch light scheme
+    let light_response = agent
+        .get_record::<ColourScheme>(&theme.light_scheme.uri)
+        .await
+        .into_diagnostic()?;
+
+    let light_scheme: ColourScheme = light_response.into_output().into_diagnostic()?.into();
 
-            ..Default::default()
-        }).fonts(ThemeFonts {
-            body: CowStr::new_static(
-                "IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
-            ),
-            heading:CowStr::new_static(
-                "IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
-            ),
-            monospace: CowStr::new_static(
-                "'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace",
-            ),
-            ..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()
+    Ok(ResolvedTheme {
+        dark_scheme: dark_scheme.colours.into_static(),
+        light_scheme: light_scheme.colours.into_static(),
+        fonts: theme.fonts.clone().into_static(),
+        spacing: theme.spacing.clone().into_static(),
+        dark_code_theme: theme.dark_code_theme.clone().into_static(),
+        light_code_theme: theme.light_code_theme.clone().into_static(),
+    })
 }

crates/weaver-server/Cargo.toml

···
 weaver-renderer = { path = "../weaver-renderer" }
 mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d" }
 n0-future = { workspace = true }
-#dioxus-primitives = { git = "https://github.com/DioxusLabs/components", version = "0.0.1", default-features = false }
+dioxus-primitives = { git = "https://github.com/DioxusLabs/components", version = "0.0.1", default-features = false }
 axum = {version = "0.8.6", optional = true}
-
+mime-sniffer = {version = "^0.1"}
 chrono = { version = "0.4" }
+serde_json = "1.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 time = { version = "0.3", features = ["wasm-bindgen"] }

crates/weaver-server/assets/styling/blog.css

···
-#blog {
-  margin-top: 50px;
-}
-
-#blog a {
-  color: #ffffff;
-  margin-top: 50px;
-}

crates/weaver-server/assets/styling/echo.css

···
-#echo {
-  width: 360px;
-  margin-left: auto;
-  margin-right: auto;
-  margin-top: 50px;
-  background-color: #1e222d;
-  padding: 20px;
-  border-radius: 10px;
-}
-
-#echo>h4 {
-  margin: 0px 0px 15px 0px;
-}
-
-
-#echo>input {
-  border: none;
-  border-bottom: 1px white solid;
-  background-color: transparent;
-  color: #ffffff;
-  transition: border-bottom-color 0.2s ease;
-  outline: none;
-  display: block;
-  padding: 0px 0px 5px 0px;
-  width: 100%;
-}
-
-#echo>input:focus {
-  border-bottom-color: #6d85c6;
-}
-
-#echo>p {
-  margin: 20px 0px 0px auto;
-}

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

···
+/* Entry page layout with gutter navigation */
+.entry-page-layout {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) minmax(0, 90ch) minmax(0, 1fr);
+    gap: 0;
+    width: 100%;
+    min-height: 100vh;
+    background: var(--color-base);
+}
+
+/* Main content area */
+.entry-content-main {
+    grid-column: 2;
+    background: var(--color-base);
+}
+
+/* Navigation gutters */
+.nav-gutter {
+    position: sticky;
+    top: auto;
+    bottom: calc(2rem * var(--spacing-scale, 1.5));
+    height: fit-content;
+    align-self: end;
+}
+
+.nav-prev {
+    grid-column: 1;
+    padding-left: calc(1rem * var(--spacing-scale, 1.5));
+}
+
+.nav-next {
+    grid-column: 3;
+    padding-right: calc(1rem * var(--spacing-scale, 1.5));
+}
+
+/* Navigation buttons */
+.nav-button {
+    display: flex;
+    flex-direction: column;
+    gap: calc(0.5rem * var(--spacing-scale, 1.5));
+    padding: calc(1rem * var(--spacing-scale, 1.5));
+    background: var(--color-surface);
+    border: 2px solid var(--color-border);
+    border-radius: 4px;
+    text-decoration: none;
+    color: var(--color-text);
+    transition: all 0.2s ease;
+}
+
+.nav-button:hover {
+    background: var(--color-overlay);
+    border-color: var(--color-primary);
+    box-shadow: 0 2px 8px color-mix(in srgb, var(--color-primary) 20%, transparent);
+}
+
+.nav-button-prev {
+    align-items: flex-start;
+    text-align: left;
+}
+
+.nav-button-next {
+    align-items: flex-end;
+    text-align: right;
+}
+
+.nav-arrow {
+    font-size: 1.5rem;
+    font-weight: bold;
+    color: var(--color-primary);
+    transition: color 0.2s ease;
+}
+
+.nav-button:hover .nav-arrow {
+    color: var(--color-emphasis);
+}
+
+.nav-label {
+    font-size: 0.875rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--color-subtle);
+    transition: color 0.2s ease;
+}
+
+.nav-button:hover .nav-label {
+    color: var(--color-secondary);
+}
+
+.nav-title {
+    font-size: 0.95rem;
+    font-weight: 500;
+    max-width: 20ch;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+/* Entry metadata header */
+.entry-metadata {
+    margin-bottom: calc(2rem * var(--spacing-scale, 1.5));
+    padding-bottom: calc(1rem * var(--spacing-scale, 1.5));
+    border-bottom: 2px solid var(--color-border);
+}
+
+.entry-title {
+    margin-bottom: calc(1rem * var(--spacing-scale, 1.5));
+    margin-top: calc(1rem * var(--spacing-scale, 1.5));
+    color: var(--color-text);
+}
+
+.entry-meta-info {
+    display: flex;
+    flex-wrap: wrap;
+    gap: calc(1.5rem * var(--spacing-scale, 1.5));
+    font-size: 0.95rem;
+    color: var(--color-subtle);
+}
+
+.entry-authors,
+.entry-date,
+.entry-tags {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.entry-date {
+    margin-left: auto;
+    font-weight: 400;
+    color: var(--color-muted);
+}
+
+.meta-label {
+    font-weight: 400;
+    color: var(--color-muted);
+}
+
+.author-name {
+    color: var(--color-link);
+    font-weight: 450;
+    text-decoration: none;
+    transition: color 0.2s ease;
+}
+
+.author-name:hover {
+    color: var(--color-emphasis);
+    text-decoration: underline;
+}
+
+.entry-tags {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+.entry-tag {
+    padding: 0.25rem 0.75rem;
+    background: var(--color-surface);
+    border: 1px solid var(--color-border);
+    border-radius: 3px;
+    font-size: 0.85rem;
+    color: var(--color-subtle);
+    text-decoration: none;
+    transition: all 0.2s ease;
+}
+
+.entry-tag:hover {
+    background: var(--color-overlay);
+    border-color: var(--color-tertiary);
+    color: var(--color-text);
+}
+
+/* Content styling */
+.entry-content-main ::selection {
+    background: var(--color-highlight);
+    color: var(--color-text);
+}
+
+.entry-content-main code {
+    background: var(--color-surface);
+}
+
+.entry-content-main blockquote {
+    border-left-color: var(--color-secondary);
+    background: var(--color-surface);
+}
+
+.entry-content-main table th {
+    background: var(--color-surface);
+    border-color: var(--color-border);
+}
+
+.entry-content-main table td {
+    border-color: var(--color-border);
+}
+
+.entry-content-main table tr:hover {
+    background: var(--color-surface);
+}
+
+/* Responsive layout */
+@media (max-width: 1200px) {
+    .entry-page-layout {
+        grid-template-columns: 1fr;
+        gap: 0;
+    }
+
+    .entry-content-main {
+        grid-column: 1;
+        padding: 2rem 1rem;
+    }
+
+    .nav-gutter {
+        position: relative;
+        bottom: auto;
+        grid-column: 1;
+        padding: 0 1rem;
+    }
+
+    .nav-prev {
+        order: 2;
+        margin-top: 2rem;
+    }
+
+    .nav-next {
+        order: 3;
+        margin-top: 1rem;
+    }
+
+    .entry-content-main {
+        order: 1;
+    }
+}

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

···
 body {
-    background-color: #0f1116;
-    color: #ffffff;
-    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background-color: var(--color-base);
+    color: var(--color-text);
+    font-family: var(--font-body);
     margin: 20px;
 }
 
···
     width: 400px;
     text-align: left;
     font-size: x-large;
-    color: white;
+    color: var(--color-text);
     display: flex;
     flex-direction: column;
 }
 
 #links a {
-    color: white;
+    color: var(--color-link);
     text-decoration: none;
     margin-top: 20px;
     margin: 10px 0px;
-    border: white 1px solid;
+    border: 1px solid var(--color-border);
     border-radius: 5px;
     padding: 10px;
+    transition: all 0.2s ease;
 }
 
 #links a:hover {
-    background-color: #1f1f1f;
+    background-color: var(--color-surface);
+    border-color: var(--color-primary);
     cursor: pointer;
 }
 

crates/weaver-server/assets/styling/navbar.css

···
 }
 
 #navbar a {
-  color: #ffffff;
+  color: var(--color-text);
   margin-right: 20px;
   text-decoration: none;
   transition: color 0.2s ease;
···
 
 #navbar a:hover {
   cursor: pointer;
-  color: #91a4d2;
+  color: var(--color-primary);
 }

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

···
+/* Default theme variables for non-notebook pages */
+/* These match the Rose Pine light/dark defaults */
+
+/* CSS Variables - Light Mode (default) */
+:root {
+    --color-base: #faf4ed;
+    --color-surface: #fffaf3;
+    --color-overlay: #f2e9e1;
+    --color-text: #575279;
+    --color-muted: #9893a5;
+    --color-subtle: #797593;
+    --color-emphasis: #575279;
+    --color-primary: #907aa9;
+    --color-secondary: #56949f;
+    --color-tertiary: #286983;
+    --color-error: #b4637a;
+    --color-warning: #ea9d34;
+    --color-success: #286983;
+    --color-border: #dfdad9;
+    --color-link: #d7827e;
+    --color-highlight: #cecacd;
+
+    --font-body: IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    --font-heading: IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    --font-mono: 'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace;
+
+    --spacing-base: 16px;
+    --spacing-line-height: 1.6;
+    --spacing-scale: 1.25;
+}
+
+/* CSS Variables - Dark Mode */
+@media (prefers-color-scheme: dark) {
+    :root {
+        --color-base: #191724;
+        --color-surface: #1f1d2e;
+        --color-overlay: #26233a;
+        --color-text: #e0def4;
+        --color-muted: #6e6a86;
+        --color-subtle: #908caa;
+        --color-emphasis: #e0def4;
+        --color-primary: #c4a7e7;
+        --color-secondary: #3e8fb0;
+        --color-tertiary: #9ccfd8;
+        --color-error: #eb6f92;
+        --color-warning: #f6c177;
+        --color-success: #31748f;
+        --color-border: #403d52;
+        --color-link: #ebbcba;
+        --color-highlight: #524f67;
+    }
+}

crates/weaver-server/src/components/avatar/style.css

···
 
 .avatar-label {
     margin: 0;
-    color: var(--secondary-color-4);
+    color: var(--color-secondary);
     font-size: 0.875rem;
 }
 
···
     flex-shrink: 0;
     align-items: center;
     justify-content: center;
-    border-radius: 3.40282e+38px;
-    color: var(--secondary-color-4);
+    border-radius: 3.40282e38px;
+    color: var(--color-secondary);
     cursor: pointer;
     font-weight: 500;
 }
···
 }
 
 .avatar[data-state="empty"] {
-    background: var(--primary-color-2);
+    background: var(--color-surface);
 }
 
 @keyframes pulse {
···
     height: 100%;
     align-items: center;
     justify-content: center;
-    background: var(--primary-color);
-    color: var(--secondary-color-4);
+    background: var(--color-surface);
+    color: var(--color-primary);
     font-size: 1.5rem;
 }
 
 .avatar[data-state="error"] .avatar-fallback {
-    background: var(--primary-color-3);
-    color: var(--secondary-color-4);
+    background: var(--color-surface);
+    color: var(--color-subtle);
 }

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

···
 #[allow(unused_imports)]
 use std::sync::Arc;
 #[allow(unused_imports)]
-use weaver_renderer::theme::Theme;
+use weaver_renderer::theme::{Theme, ResolvedTheme};
 
 #[cfg(feature = "server")]
 use axum::{extract::Extension, response::IntoResponse};
···
 
     use weaver_api::sh_weaver::notebook::book::Book;
     use weaver_renderer::css::{generate_base_css, generate_syntax_css};
-    use weaver_renderer::theme::default_theme;
+    use weaver_renderer::theme::{default_resolved_theme, resolve_theme};
 
     let ident = AtIdentifier::new_owned(ident)?;
-    let theme = if let Some(notebook) = fetcher.get_notebook(ident, notebook).await? {
+    let resolved_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(default_theme())
+        if let Some(theme_ref) = book.theme {
+            if let Ok(theme_response) = fetcher.client.get_record::<Theme>(&theme_ref.uri).await {
+                if let Ok(theme_output) = theme_response.into_output() {
+                    let theme: Theme = theme_output.into();
+                    // Try to resolve the theme (fetch colour schemes from PDS)
+                    resolve_theme(fetcher.client.as_ref(), &theme)
+                        .await
+                        .unwrap_or_else(|_| default_resolved_theme())
+                } else {
+                    default_resolved_theme()
+                }
             } else {
-                default_theme()
+                default_resolved_theme()
             }
         } else {
-            default_theme()
+            default_resolved_theme()
         }
     } else {
-        default_theme()
+        default_resolved_theme()
     };
-    let mut css = generate_base_css(&theme);
+
+    let mut css = generate_base_css(&resolved_theme);
     css.push_str(
-        &generate_syntax_css(&theme)
+        &generate_syntax_css(&resolved_theme)
             .await
             .map_err(|e| CapturedError::from_display(e))
             .unwrap_or_default(),

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

···
 
 #[cfg(feature = "server")]
 use crate::blobcache::BlobCache;
-use crate::fetch;
+use crate::{
+    components::avatar::{Avatar, AvatarFallback, AvatarImage},
+    fetch,
+};
 use dioxus::prelude::*;
+
+const ENTRY_CSS: Asset = asset!("/assets/styling/entry.css");
 #[allow(unused_imports)]
 use dioxus::{fullstack::extract::Extension, CapturedError};
-use jacquard::{prelude::IdentityResolver, smol_str::ToSmolStr};
+use jacquard::{
+    from_data, prelude::IdentityResolver, smol_str::ToSmolStr, types::string::Datetime,
+};
 #[allow(unused_imports)]
 use jacquard::{
     smol_str::SmolStr,
···
 #[component]
 pub fn Entry(ident: AtIdentifier<'static>, book_title: SmolStr, title: SmolStr) -> Element {
     let ident_clone = ident.clone();
+    let book_title_clone = book_title.clone();
     let entry = use_resource(use_reactive!(|(ident, book_title, title)| async move {
         let fetcher = use_context::<fetch::CachedFetcher>();
         let entry = fetcher
···
 
     match &*entry.read_unchecked() {
         Some(Some(entry_data)) => {
-            rsx! { EntryMarkdownDirect {
-                content: entry_data.1.clone(),
-                ident: ident_clone
+            rsx! { EntryPage {
+                book_entry_view: entry_data.0.clone(),
+                entry_record: entry_data.1.clone(),
+                ident: ident_clone,
+                book_title: book_title_clone
             } }
         }
         Some(None) => {
···
     }
 }
 
+/// Full entry page with metadata, content, and navigation
+#[component]
+fn EntryPage(
+    book_entry_view: BookEntryView<'static>,
+    entry_record: entry::Entry<'static>,
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+) -> Element {
+    // Extract metadata
+    let entry_view = &book_entry_view.entry;
+    let title = entry_view
+        .title
+        .as_ref()
+        .map(|t| t.as_ref())
+        .unwrap_or("Untitled");
+
+    rsx! {
+        // Set page title
+        document::Title { "{title}" }
+        document::Link { rel: "stylesheet", href: ENTRY_CSS }
+
+        div { class: "entry-page-layout",
+            // Left gutter with prev button
+            if let Some(ref prev) = book_entry_view.prev {
+                div { class: "nav-gutter nav-prev",
+                    NavButton {
+                        direction: "prev",
+                        entry: prev.entry.clone(),
+                        ident: ident.clone(),
+                        book_title: book_title.clone()
+                    }
+                }
+            }
+
+            // Main content area
+            div { class: "entry-content-main",
+                // Metadata header
+                EntryMetadata {
+                    entry_view: entry_view.clone(),
+                    ident: ident.clone(),
+                    created_at: entry_record.created_at.clone()
+                }
+
+                // Rendered markdown
+                EntryMarkdownDirect {
+                    content: entry_record,
+                    ident: ident.clone()
+                }
+            }
+
+            // Right gutter with next button
+            if let Some(ref next) = book_entry_view.next {
+                div { class: "nav-gutter nav-next",
+                    NavButton {
+                        direction: "next",
+                        entry: next.entry.clone(),
+                        ident: ident.clone(),
+                        book_title: book_title.clone()
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[component]
 pub fn EntryCard(entry: BookEntryView<'static>) -> Element {
     rsx! {}
 }
 
+/// Metadata header showing title, authors, date, tags
+#[component]
+fn EntryMetadata(
+    entry_view: weaver_api::sh_weaver::notebook::EntryView<'static>,
+    ident: AtIdentifier<'static>,
+    created_at: Datetime,
+) -> Element {
+    use weaver_api::app_bsky::actor::profile::Profile;
+
+    let title = entry_view
+        .title
+        .as_ref()
+        .map(|t| t.as_ref())
+        .unwrap_or("Untitled");
+
+    let indexed_at_chrono = entry_view.indexed_at.as_ref();
+
+    rsx! {
+        header { class: "entry-metadata",
+            h1 { class: "entry-title", "{title}" }
+
+            div { class: "entry-meta-info",
+                // Authors
+                if !entry_view.authors.is_empty() {
+                    div { class: "entry-authors",
+                        for (i, author) in entry_view.authors.iter().enumerate() {
+                            if i > 0 { span { ", " } }
+                            {
+                                // Parse author profile from the nested value field
+                                match from_data::<Profile>(author.record.get_at_path(".value").unwrap()) {
+                                    Ok(profile) => {
+                                        let avatar = profile.avatar
+                                            .map(|avatar| {
+                                                let cid = avatar.blob().cid();
+                                                let did = entry_view.uri.authority();
+                                                format!("https://cdn.bsky.app/img/avatar/plain/{did}/{cid}@jpeg")
+                                            });
+                                        let display_name = profile.display_name
+                                            .as_ref()
+                                            .map(|n| n.as_ref())
+                                            .unwrap_or("Unknown");
+                                        rsx! {
+                                            if let Some(avatar) = avatar {
+                                                Avatar {
+                                                    AvatarImage {
+                                                        src: avatar
+                                                    }
+                                                }
+                                            }
+                                            span { class: "author-name", "{display_name}" }
+                                            span { class: "meta-label", "@{ident}" }
+                                        }
+                                    }
+                                    Err(_) => {
+                                        rsx! {
+                                            span { class: "author-name", "Author {author.index}" }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Date
+                div { class: "entry-date",
+                    {
+                        let formatted_date = created_at.as_ref().format("%B %d, %Y").to_string();
+
+                        rsx! {
+                            time { datetime: "{entry_view.indexed_at.as_str()}", "{formatted_date}" }
+
+                        }
+                    }
+                }
+
+                // Tags
+                if let Some(ref tags) = entry_view.tags {
+                    div { class: "entry-tags",
+                        // TODO: Parse tags structure
+                        span { class: "meta-label", "Tags: " }
+                        span { "[tags]" }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Navigation button for prev/next entries
+#[component]
+fn NavButton(
+    direction: &'static str,
+    entry: weaver_api::sh_weaver::notebook::EntryView<'static>,
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+) -> Element {
+    use crate::Route;
+
+    let entry_title = entry
+        .title
+        .as_ref()
+        .map(|t| t.as_ref())
+        .unwrap_or("Untitled");
+
+    let label = if direction == "prev" {
+        "← Previous"
+    } else {
+        "Next →"
+    };
+    let arrow = if direction == "prev" { "←" } else { "→" };
+
+    rsx! {
+        Link {
+            to: Route::Entry {
+                ident: ident.clone(),
+                book_title: book_title.clone(),
+                title: entry_title.to_string().into()
+            },
+            class: "nav-button nav-button-{direction}",
+            div { class: "nav-arrow", "{arrow}" }
+            div { class: "nav-label", "{label}" }
+            div { class: "nav-title", "{entry_title}" }
+        }
+    }
+}
+
 #[derive(Props, Clone, PartialEq)]
 pub struct EntryMarkdownProps {
     #[props(default)]
···
 
         // Render to HTML
         let mut html_buf = String::new();
-        let _ = ClientWriter::<_, ()>::new(&mut html_buf).run(events.into_iter());
+        let _ = ClientWriter::<_, _, ()>::new(events.into_iter(), &mut html_buf).run();
         Some(html_buf)
     }));
 

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

···
 
 mod identity;
 pub use identity::{Repository, RepositoryIndex};
-//pub mod avatar;
+pub mod avatar;

crates/weaver-server/src/main.rs

···
 // The dioxus prelude contains a ton of common items used in dioxus apps. It's a good idea to import wherever you
 // need dioxus
 use components::{Entry, Repository, RepositoryIndex};
-use dioxus::{fullstack::FullstackContext, prelude::*};
-use jacquard::{client::BasicClient, smol_str::SmolStr, types::string::AtIdentifier};
+#[allow(unused)]
+use dioxus::{
+    fullstack::{response::Extension, FullstackContext},
+    prelude::*,
+    CapturedError,
+};
+#[allow(unused)]
+use jacquard::{
+    client::BasicClient,
+    smol_str::SmolStr,
+    types::{cid::Cid, string::AtIdentifier},
+};
+
 use std::sync::Arc;
+#[allow(unused)]
 use views::{Home, Navbar, Notebook, NotebookIndex, NotebookPage};
 
 #[cfg(feature = "server")]
···
         }
     }
 }
+
+#[get("/{notebook}/image/{name}", blob_cache: Extension<Arc<crate::blobcache::BlobCache>>)]
+pub async fn image_named(
+    notebook: SmolStr,
+    name: SmolStr,
+) -> Result<dioxus_fullstack::response::Response> {
+    use axum::response::IntoResponse;
+    use mime_sniffer::MimeTypeSniffer;
+    if let Some(bytes) = blob_cache.get_named(&name) {
+        let blob = bytes.clone();
+        let mime = blob.sniff_mime_type().unwrap_or("application/octet-stream");
+        Ok((
+            [(dioxus_fullstack::http::header::CONTENT_TYPE, mime)],
+            bytes,
+        )
+            .into_response())
+    } else {
+        Err(CapturedError::from_display("no image"))
+    }
+}
+
+#[get("/{notebook}/blob/{cid}", blob_cache: Extension<Arc<crate::blobcache::BlobCache>>)]
+pub async fn blob(notebook: SmolStr, cid: SmolStr) -> Result<dioxus_fullstack::response::Response> {
+    use axum::response::IntoResponse;
+    use mime_sniffer::MimeTypeSniffer;
+    if let Some(bytes) = blob_cache.get_cid(&Cid::new_owned(cid.as_bytes())?) {
+        let blob = bytes.clone();
+        let mime = blob.sniff_mime_type().unwrap_or("application/octet-stream");
+        Ok((
+            [(dioxus_fullstack::http::header::CONTENT_TYPE, mime)],
+            bytes,
+        )
+            .into_response())
+    } else {
+        Err(CapturedError::from_display("no blob"))
+    }
+}

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

···
 use crate::Route;
 use dioxus::prelude::*;
 
+const THEME_DEFAULTS_CSS: Asset = asset!("/assets/styling/theme-defaults.css");
 const NAVBAR_CSS: Asset = asset!("/assets/styling/navbar.css");
 
 /// The Navbar component that will be rendered on all pages of our app since every page is under the layout.
···
 #[component]
 pub fn Navbar() -> Element {
     rsx! {
+        document::Link { rel: "stylesheet", href: THEME_DEFAULTS_CSS }
         document::Link { rel: "stylesheet", href: NAVBAR_CSS }
 
         div {

docs/plans/2025-11-03-theme-colour-scheme-redesign.md

···
+# Theme and Colour Scheme Redesign
+
+**Date:** 2025-11-03
+**Status:** Design approved, ready for implementation
+
+## Overview
+
+Redesign the theme lexicon to support expressive colour schemes comparable to base16 and Rose Pine, while maintaining flexibility for both preset themes and power user customization.
+
+## Requirements
+
+- Support 16+ semantic colour slots (comparable to base16 expressiveness)
+- Enable importing/adapting popular themes (base16, Rose Pine, etc.)
+- Separate light/dark modes as distinct themes (users can mix and match)
+- Semantic naming over positional identifiers (readable, consistent across themes)
+- Support preset picker UI + power user manual customization
+
+## Design
+
+### Two-Lexicon Structure
+
+Split colour schemes from themes to enable reusability and mixing:
+
+**1. `sh.weaver.notebook.colourScheme`** - Standalone colour palette record
+- Standalone AT Protocol record
+- Contains name, variant (dark/light), and 16 colour slots
+- Can be published and referenced by multiple themes
+- Enables sharing palettes between users
+
+**2. `sh.weaver.notebook.theme`** - Complete theme with colour references
+- References two colourScheme records (dark and light) via strongRefs
+- Contains fonts, spacing, codeTheme (unchanged from previous design)
+- Users can point to any published colour schemes, including others' palettes
+
+### 16 Semantic Colour Slots
+
+Organized into 5 semantic categories with consistent naming:
+
+**Backgrounds (3):**
+- `base` - Primary background for page/frame
+- `surface` - Secondary background for panels/cards
+- `overlay` - Tertiary background for popovers/dialogs
+
+**Text (1):**
+- `text` - Primary readable text colour (baseline)
+
+**Foreground variations (3):**
+- `muted` - De-emphasized text (disabled, metadata)
+- `subtle` - Medium emphasis text (comments, labels)
+- `emphasis` - Emphasized text (bold, important)
+
+**Accents (3):**
+- `primary` - Primary brand/accent colour
+- `secondary` - Secondary accent colour
+- `tertiary` - Tertiary accent colour
+
+**Status (3):**
+- `error` - Error state colour
+- `warning` - Warning state colour
+- `success` - Success state colour
+
+**Role (3):**
+- `border` - Border/divider colour
+- `link` - Hyperlink colour
+- `highlight` - Selection/highlight colour
+
+### Mapping to Existing Schemes
+
+**Base16 compatibility:**
+- Backgrounds map to base00-base02
+- Foregrounds map to base03-base07
+- Accents/status/roles map to base08-base0F
+
+**Rose Pine compatibility:**
+- Direct semantic mapping (base→base, surface→surface, overlay→overlay)
+- text/muted/subtle map to text/muted/subtle
+- Accent colours map to love/gold/rose/pine/foam/iris
+
+## Implementation Impact
+
+### Files to Create
+- `lexicons/notebook/colourScheme.json` ✓ (created)
+
+### Files to Modify
+- `lexicons/notebook/theme.json` ✓ (modified)
+- Run `./lexicon-codegen.sh` to regenerate Rust types
+- Update `crates/weaver-common/src/lexicons/mod.rs` (remove duplicate `mod sh;`)
+
+### Code Changes Needed
+- Update theme rendering code to use strongRef lookups
+- Update CSS generation to use new 16-slot colour names
+- Create default colour schemes (at least one dark, one light)
+- Update any existing theme records/configs to new format
+
+### Future Enhancements
+- Theme picker UI with preset browser
+- Colour scheme validation/linting
+- Auto-generate light from dark (and vice versa) where appropriate
+- Import converters for base16 YAML, Rose Pine JSON

lexicon-codegen.sh

···
-#!/usr/bin/env bash
-
-
-#cargo install esquema-cli --locked --git https://github.com/fatfingers23/esquema.git
-
-rm -rf ./target/lexicons
-mkdir -p ./target/lexicons
-cd target
-git clone -n --depth=1 --filter=tree:0 \
-https://github.com/bluesky-social/atproto.git
-cd atproto
-git sparse-checkout set --no-cone /lexicons
-git checkout
-cd ..
-
-cp -r ../lexicons ./
-cp -r ./atproto/lexicons ./
-
-
-~/.cargo/bin/esquema-cli generate local --lexdir ./lexicons/ --outdir ../crates/weaver-common/src/ --module lexicons

lexicons/notebook/colourScheme.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.colourScheme",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A colour palette for notebook theming",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["name", "variant", "colours"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Human-readable name for the colour scheme"
+          },
+          "variant": {
+            "type": "string",
+            "enum": ["dark", "light"],
+            "description": "Whether this is a dark or light colour scheme"
+          },
+          "colours": {
+            "type": "object",
+            "required": [
+              "base", "surface", "overlay",
+              "text", "muted", "subtle", "emphasis",
+              "primary", "secondary", "tertiary",
+              "error", "warning", "success",
+              "border", "link", "highlight"
+            ],
+            "properties": {
+              "base": {
+                "type": "string",
+                "description": "Primary background for page/frame"
+              },
+              "surface": {
+                "type": "string",
+                "description": "Secondary background for panels/cards"
+              },
+              "overlay": {
+                "type": "string",
+                "description": "Tertiary background for popovers/dialogs"
+              },
+              "text": {
+                "type": "string",
+                "description": "Primary readable text colour"
+              },
+              "muted": {
+                "type": "string",
+                "description": "De-emphasized text (disabled, metadata)"
+              },
+              "subtle": {
+                "type": "string",
+                "description": "Medium emphasis text (comments, labels)"
+              },
+              "emphasis": {
+                "type": "string",
+                "description": "Emphasized text (bold, important)"
+              },
+              "primary": {
+                "type": "string",
+                "description": "Primary brand/accent colour"
+              },
+              "secondary": {
+                "type": "string",
+                "description": "Secondary accent colour"
+              },
+              "tertiary": {
+                "type": "string",
+                "description": "Tertiary accent colour"
+              },
+              "error": {
+                "type": "string",
+                "description": "Error state colour"
+              },
+              "warning": {
+                "type": "string",
+                "description": "Warning state colour"
+              },
+              "success": {
+                "type": "string",
+                "description": "Success state colour"
+              },
+              "border": {
+                "type": "string",
+                "description": "Border/divider colour"
+              },
+              "link": {
+                "type": "string",
+                "description": "Hyperlink colour"
+              },
+              "highlight": {
+                "type": "string",
+                "description": "Selection/highlight colour"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/notebook/theme.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": ["colours", "fonts", "spacing", "codeTheme"],
+        "required": ["darkScheme", "lightScheme", "fonts", "spacing", "darkCodeTheme", "lightCodeTheme"],
         "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"
-              }
-            }
+          "darkScheme": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef",
+            "description": "Reference to a dark colour scheme"
+          },
+          "lightScheme": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef",
+            "description": "Reference to a light colour scheme"
           },
           "fonts": {
             "type": "object",
···
               }
             }
           },
-          "codeTheme": {
+          "darkCodeTheme": {
             "type": "union",
-            "refs": ["#codeThemeName", "#codeThemeFile"]
+            "refs": ["#codeThemeName", "#codeThemeFile"],
+            "description": "Syntax highlighting theme for dark mode"
+          },
+          "lightCodeTheme": {
+            "type": "union",
+            "refs": ["#codeThemeName", "#codeThemeFile"],
+            "description": "Syntax highlighting theme for light mode"
           }
         }
       }

weaver_notes/.obsidian/app.json

···
+{}

weaver_notes/.obsidian/appearance.json

···
+{}

weaver_notes/.obsidian/core-plugins.json

···
+{
+  "file-explorer": true,
+  "global-search": true,
+  "switcher": true,
+  "graph": true,
+  "backlink": true,
+  "canvas": true,
+  "outgoing-link": true,
+  "tag-pane": true,
+  "footnotes": false,
+  "properties": false,
+  "page-preview": true,
+  "daily-notes": true,
+  "templates": true,
+  "note-composer": true,
+  "command-palette": true,
+  "slash-command": false,
+  "editor-status": true,
+  "bookmarks": true,
+  "markdown-importer": false,
+  "zk-prefixer": false,
+  "random-note": false,
+  "outline": true,
+  "word-count": true,
+  "slides": false,
+  "audio-recorder": false,
+  "workspaces": false,
+  "file-recovery": true,
+  "publish": false,
+  "sync": true,
+  "bases": true,
+  "webviewer": false
+}

weaver_notes/.obsidian/workspace.json

···
+{
+  "main": {
+    "id": "9e811362058e2cfe",
+    "type": "split",
+    "children": [
+      {
+        "id": "38872499ca515395",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "f41bdf1f327c8668",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "Long-form writing.md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "Long-form writing"
+            }
+          }
+        ]
+      }
+    ],
+    "direction": "vertical"
+  },
+  "left": {
+    "id": "d19acb107ca6c5a8",
+    "type": "split",
+    "children": [
+      {
+        "id": "deab36e0c8ac1697",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "2f6bdb6d2dce13ed",
+            "type": "leaf",
+            "state": {
+              "type": "file-explorer",
+              "state": {
+                "sortOrder": "alphabetical",
+                "autoReveal": false
+              },
+              "icon": "lucide-folder-closed",
+              "title": "Files"
+            }
+          },
+          {
+            "id": "b2bacecc9ad2b76f",
+            "type": "leaf",
+            "state": {
+              "type": "search",
+              "state": {
+                "query": "",
+                "matchingCase": false,
+                "explainSearch": false,
+                "collapseAll": false,
+                "extraContext": false,
+                "sortOrder": "alphabetical"
+              },
+              "icon": "lucide-search",
+              "title": "Search"
+            }
+          },
+          {
+            "id": "bfa8d6752e6e8a65",
+            "type": "leaf",
+            "state": {
+              "type": "bookmarks",
+              "state": {},
+              "icon": "lucide-bookmark",
+              "title": "Bookmarks"
+            }
+          }
+        ]
+      }
+    ],
+    "direction": "horizontal",
+    "width": 300
+  },
+  "right": {
+    "id": "e2be0bd6d264a319",
+    "type": "split",
+    "children": [
+      {
+        "id": "9dbec3dc54c2e087",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "c090edea1d5304fa",
+            "type": "leaf",
+            "state": {
+              "type": "backlink",
+              "state": {
+                "file": "Long-form writing.md",
+                "collapseAll": false,
+                "extraContext": false,
+                "sortOrder": "alphabetical",
+                "showSearch": false,
+                "searchQuery": "",
+                "backlinkCollapsed": false,
+                "unlinkedCollapsed": true
+              },
+              "icon": "links-coming-in",
+              "title": "Backlinks for Long-form writing"
+            }
+          },
+          {
+            "id": "b6d0494de7d9f798",
+            "type": "leaf",
+            "state": {
+              "type": "outgoing-link",
+              "state": {
+                "file": "Long-form writing.md",
+                "linksCollapsed": false,
+                "unlinkedCollapsed": true
+              },
+              "icon": "links-going-out",
+              "title": "Outgoing links from Long-form writing"
+            }
+          },
+          {
+            "id": "634ad4a6ff1cb685",
+            "type": "leaf",
+            "state": {
+              "type": "tag",
+              "state": {
+                "sortOrder": "frequency",
+                "useHierarchy": true,
+                "showSearch": false,
+                "searchQuery": ""
+              },
+              "icon": "lucide-tags",
+              "title": "Tags"
+            }
+          },
+          {
+            "id": "16dc52d50e7d2218",
+            "type": "leaf",
+            "state": {
+              "type": "outline",
+              "state": {
+                "file": "Long-form writing.md",
+                "followCursor": false,
+                "showSearch": false,
+                "searchQuery": ""
+              },
+              "icon": "lucide-list",
+              "title": "Outline of Long-form writing"
+            }
+          }
+        ]
+      }
+    ],
+    "direction": "horizontal",
+    "width": 300,
+    "collapsed": true
+  },
+  "left-ribbon": {
+    "hiddenItems": {
+      "switcher:Open quick switcher": false,
+      "graph:Open graph view": false,
+      "canvas:Create new canvas": false,
+      "daily-notes:Open today's daily note": false,
+      "templates:Insert template": false,
+      "command-palette:Open command palette": false,
+      "bases:Create new base": false
+    }
+  },
+  "active": "f41bdf1f327c8668",
+  "lastOpenFiles": [
+    "Long-form writing.md"
+  ]
+}

weaver_notes/Long-form writing.md

···
+I grew up, like a lot of people on Bluesky, in the era of the internet where most of your online social interactions took place via text. I had a MySpace account, MSN messenger and Google Chat, I first got on Facebook back when they required a school email to sign up, I had a Tumblr, though not a LiveJournal. I was super into reddit for a long time. Big fan of Fanfiction.net and later Archive of Our Own.
+
+Social media in the conventional sense has been in a lot of ways a small part of the story of my time on the internet. Because while I wasn't huge into independent internet forums, the broader independent blogosphere of my teens and early adulthood shaped my worldview, and I was an avid reader and sometime participant there. I am an atheist in large part because of a blog called [Common Sense Atheism](http://commonsenseatheism.com) (which I started reading in part because the author, Luke Muehlhauser, was criticising both Richard Dawkins and some Christian apologetics I was familiar with). Luke's blog was part of cluster of blogs out of which grew the [rationalists](https://www.lesswrong.com/), one of, for better or for worse, the most influential intellectual movements of the 21st century, who are, via people like [Scott ](https://slatestarcodex.com/) [Alexander](https://www.astralcodexten.com/), both downstream and upstream of the tech billionaire ideology. I also read blogs like [boingboing.net](https://boingboing.net/), was a big fan of Cory Doctorow. I figured out I am trans in part because of [Thing of Things](https://thingofthings.wordpress.com/2017/05/05/the-cluster-structure-of-genderspace/), a blog by Ozy Frantz, a transmasc person in the broader rationalist and Effective Altruist blogosphere. One thing these all have in common is length. Part of the reason I only really got onto Twitter in 2020 or so was because the concept of microblogging, of having to fit your thoughts into such a small package, baffled me for ages. Amusingly I now think that being on Twitter and now Bluesky made me a better writer. [Restrictions breed creativity](https://articles.starcitygames.com/articles/restrictions-breed-creativity/), after all.
+
+But through all of this I was never really satisfied with the options that were out there for long-form writing. Wordpress, even their hosted version, required a lot of setup to really be functional, Tumblr's system for comment/replies was and remains insane, hosting my own seemed like too much money to burn on something nobody might even read at the time, and honestly I felt like I kinda missed the boat on discoverability, as the internet grew larger and more centralised, with platforms like Substack eating what was left of the blogosphere. But at the same time, its success proves that there is very much a desire for long-form writing, enough that people will pay for it, and that investors will back it. There are thoughts and forms of writing that you simply cannot fit into a post or even a thread of posts, and which don't make sense on a topic-based forum, or a place like Archive of our Own. Plus, I'm loathe to enable a centralised platform like Substack where the owners are unfortunately friendly to fascists.
+
+That's where the `at://` protocol and Weaver comes in.
+### The pitch
+Weaver is designed to be a highly flexible platform for medium and long-form writing on atproto. I was inspired by how weaver birds build their own homes, and by the notebooks, physical and virtual, that I create in the course of my work, to ideate, to document, and to inform. The initial proof-of-concept is essentially a static site generator, able to turn a Markdown text file or a folder of Markdown files, such as an Obsidian vault or git repository documentation, into a static "notebook" site. The file is uploaded to your PDS, where it can be accessed, either directly, via a minimal app server layer that provides a friendlier web address than an XRPC request or CDN link, or hosted on a platform of your choice, be that your own server or any other static site hosting service. The intermediate goal is an elegant and intuitive writing platform with collaborative editing and straightforward, immediate publishing via a web-app. The ultimate goal is to build a platform suitable for professional writers and journalists, an open alternative to platforms like Substack, with ways for readers to support writers, all on the AT protocol.
+
+### So what about...
+When I started working on Weaver back in the spring, the only real games in town for long-form blogging based on atproto, aside from rolling your own, [piss.beauty](https://piss.beauty) style, were [whtwnd.com](https://whtwnd.com/) and [leaflet.pub](https://leaflet.pub/home). Leaflet's good, and it's gotten a lot better in the last year, but it doesn't offer quite what I'm looking for either. For one, I am a Markdown fangirl, for better or for worse, and while Leaflet allows you to use Markdown for formatting, it doesn't speak it natively. There are [more alternatives now](https://connectedplaces.leaflet.pub/3m4qgpc7h3223), which makes sense as this space definitely feels like one that has gaps to fill. And the `at://` protocol, while it was developed in concert with a microblogging app, is actually pretty damn good for "macro"blogging, too. The interoperability the protocol allows is incredible. Weaver's app server can display Whitewind posts very easily. With some effort on my part, it can faithfully render Leaflet posts. It doesn't care what app your profile is on, it uses the [partial understanding](https://sdr-podcast.com/episodes/partial-understanding/) [capabilities](https://bsky.app/profile/nonbinary.computer/post/3m44ooo42xc2j) of the [jacquard](https://tangled.org/@nonbinary.computer/jacquard/) library I created to pull useful data out of it.