moved stuff around, new lexicons

Cargo.lock

···
 ]
 
 [[package]]
-name = "weaver-appview"
+name = "weaver-app"
+version = "0.1.0"
+dependencies = [
+ "axum",
+ "chrono",
+ "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",
+ "weaver-renderer",
+]
+
+[[package]]
+name = "weaver-app-server"
 version = "0.1.0"
 dependencies = [
  "axum",
···
 dependencies = [
  "http",
  "jacquard",
+ "jacquard-common",
  "markdown-weaver",
  "markdown-weaver-escape",
  "miette 7.6.0",
···
  "weaver-api",
  "weaver-common",
  "yaml-rust2",
-]
-
-[[package]]
-name = "weaver-server"
-version = "0.1.0"
-dependencies = [
- "axum",
- "chrono",
- "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",
- "weaver-renderer",
 ]
 
 [[package]]

Cargo.toml

···
 # paths because the flake.nix is written in a way such that top-level members
 # (`weaver-cli` and `weaver-server`) are built as different derivations which avoid being
 # rebuilt if the other package's sources change.
-members = ["crates/*", "crates/weaver-server", "crates/weaver-server"]
+members = ["crates/*"]
 
 #default-members = ["crates/weaver-cli"]
 
···
 
 jacquard = { git = "https://tangled.org/@nonbinary.computer/jacquard", default-features = false, features = ["derive", "api_bluesky"] }
 jacquard-api = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
+jacquard-common = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
 jacquard-axum = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
 
 [profile]

crates/weaver-api/lexicons/app_bsky_actor_defs.json

···
     "threadViewPref": {
       "type": "object",
       "properties": {
-        "prioritizeFollowedUsers": {
-          "type": "boolean",
-          "description": "Show followed users at the top of all replies."
-        },
         "sort": {
           "type": "string",
           "description": "Sorting mode for threads.",

crates/weaver-api/lexicons/app_bsky_unspecced_getPostThreadOtherV2.json

···
             "type": "string",
             "description": "Reference (AT-URI) to post record. This is the anchor post.",
             "format": "at-uri"
-          },
-          "prioritizeFollowedUsers": {
-            "type": "boolean",
-            "description": "Whether to prioritize posts from followed users. It only has effect when the user is authenticated.",
-            "default": false
           }
         }
       },

crates/weaver-api/lexicons/app_bsky_unspecced_getPostThreadV2.json

···
             "minimum": 0,
             "maximum": 100
           },
-          "prioritizeFollowedUsers": {
-            "type": "boolean",
-            "description": "Whether to prioritize posts from followed users. It only has effect when the user is authenticated.",
-            "default": false
-          },
           "sort": {
             "type": "string",
             "description": "Sorting for the thread replies.",

crates/weaver-api/lexicons/sh_weaver_notebook_book.json

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

crates/weaver-api/lexicons/sh_weaver_notebook_defs.json

···
         }
       }
     },
+    "path": {
+      "type": "string",
+      "description": "The path of the notebook.",
+      "maxLength": 100
+    },
     "renderedView": {
       "type": "object",
       "description": "View of a rendered and cached notebook entry",

crates/weaver-api/src/app_bsky/actor.rs

···
                         #[allow(unused_mut)]
                         let mut map = ::std::collections::BTreeMap::new();
                         map.insert(
-                            ::jacquard_common::smol_str::SmolStr::new_static(
-                                "prioritizeFollowedUsers",
-                            ),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
-                                description: None,
-                                default: None,
-                                r#const: None,
-                            }),
-                        );
-                        map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static("sort"),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
                                 description: Some(
···
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ThreadViewPref<'a> {
-    /// Show followed users at the top of all replies.
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub prioritize_followed_users: std::option::Option<bool>,
     /// Sorting mode for threads.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]

crates/weaver-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs

···
 pub struct GetPostThreadOtherV2<'a> {
     #[serde(borrow)]
     pub anchor: jacquard_common::types::string::AtUri<'a>,
-    /// (default: false)
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub prioritize_followed_users: std::option::Option<bool>,
 }
 
 pub mod get_post_thread_other_v2_state {
···
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
         ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
-        ::core::option::Option<bool>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
 }
···
     pub fn new() -> Self {
         GetPostThreadOtherV2Builder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None),
+            __unsafe_private_named: (None,),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
     }
 }
 
-impl<'a, S: get_post_thread_other_v2_state::State> GetPostThreadOtherV2Builder<'a, S> {
-    /// Set the `prioritizeFollowedUsers` field (optional)
-    pub fn prioritize_followed_users(mut self, value: impl Into<Option<bool>>) -> Self {
-        self.__unsafe_private_named.1 = value.into();
-        self
-    }
-    /// Set the `prioritizeFollowedUsers` field to an Option value (optional)
-    pub fn maybe_prioritize_followed_users(mut self, value: Option<bool>) -> Self {
-        self.__unsafe_private_named.1 = value;
-        self
-    }
-}
-
 impl<'a, S> GetPostThreadOtherV2Builder<'a, S>
 where
     S: get_post_thread_other_v2_state::State,
