Lexicons and codegen, tiny testbed for oauth in cli crate

Cargo.lock

···
 
 [[package]]
 name = "n0-future"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "399e11dc3b0e8d9d65b27170d22f5d779d52d9bed888db70d7e0c2c7ce3dfc52"
+checksum = "7bb0e5d99e681ab3c938842b96fcb41bf8a7bb4bfdb11ccbd653a7e83e06c794"
 dependencies = [
  "cfg_aliases",
  "derive_more",
···
 ]
 
 [[package]]
+name = "serde_spanned"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "toml"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
+dependencies = [
+ "indexmap 2.9.0",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_write",
+ "winnow",
+]
+
+[[package]]
+name = "toml_write"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
+
+[[package]]
 name = "tower"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "clap",
  "esquema-codegen",
  "hickory-resolver",
+ "miette",
  "n0-future",
+ "serde_html_form",
+ "tokio",
  "weaver-common",
  "weaver-workspace-hack",
 ]
···
  "serde_json",
  "thiserror 2.0.12",
  "tokio",
+ "toml",
  "tracing",
  "weaver-workspace-hack",
 ]
···
 version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "winnow"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec"
+dependencies = [
+ "memchr",
+]
 
 [[package]]
 name = "winreg"

Cargo.toml

···
 thiserror = "2.0"
 syntect = "5.2.0"
 jane-eyre = "0.6.12"
-n0-future = "=0.1.2"
+n0-future = "=0.1.3"
 tracing = { version = "0.1.41", default-features = false, features = ["std"] }
 lexicon_cid = { package = "cid", version = "0.10.1", features = [
   "serde-codec",

crates/weaver-cli/Cargo.toml

···
 n0-future = { workspace = true }
 weaver-common = { path = "../weaver-common" }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
+miette = { workspace = true, features = ["fancy"] }
 
 hickory-resolver = "0.24.1"
 esquema-codegen.workspace = true
···
 atrium-oauth = "0.1.1"
 atrium-xrpc-client = "0.5.13"
 atrium-lex = { workspace = true }
+
+serde_html_form = "0.2.7"
+
+# temp for testing
+tokio = { version = "1.45.0", features = ["full"] }

crates/weaver-cli/src/main.rs

···
-//! A cli which will echo every input argument to stdout
+use atrium_api::agent::Agent;
+use atrium_api::xrpc::http::Uri;
+use atrium_oauth::AuthorizeOptions;
+use atrium_oauth::KnownScope;
+use atrium_oauth::Scope;
+use std::{
+    error,
+    io::{BufRead, Write, stdin, stdout},
+    sync::Arc,
+};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn error::Error>> {
+    let client = weaver_common::oauth::default_oauth_client("http://127.0.0.1/callback")?;
+    println!(
+        "Authorization url: {}",
+        client
+            .authorize(
+                std::env::var("PDS_URL").unwrap_or(String::from("https://atproto.systems")),
+                AuthorizeOptions {
+                    scopes: vec![
+                        Scope::Known(KnownScope::Atproto),
+                        Scope::Known(KnownScope::TransitionGeneric)
+                    ],
+                    ..Default::default()
+                }
+            )
+            .await?
+    );
+
+    print!("Redirected url: ");
+    stdout().lock().flush()?;
+    let mut url = String::new();
+    stdin().lock().read_line(&mut url)?;
 
-fn main() {}
+    let uri = url.trim().parse::<Uri>()?;
+    let params = serde_html_form::from_str(uri.query().unwrap())?;
+    let (session, _) = client.callback(params).await?;
+    let agent = Agent::new(session);
+    let output = agent
+        .api
+        .app
+        .bsky
+        .feed
+        .get_timeline(
+            atrium_api::app::bsky::feed::get_timeline::ParametersData {
+                algorithm: None,
+                cursor: None,
+                limit: 3.try_into().ok(),
+            }
+            .into(),
+        )
+        .await?;
+    for feed in &output.feed {
+        println!("{feed:?}");
+    }
+    Ok(())
+}

crates/weaver-common/Cargo.toml

···
 ] }
 
 
-miette = { workspace = true, features = ["fancy"] }
+miette = { workspace = true }
 owo-colors = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 hickory-resolver = "0.24.1"
+toml = "0.8.22"
 
 
 

crates/weaver-common/src/config.rs