···
     pub fn build(self) -> GetPostThreadOtherV2<'a> {
         GetPostThreadOtherV2 {
             anchor: self.__unsafe_private_named.0.unwrap(),
-            prioritize_followed_users: self.__unsafe_private_named.1,
         }
     }
 }
···
                                         r#enum: None,
                                         r#const: None,
                                         known_values: None,
-                                    }),
-                                );
-                                map.insert(
-                                    ::jacquard_common::smol_str::SmolStr::new_static(
-                                        "prioritizeFollowedUsers",
-                                    ),
-                                    ::jacquard_lexicon::lexicon::LexXrpcParametersProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
-                                        description: None,
-                                        default: None,
-                                        r#const: None,
                                     }),
                                 );
                                 map

crates/weaver-api/src/app_bsky/unspecced/get_post_thread_v2.rs

···
     ///(default: 10, min: 0, max: 100)
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub branching_factor: std::option::Option<i64>,
-    /// (default: false)
-    #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub prioritize_followed_users: std::option::Option<bool>,
     ///(default: "oldest")
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
···
         ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
         ::core::option::Option<i64>,
         ::core::option::Option<i64>,
-        ::core::option::Option<bool>,
         ::core::option::Option<jacquard_common::CowStr<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
···
     pub fn new() -> Self {
         GetPostThreadV2Builder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None, None, None),
+            __unsafe_private_named: (None, None, None, None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
 }
 
 impl<'a, S: get_post_thread_v2_state::State> GetPostThreadV2Builder<'a, S> {
-    /// Set the `prioritizeFollowedUsers` field (optional)
-    pub fn prioritize_followed_users(mut self, value: impl Into<Option<bool>>) -> Self {
-        self.__unsafe_private_named.4 = value.into();
-        self
-    }
-    /// Set the `prioritizeFollowedUsers` field to an Option value (optional)
-    pub fn maybe_prioritize_followed_users(mut self, value: Option<bool>) -> Self {
-        self.__unsafe_private_named.4 = value;
-        self
-    }
-}
-
-impl<'a, S: get_post_thread_v2_state::State> GetPostThreadV2Builder<'a, S> {
     /// Set the `sort` field (optional)
     pub fn sort(
         mut self,
         value: impl Into<Option<jacquard_common::CowStr<'a>>>,
     ) -> Self {
-        self.__unsafe_private_named.5 = value.into();
+        self.__unsafe_private_named.4 = value.into();
         self
     }
     /// Set the `sort` field to an Option value (optional)
     pub fn maybe_sort(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
-        self.__unsafe_private_named.5 = value;
+        self.__unsafe_private_named.4 = value;
         self
     }
 }
···
             anchor: self.__unsafe_private_named.1.unwrap(),
             below: self.__unsafe_private_named.2,
             branching_factor: self.__unsafe_private_named.3,
-            prioritize_followed_users: self.__unsafe_private_named.4,
-            sort: self.__unsafe_private_named.5,
+            sort: self.__unsafe_private_named.4,
         }
     }
 }
···
                                         minimum: None,
                                         maximum: None,
                                         r#enum: None,
-                                        r#const: None,
-                                    }),
-                                );
-                                map.insert(
-                                    ::jacquard_common::smol_str::SmolStr::new_static(
-                                        "prioritizeFollowedUsers",
-                                    ),
-                                    ::jacquard_lexicon::lexicon::LexXrpcParametersProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
-                                        description: None,
-                                        default: None,
                                         r#const: None,
                                     }),
                                 );

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

···
                 }),
             );
             map.insert(
+                ::jacquard_common::smol_str::SmolStr::new_static("path"),
+                ::jacquard_lexicon::lexicon::LexUserType::String(::jacquard_lexicon::lexicon::LexString {
+                    description: Some(
+                        ::jacquard_common::CowStr::new_static(
+                            "The path of the notebook.",
+                        ),
+                    ),
+                    format: None,
+                    default: None,
+                    min_length: None,
+                    max_length: Some(100usize),
+                    min_graphemes: None,
+                    max_graphemes: None,
+                    r#enum: None,
+                    r#const: None,
+                    known_values: None,
+                }),
+            );
+            map.insert(
                 ::jacquard_common::smol_str::SmolStr::new_static("renderedView"),
                 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
                     description: Some(
···
     }
 }
 
+/// The path of the notebook.
+pub type Path<'a> = jacquard_common::CowStr<'a>;
 /// View of a rendered and cached notebook entry
 #[jacquard_derive::lexicon]
 #[derive(

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

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

crates/weaver-appview/Cargo.toml crates/weaver-app-server/Cargo.toml

···
 [package]
-name = "weaver-appview"
+name = "weaver-app-server"
 version.workspace = true
 edition.workspace = true
 license.workspace = true

crates/weaver-common/Cargo.toml

···
 http = "1.3.1"
 
 jacquard = { workspace = true }
+jacquard-common = { workspace = true }
 trait-variant = "0.1"
 
 serde = { workspace = true }

crates/weaver-common/src/constellation.rs

···
+use jacquard::{
+    CowStr, IntoStatic, XrpcRequest,
+    types::{
+        did::Did,
+        nsid::Nsid,
+        string::{RecordKey, Rkey},
+    },
+};
+use serde::{Deserialize, Serialize};
+
+const DEFAULT_CURSOR_LIMIT: u64 = 16;
+const DEFAULT_CURSOR_LIMIT_MAX: u64 = 100;
+
+fn get_default_cursor_limit() -> u64 {
+    DEFAULT_CURSOR_LIMIT
+}
+
+#[derive(Clone, Deserialize, Serialize, XrpcRequest, IntoStatic)]
+#[xrpc(
+    nsid = "blue.microcosm.links.getBacklinks",
+    method = Query,
+    output = GetBacklinksResponse,
+)]
+pub struct GetBacklinksQuery<'a> {
+    /// The link target
+    ///
+    /// can be an AT-URI, plain DID, or regular URI
+    subject: jacquard::types::uri::Uri<'a>,
+    /// Filter links only from this link source
+    ///
+    /// eg.: `app.bsky.feed.like:subject.uri`
+    source: CowStr<'a>,
+    #[serde(borrow)]
+    cursor: Option<CowStr<'a>>,
+    /// Filter links only from these DIDs
+    ///
+    /// include multiple times to filter by multiple source DIDs
+    #[serde(default)]
+    did: Vec<Did<'a>>,
+    /// Set the max number of links to return per page of results
+    #[serde(default = "get_default_cursor_limit")]
+    limit: u64,
+    // TODO: allow reverse (er, forward) order as well
+}
+#[derive(Deserialize, Serialize, IntoStatic)]
+pub struct GetBacklinksResponse<'a> {
+    total: u64,
+    #[serde(borrow)]
+    records: Vec<RecordId<'a>>,
+    cursor: Option<CowStr<'a>>,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize, IntoStatic)]
+pub struct RecordId<'a> {
+    #[serde(borrow)]
+    pub did: Did<'a>,
+    pub collection: Nsid<'a>,
+    pub rkey: RecordKey<Rkey<'a>>,
+}
+
+impl RecordId<'_> {
+    pub fn did(&self) -> Did<'_> {
+        self.did.clone()
+    }
+    pub fn collection(&self) -> Nsid<'_> {
+        self.collection.clone()
+    }
+    pub fn rkey(&self) -> RecordKey<Rkey<'_>> {
+        self.rkey.clone()
+    }
+}

crates/weaver-common/src/lib.rs

···
 //! Weaver common library - thin wrapper around jacquard with notebook-specific conveniences
 
+pub mod constellation;
 pub mod error;
 pub mod view;
 

crates/weaver-server/Cargo.toml crates/weaver-app/Cargo.toml

···
 [package]
-name = "weaver-server"
+name = "weaver-app"
 version = "0.1.0"
 authors = ["Orual <[e-mail]>"]
 edition = "2021"

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

···
 #[allow(unused_imports)]
 use std::sync::Arc;
 #[allow(unused_imports)]
-use weaver_renderer::theme::{Theme, ResolvedTheme};
+use weaver_renderer::theme::{ResolvedTheme, Theme};
 
 #[cfg(feature = "server")]
 use axum::{extract::Extension, response::IntoResponse};
···
 pub fn NotebookCss(ident: SmolStr, notebook: SmolStr) -> Element {
     rsx! {
         document::Stylesheet {
-            href: "{get_server_url()}/css/{ident}/{notebook}"
+            href: "{get_server_url()}/{ident}/{notebook}/css"
         }
     }
 }
 
-#[get("/css/{ident}/{notebook}", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
+#[get("/{ident}/{notebook}/css", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
 pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<Response> {
     use jacquard::client::AgentSessionExt;
     use jacquard::types::ident::AtIdentifier;

flake.nix

···
           cargoExtraArgs = "-p ${name}-cli";
           src = fileSetForCrate ./crates/weaver-cli;
         });