···
+use atrium_api::agent::atp_agent::AtpSession;
+use miette::Result;
+use miette::miette;
+use serde::{Deserialize, Serialize};
+
+use std::future::Future;
+use std::path::Path;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Config {
+    /// The base URL for the XRPC endpoint.
+    pub endpoint: String,
+    /// The session data.
+    pub session: Option<AtpSession>,
+    /// The labelers header values.
+    pub labelers_header: Option<Vec<String>>,
+    /// The proxy header for service proxying.
+    pub proxy_header: Option<String>,
+}
+
+impl Config {
+    /// Loads the configuration from the provided loader.
+    pub async fn load(loader: &impl Loader) -> Result<Self> {
+        loader
+            .load()
+            .await
+            .map_err(|_| miette!("Failed to load configuration"))
+    }
+    /// Saves the configuration using the provided saver.
+    pub async fn save(&self, saver: &impl Saver) -> Result<()> {
+        saver
+            .save(self)
+            .await
+            .map_err(|_| miette!("Failed to save configuration"))
+    }
+}
+
+impl Default for Config {
+    /// Creates a new default configuration.
+    ///
+    /// The default configuration uses the base URL `https://bsky.social`.
+    fn default() -> Self {
+        Self {
+            endpoint: "https://atproto.systems".to_owned(),
+            session: None,
+            labelers_header: None,
+            proxy_header: None,
+        }
+    }
+}
+
+/// The trait for loading configuration data.
+pub trait Loader {
+    /// Loads the configuration data.
+    fn load(
+        &self,
+    ) -> impl Future<
+        Output = core::result::Result<Config, Box<dyn std::error::Error + Send + Sync + 'static>>,
+    > + Send;
+}
+
+/// The trait for saving configuration data.
+pub trait Saver {
+    /// Saves the configuration data.
+    fn save(
+        &self,
+        config: &Config,
+    ) -> impl Future<
+        Output = core::result::Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>,
+    > + Send;
+}
+
+/// An implementation of [`Loader`] and [`Saver`] that reads and writes a configuration file.
+pub struct FileStore {
+    path: PathBuf,
+}
+
+impl FileStore {
+    /// Create a new [`FileStore`] with the given path.
+    ///
+    /// This `FileStore` will read and write to the file at the given path.
+    /// [`Config`] data will be serialized and deserialized using the file extension.
+    /// By default, this supports only `.json` files.
+    pub fn new(path: impl AsRef<Path>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+        }
+    }
+}
+
+impl Loader for FileStore {
+    async fn load(
+        &self,
+    ) -> core::result::Result<Config, Box<dyn std::error::Error + Send + Sync + 'static>> {
+        match self.path.extension().and_then(|ext| ext.to_str()) {
+            Some("json") => Ok(serde_json::from_str(&std::fs::read_to_string(&self.path)?)?),
+            Some("toml") => Ok(toml::from_str(&std::fs::read_to_string(&self.path)?)?),
+            _ => Err(miette!("Unsupported file format").into()),
+        }
+    }
+}
+
+impl Saver for FileStore {
+    async fn save(
+        &self,
+        config: &Config,
+    ) -> core::result::Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        match self.path.extension().and_then(|ext| ext.to_str()) {
+            Some("json") => Ok(std::fs::write(
+                &self.path,
+                serde_json::to_string_pretty(config)?,
+            )?),
+            Some("toml") => Ok(std::fs::write(&self.path, toml::to_string_pretty(config)?)?),
+            _ => Err(miette!("Unsupported file format").into()),
+        }
+    }
+}

crates/weaver-common/src/lexicons/record.rs

···
     LexiconsShWeaverNotebookAuthors(
         Box<crate::lexicons::sh::weaver::notebook::authors::Record>,
     ),
+    #[serde(rename = "sh.weaver.notebook.book")]
+    LexiconsShWeaverNotebookBook(
+        Box<crate::lexicons::sh::weaver::notebook::book::Record>,
+    ),
     #[serde(rename = "sh.weaver.notebook.entry")]
     LexiconsShWeaverNotebookEntry(
         Box<crate::lexicons::sh::weaver::notebook::entry::Record>,
···
         record_data: crate::lexicons::sh::weaver::notebook::authors::RecordData,
     ) -> Self {
         KnownRecord::LexiconsShWeaverNotebookAuthors(Box::new(record_data.into()))
+    }
+}
+impl From<crate::lexicons::sh::weaver::notebook::book::Record> for KnownRecord {
+    fn from(record: crate::lexicons::sh::weaver::notebook::book::Record) -> Self {
+        KnownRecord::LexiconsShWeaverNotebookBook(Box::new(record))
+    }
+}
+impl From<crate::lexicons::sh::weaver::notebook::book::RecordData> for KnownRecord {
+    fn from(
+        record_data: crate::lexicons::sh::weaver::notebook::book::RecordData,
+    ) -> Self {
+        KnownRecord::LexiconsShWeaverNotebookBook(Box::new(record_data.into()))
     }
 }
 impl From<crate::lexicons::sh::weaver::notebook::entry::Record> for KnownRecord {

crates/weaver-common/src/lexicons/sh/weaver/actor/defs.rs

···
     pub indexed_at: core::option::Option<atrium_api::types::string::Datetime>,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub labels: core::option::Option<Vec<crate::com::atproto::label::defs::Label>>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub links: core::option::Option<Vec<String>>,
+    ///Free-form location text.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub location: core::option::Option<String>,
 }
 pub type ProfileView = atrium_api::types::Object<ProfileViewData>;

crates/weaver-common/src/lexicons/sh/weaver/notebook.rs

···
 // @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
 //!Definitions for the `sh.weaver.notebook` namespace.
 pub mod authors;
+pub mod book;
 pub mod defs;
 pub mod entry;
 #[derive(Debug)]
···
 impl atrium_api::types::Collection for Authors {
     const NSID: &'static str = "sh.weaver.notebook.authors";
     type Record = authors::Record;
+}
+#[derive(Debug)]
+pub struct Book;
+impl atrium_api::types::Collection for Book {
+    const NSID: &'static str = "sh.weaver.notebook.book";
+    type Record = book::Record;
 }
 #[derive(Debug)]
 pub struct Entry;

crates/weaver-common/src/lexicons/sh/weaver/notebook/authors.rs

···
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub index: core::option::Option<i64>,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
-    pub profile: core::option::Option<atrium_api::types::Union<AuthorListItemProfileRefs>>,
+    pub profile: core::option::Option<
+        atrium_api::types::Union<AuthorListItemProfileRefs>,
+    >,
 }
 pub type AuthorListItem = atrium_api::types::Object<AuthorListItemData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(tag = "$type")]
 pub enum AuthorListItemProfileRefs {
     #[serde(rename = "app.bsky.actor.defs#profileViewBasic")]
-    AppBskyActorDefsProfileViewBasic(Box<crate::app::bsky::actor::defs::ProfileViewBasic>),
-    #[serde(rename = "sh.weaver.actor.profile")]
-    ShWeaverActorProfileMain(Box<crate::sh::weaver::actor::profile::Record>),
+    AppBskyActorDefsProfileViewBasic(
+        Box<crate::app::bsky::actor::defs::ProfileViewBasic>,
+    ),
+    #[serde(rename = "sh.weaver.actor.defs#profileView")]
+    ShWeaverActorDefsProfileView(Box<crate::sh::weaver::actor::defs::ProfileView>),
 }