-      weaver-server = craneLib.buildPackage (individualCrateArgs
+      weaver-app = craneLib.buildPackage (individualCrateArgs
         // {
-          pname = "${name}-server";
-          cargoExtraArgs = "-p ${name}-server";
+          pname = "${name}-app";
+          cargoExtraArgs = "-p ${name}-app";
           src = fileSetForCrate ./crates/weaver-server;
         });
       weaver-renderer = craneLib.buildPackage (individualCrateArgs
···
     in {
       checks = {
         # Build the crates as part of `nix flake check` for convenience
-        inherit weaver-cli weaver-server weaver-renderer;
+        inherit weaver-cli weaver-app weaver-renderer;
 
         # Run clippy (and deny all warnings) on the workspace source,
         # again, reusing the dependency artifacts from above.
···
 
       packages =
         {
-          inherit weaver-cli weaver-server;
+          inherit weaver-cli weaver-app;
         }
         // lib.optionalAttrs (!pkgs.stdenv.isDarwin) {
           # weaver-workspace-llvm-coverage = craneLibLLvmTools.cargoLlvmCov (commonArgs // {
···
           drv = weaver-cli;
         };
         weaver-server = flake-utils.lib.mkApp {
-          drv = weaver-server;
+          drv = weaver-app;
         };
       };
 
···
         # dioxus-cli = pkgs.dioxus-cli.overrideAttrs (_: {
         #   postPatch = ''
         #     rm Cargo.lock
-        #     cp ${./crates/weaver-server/Dioxus.lock} Cargo.lock
+        #     cp ${./crates/weaver-app/Dioxus.lock} Cargo.lock
         #   '';
         #   cargoDeps = pkgs.rustPlatform.importCargoLock {
-        #     lockFile = ./crates/weaver-server/Dioxus.lock;
+        #     lockFile = ./crates/weaver-app/Dioxus.lock;
         #   };
         # });
         cargoLock = builtins.fromTOML (builtins.readFile ./Cargo.lock);

lexicons/actor/defs.json

···
       "required": ["did"],
       "properties": {
         "did": { "type": "string", "format": "did" },
-        "handle": { "type": "string", "format": "handle" },
-        "displayName": {
-          "type": "string",
-          "maxGraphemes": 64,
-          "maxLength": 640
+        "signature": {
+          "type": "bytes"
+          "description": "signed bytes of the corresponding notebook record in the author's repo"
         }
       }
     },

lexicons/notebook/book.json

···
         "required": ["authors", "entryList"],
         "properties": {
           "title": { "type": "ref", "ref": "sh.weaver.notebook.defs#title" },
+          "path": { "type": "ref", "ref": "sh.weaver.notebook.defs#path" },
           "tags": { "type": "ref", "ref": "sh.weaver.notebook.defs#tags" },
           "authors": {
             "type": "array",

lexicons/notebook/defs.json

···
       "maxLength": 300,
       "description": "The title of the notebook entry."
     },
+    "path": {
+      "type": "string",
+      "maxLength": 100,
+      "description": "The path of the notebook."
+    },
     "tags": {
       "type": "array",
       "items": {

weaver_notes/.obsidian/workspace.json

···
             "state": {
               "type": "markdown",
               "state": {
-                "file": "Weaver - Long-form writing.md",
+                "file": "Arch.md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "Weaver - Long-form writing"
+              "title": "Arch"
             }
           }
         ]
···
             "state": {
               "type": "backlink",
               "state": {
-                "file": "Weaver - Long-form writing.md",
+                "file": "Arch.md",
                 "collapseAll": false,
                 "extraContext": false,
                 "sortOrder": "alphabetical",
···
                 "unlinkedCollapsed": true
               },
               "icon": "links-coming-in",
-              "title": "Backlinks for Weaver - Long-form writing"
+              "title": "Backlinks for Arch"
             }
           },
           {
···
   },
   "active": "f41bdf1f327c8668",
   "lastOpenFiles": [
+    "Weaver - Long-form writing.md",
+    "Arch.md",
     "weaver_photo_med.jpg",
     "xkcd_345_excerpt.png",
-    "Weaver - Long-form writing.md",
     "light_mode_excerpt.png",
     "notebook_entry_preview.png"
   ]

weaver_notes/Arch.md

···
+## Viewer/minimal app
+
+#### Routes - names can be title/name or rkey, ident can be did or handle
+/{ident}/{notebook}/{entry} - entry
+/{ident}/{notebook}/{page} - page of entries
+/{ident}/{notebook}/{chapter}/{entry|page} - entry/page in chapter
+/{ident}/{notebook} - index/"cover page"
+/{ident} - profile page
+
+/ - discover (later, home)
+
+
+/record/{at-uri} - fallback viewer?
+/post/{at-uri} - bsky post, anything similarly shaped
+/leaflet/{pub}/{rkey} - leaflet
+/blog/{at-uri} - whitewind, etc.
+/feed/{at-uri}
+
+
+/{notebook}/image/{name|cid}
+/{notebook}/blob/{cid}
+/{ident}/{notebook}/css