crates/weaver-common/src/lexicons/sh/weaver/notebook/book.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.notebook.book` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    pub authors: crate::sh::weaver::notebook::defs::AuthorListView,
+    pub cid: atrium_api::types::string::Cid,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub created_at: core::option::Option<atrium_api::types::string::Datetime>,
+    pub entry_list: Vec<crate::sh::weaver::notebook::defs::BookEntryView>,
+    pub uri: String,
+}
+pub type Record = atrium_api::types::Object<RecordData>;
+impl From<atrium_api::types::Unknown> for RecordData {
+    fn from(value: atrium_api::types::Unknown) -> Self {
+        Self::try_from_unknown(value).unwrap()
+    }
+}

crates/weaver-common/src/lexicons/sh/weaver/notebook/defs.rs

···
 //!Definitions for the `sh.weaver.notebook.defs` namespace.
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
+pub struct AuthorListViewData {
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub cid: core::option::Option<atrium_api::types::string::Cid>,
+    pub index: i64,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub record: core::option::Option<atrium_api::types::Unknown>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub uri: core::option::Option<String>,
+}
+pub type AuthorListView = atrium_api::types::Object<AuthorListViewData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct BookEntryRefData {
+    pub entry: EntryView,
+}
+pub type BookEntryRef = atrium_api::types::Object<BookEntryRefData>;
+///An ordered entry in a Weaver notebook.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct BookEntryViewData {
+    pub entry: EntryView,
+    pub index: i64,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub next: core::option::Option<BookEntryRef>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub prev: core::option::Option<BookEntryRef>,
+}
+pub type BookEntryView = atrium_api::types::Object<BookEntryViewData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
 pub struct EntryViewData {
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub authors: core::option::Option<AuthorListView>,
     pub cid: atrium_api::types::string::Cid,
+    pub indexed_at: atrium_api::types::string::Datetime,
+    pub record: atrium_api::types::Unknown,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub rendered_view: core::option::Option<RenderedView>,
     pub uri: String,
 }
 pub type EntryView = atrium_api::types::Object<EntryViewData>;

crates/weaver-common/src/lib.rs

···
+pub mod client;
+pub mod config;
 pub mod error;
 pub mod lexicons;
 pub mod oauth;
+pub mod resolver;
 pub use lexicons::*;
 
-use atrium_identity::handle::DnsTxtResolver;
-
 pub use crate::error::{Error, IoError, ParseError, SerDeError};
 
 /// Canonical Cow for us, thanks Amos
 pub use merde::CowStr;
-
-use hickory_resolver::TokioAsyncResolver;
 
 /// too many cows, so we have conversions
 pub fn mcow_to_cow(cow: CowStr<'_>) -> std::borrow::Cow<'_, str> {
···
         markdown_weaver::CowStr::Inlined(s) => std::borrow::Cow::Owned(s.as_ref().to_owned()),
     }
 }
-
-pub struct HickoryDnsTxtResolver {
-    resolver: TokioAsyncResolver,
-}
-
-impl Default for HickoryDnsTxtResolver {
-    fn default() -> Self {
-        Self {
-            resolver: TokioAsyncResolver::tokio_from_system_conf()
-                .expect("failed to create resolver"),
-        }
-    }
-}
-
-impl DnsTxtResolver for HickoryDnsTxtResolver {
-    async fn resolve(
-        &self,
-        query: &str,
-    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync + 'static>> {
-        Ok(self
-            .resolver
-            .txt_lookup(query)
-            .await?
-            .iter()
-            .map(|txt| txt.to_string())
-            .collect())
-    }
-}

crates/weaver-common/src/oauth.rs

···
 
 use std::sync::Arc;
 
-use crate::HickoryDnsTxtResolver;
+use crate::resolver::HickoryDnsTxtResolver;
 
 pub fn default_oauth_client(
     url: impl AsRef<str>,

crates/weaver-common/src/resolver.rs

···
+use atrium_identity::handle::DnsTxtResolver;
+use hickory_resolver::TokioAsyncResolver;
+
+pub struct HickoryDnsTxtResolver {
+    resolver: TokioAsyncResolver,
+}
+
+impl Default for HickoryDnsTxtResolver {
+    fn default() -> Self {
+        Self {
+            resolver: TokioAsyncResolver::tokio_from_system_conf()
+                .expect("failed to create resolver"),
+        }
+    }
+}
+
+impl DnsTxtResolver for HickoryDnsTxtResolver {
+    async fn resolve(
+        &self,
+        query: &str,
+    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+        Ok(self
+            .resolver
+            .txt_lookup(query)
+            .await?
+            .iter()
+            .map(|txt| txt.to_string())
+            .collect())
+    }
+}

docs/oauth/client-metadata.json

···
+{
+  "client_id": "https://appview.weaver.sh/oauth/client-metadata.json",
+  "application_type": "native",
+  "client_name": "Weaver Appview",
+  "client_uri": "https://appview.weaver.sh",
+  "dpop_bound_access_tokens": true,
+  "grant_types": ["authorization_code", "refresh_token"],
+  "redirect_uris": ["http://127.0.0.1:8080/oauth/callback"],
+  "response_types": ["code"],
+  "scope": "atproto transition:generic",
+  "token_endpoint_auth_method": "none"
+}

flake.nix

···
         weaver-server = flake-utils.lib.mkApp {
           drv = weaver-server;
         };
+
       };
 
       devShells.default = craneLib.devShell {

lexicon-codegen.sh

···
 
 
 #cargo install esquema-cli --locked --git https://github.com/fatfingers23/esquema.git
+rm -rf ./target/lexicons
 mkdir -p ./target/lexicons
+
 cp -r ./lexicons ./target/lexicons
 cp -r ./atproto/lexicons ./target/lexicons
 

lexicons/sh.weaver/actor/defs.json lexicons/sh/weaver/actor/defs.json

···
           "maxLength": 2560
         },
         "avatar": { "type": "string", "format": "uri" },
-
+        "location": {
+          "type": "string",
+          "description": "Free-form location text.",
+          "maxGraphemes": 40,
+          "maxLength": 400
+        },
+        "links": {
+          "type": "array",
+          "minLength": 0,
+          "maxLength": 5,
+          "items": {
+            "type": "string",
+            "description": "Any URI, intended for social profiles or websites, can be used to link DIDs/AT-URIs too.",
+            "format": "uri"
+          }
+        },
         "indexedAt": { "type": "string", "format": "datetime" },
         "createdAt": { "type": "string", "format": "datetime" },
 

lexicons/sh.weaver/notebook/authors.json lexicons/sh/weaver/notebook/authors.json

···
       "properties": {
         "profile": {
           "type": "union",
-          "refs": ["app.bsky.actor.defs#profileViewBasic", "sh.weaver.actor.profile", "sh.weaver.actor.profile"]
+          "refs": ["app.bsky.actor.defs#profileViewBasic", "sh.weaver.actor.defs#profileView"]
         },
         "index": { "type": "integer" }
       }

lexicons/sh.weaver/notebook/defs.json

···
-{
-  "lexicon": 1,
-  "id": "sh.weaver.notebook.defs",
-  "defs": {
-    "entryView": {
-      "type": "object",
-      "required": ["uri", "cid", "author", "record", "indexedAt"],
-      "authors": {
-        "type": "array",
-        "items": {
-          "type": "union",
-          "refs": ["app.bsky.actor.defs#profileViewBasic"]
-        }
-      },
-      "properties": {
-        "uri": { "type": "string", "format": "at-uri" },
-        "cid": { "type": "string", "format": "cid" }
-      },
-
-      "record": { "type": "unknown" },
-      "renderedView": {
-        "type": "ref",
-        "ref": "#renderedView"
-      },
-      "indexedAt": { "type": "string", "format": "datetime" }
-    },
-
-    "renderedView": {
-      "type": "object",
-      "required": ["html"],
-      "properties": {
-        "html": {
-          "type": "blob",
-          "accept": ["text/html"],
-          "maxSize": 1000000
-        },
-        "css": {
-          "type": "blob",
-          "accept": ["text/css"],
-          "maxSize": 1000000
-        }
-      },
-      "description": "View of a rendered and cached notebook entry"
-    }
-  }
-}

lexicons/sh/weaver/notebook/book.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.book",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "Authors of a Weaver notebook.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["cid", "uri", "authors", "entryList"],
+        "properties": {
+          "uri": { "type": "string", "format": "at-uri" },
+          "cid": { "type": "string", "format": "cid" },
+          "authors": {
+            "type": "ref",
+            "ref": "sh.weaver.notebook.defs#authorListView"
+          },
+          "entryList": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "sh.weaver.notebook.defs#bookEntryView"
+            }
+          },
+          "createdAt": { "type": "string", "format": "datetime" }
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/notebook/defs.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.defs",
+  "defs": {
+    "entryView": {
+      "type": "object",
+      "required": ["uri", "cid", "author", "record", "indexedAt"],
+
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" },
+        "authors": {
+          "type": "ref",
+          "ref": "#authorListView"
+        },
+        "record": { "type": "unknown" },
+        "renderedView": {
+          "type": "ref",
+          "ref": "#renderedView"
+        },
+        "indexedAt": { "type": "string", "format": "datetime" }
+      }
+    },
+
+    "renderedView": {
+      "type": "object",
+      "required": ["html"],
+      "properties": {
+        "html": {
+          "type": "blob",
+          "accept": ["text/html"],
+          "maxSize": 1000000
+        },
+        "css": {
+          "type": "blob",
+          "accept": ["text/css"],
+          "maxSize": 1000000
+        }
+      },
+      "description": "View of a rendered and cached notebook entry"
+    },
+    "authorListView": {
+      "type": "object",
+      "required": ["profile", "index"],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" },
+        "record": { "type": "unknown" },
+        "index": { "type": "integer" }
+      }
+    },
+
+    "bookEntryView": {
+      "type": "object",
+      "description": "An ordered entry in a Weaver notebook.",
+      "required": ["entry", "index"],
+      "properties": {
+        "entry": {
+          "type": "ref",
+          "ref": "#entryView"
+        },
+        "index": { "type": "integer" },
+        "next": {
+          "type": "ref",
+          "ref": "#bookEntryRef"
+        },
+        "prev": {
+          "type": "ref",
+          "ref": "#bookEntryRef"
+        }
+      }
+    },
+    "bookEntryRef": {
+      "type": "object",
+      "required": ["entry"],
+      "properties": {
+        "entry": {
+          "type": "ref",
+          "ref": "#entryView"
+        }
+      }
+    }
+  }
+}