bit of renderer work, docs pages deploy

.github/workflows/static.yml

···
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy static content to Pages
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["main"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          # Upload entire repository
+          path: "./docs"
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.gitignore

···
 /target
-result*
+/result
+/result-lib
+/dist
 /node_modules
 
 .direnv

Cargo.lock

···
 
 [[package]]
 name = "axum"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
-dependencies = [
- "async-trait",
- "axum-core 0.4.5",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "http-body-util",
- "hyper",
- "hyper-util",
- "itoa",
- "matchit 0.7.3",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "rustversion",
- "serde",
- "serde_json",
- "serde_path_to_error",
- "serde_urlencoded",
- "sync_wrapper",
- "tokio",
- "tower",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
-[[package]]
-name = "axum"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "021e862c184ae977658b36c4500f7feac3221ca5da43e3f25bd04ab6c79a29b5"
 dependencies = [
- "axum-core 0.5.2",
+ "axum-core",
  "bytes",
  "form_urlencoded",
  "futures-util",
···
  "hyper",
  "hyper-util",
  "itoa",
- "matchit 0.8.4",
+ "matchit",
  "memchr",
  "mime",
  "percent-encoding",
···
  "sync_wrapper",
  "tokio",
  "tower",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
-[[package]]
-name = "axum-core"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199"
-dependencies = [
- "async-trait",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "http-body-util",
- "mime",
- "pin-project-lite",
- "rustversion",
- "sync_wrapper",
  "tower-layer",
  "tower-service",
  "tracing",
···
 ]
 
 [[package]]
-name = "facet"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36b55e98a6cc63c843db91f6db4be9f47067b9bd07d93560da0ba4c0f55f20fd"
-dependencies = [
- "facet-core",
- "facet-derive",
-]
-
-[[package]]
-name = "facet-core"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5227e1c925a1f21ea3ebff90e08af0b34b59975171cf00fcee36b917941d1ac0"
-dependencies = [
- "bitflags 2.9.0",
- "camino",
- "impls",
-]
-
-[[package]]
-name = "facet-derive"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9982f286c2121f36d6921c7ecedde49158a5ba8eef622a4fd777ff502c1348e3"
-dependencies = [
- "facet-core",
- "facet-derive-emit",
-]
-
-[[package]]
-name = "facet-derive-emit"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ed20e29f8aa502cf1263eb040e3442ef84636e89a88ee8dffcda336a1152a38"
-dependencies = [
- "facet-derive-parse",
-]
-
-[[package]]
-name = "facet-derive-parse"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71ea122ff95ac65c86bf18d0ba7f04f087ef5dd20f7dc76cb5bd69cbb14bd8ad"
-dependencies = [
- "unsynn",
-]
-
-[[package]]
 name = "fallible-iterator"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
 dependencies = [
  "percent-encoding",
+]
+
+[[package]]
+name = "fsevent-sys"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+dependencies = [
+ "libc",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "impls"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a46645bbd70538861a90d0f26c31537cdf1e44aae99a794fb75a664b70951bc"
-
-[[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "equivalent",
  "hashbrown 0.15.3",
+]
+
+[[package]]
+name = "inotify"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
+dependencies = [
+ "bitflags 2.9.0",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
+dependencies = [
+ "libc",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "kdl"
-version = "6.3.4"
+name = "kqueue"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12661358400b02cbbf1fbd05f0a483335490e8a6bd1867620f2eeb78f304a22f"
+checksum = "eac30106d7dce88daf4a3fcb4879ea939476d5074a9b7ddd0fb97fa4bed5596a"
 dependencies = [
- "miette",
- "num",
- "thiserror 1.0.69",
- "winnow 0.6.24",
+ "kqueue-sys",
+ "libc",
+]
+
+[[package]]
+name = "kqueue-sys"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
 ]
 
 [[package]]
···
 dependencies = [
  "regex-automata 0.1.10",
 ]
-
-[[package]]
-name = "matchit"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
 
 [[package]]
 name = "matchit"
···
 checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
 dependencies = [
  "libc",
+ "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.52.0",
 ]
···
 ]
 
 [[package]]
-name = "mutants"
-version = "0.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc0287524726960e07b119cebd01678f852f147742ae0d925e6a520dca956126"
-
-[[package]]
 name = "n0-future"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "nu-ansi-term"
-version = "0.46.0"
+name = "notify"
+version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "2fee8403b3d66ac7b26aee6e40a897d85dc5ce26f44da36b8b73e987cc52e943"
 dependencies = [
- "overload",
- "winapi",
+ "bitflags 2.9.0",
+ "filetime",
+ "fsevent-sys",
+ "inotify",
+ "kqueue",
+ "libc",
+ "log",
+ "mio",
+ "notify-types",
+ "walkdir",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "num"
-version = "0.4.3"
+name = "notify-types"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
-dependencies = [
- "num-bigint",
- "num-complex",
- "num-integer",
- "num-iter",
- "num-rational",
- "num-traits",
-]
+checksum = "5e0826a989adedc2a244799e823aece04662b66609d96af8dff7ac6df9a8925d"
 
 [[package]]
-name = "num-bigint"
-version = "0.4.6"
+name = "nu-ansi-term"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
 dependencies = [
- "num-integer",
- "num-traits",
+ "overload",
+ "winapi",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "num-complex"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
 dependencies = [
  "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
-dependencies = [
- "num-bigint",
  "num-integer",
  "num-traits",
 ]
···
 ]
 
 [[package]]
-name = "shadow_counted"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65da48d447333cebe1aadbdd3662f3ba56e76e67f53bc46f3dd5f67c74629d6b"
-
-[[package]]
 name = "sharded-slab"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "serde_spanned",
  "toml_datetime",
  "toml_write",
- "winnow 0.7.10",
+ "winnow",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "151b5a3e3c45df17466454bb74e9ecedecc955269bdedbf4d150dfa393b55a36"
 dependencies = [
- "axum-core 0.5.2",
+ "axum-core",
  "cookie",
  "futures-util",
  "http",
···
 checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
 
 [[package]]
-name = "unsynn"
-version = "0.0.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14013db4ac11f92d4df4b56edb431eab9c1d9f7aee4791f3205b6a1119b83f54"
-dependencies = [
- "mutants",
- "proc-macro2",
- "shadow_counted",
-]
-
-[[package]]
 name = "untrusted"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "atrium-identity",
  "atrium-oauth",
  "atrium-xrpc",
- "axum 0.8.4",
+ "axum",
  "chrono",
  "clap",
  "dashmap",
···
  "diesel-async",
  "diesel_migrations",
  "dotenvy",
- "facet",
  "hyper",
  "jose",
  "jose-jwk",
- "kdl",
  "merde",
  "miette",
  "minijinja",
···
  "atrium-api",
  "atrium-common",
  "atrium-identity",
- "atrium-lex",
  "atrium-oauth",
  "atrium-xrpc",
- "atrium-xrpc-client",
- "compact_string",
  "esquema-codegen",
  "hickory-resolver",
  "http",
- "jose",
  "jose-jwk",
  "libsqlite3-sys",
  "markdown-weaver",
  "merde",
  "miette",
  "minijinja",
+ "multibase",
  "n0-future",
  "owo-colors",
  "reqwest",
···
  "thiserror 2.0.12",
  "tokio",
  "toml",
+ "tower-layer",
+ "tower-service",
  "tracing",
  "weaver-workspace-hack",
 ]
···
 name = "weaver-renderer"
 version = "0.1.0"
 dependencies = [
+ "atrium-api",
+ "compact_string",
  "n0-future",
  "weaver-common",
  "weaver-workspace-hack",
···
 name = "weaver-server"
 version = "0.1.0"
 dependencies = [
- "axum 0.7.9",
+ "axum",
  "clap",
+ "notify",
  "tokio",
  "weaver-common",
  "weaver-workspace-hack",
···
 name = "weaver-workspace-hack"
 version = "0.1.0"
 dependencies = [
+ "base16ct",
+ "byteorder",
+ "chrono",
  "data-encoding",
+ "der",
+ "diesel",
+ "diesel-async",
+ "diesel_derives",
+ "ecdsa",
+ "either",
+ "elliptic-curve",
+ "fastrand",
+ "ff",
  "futures-channel",
- "futures-core",
+ "generic-array",
+ "group",
+ "hashbrown 0.15.3",
  "idna",
+ "libsqlite3-sys",
+ "log",
  "memchr",
+ "miette",
+ "mime_guess",
+ "minijinja",
+ "num-traits",
+ "p384",
  "percent-encoding",
+ "pkcs8",
  "proc-macro2",
  "quote",
+ "rand_core 0.6.4",
+ "reqwest",
  "scopeguard",
+ "sec1",
+ "serde",
+ "serde_json",
+ "sha2",
  "smallvec",
+ "spki",
+ "subtle",
  "syn",
+ "time",
  "tokio",
+ "tokio-util",
+ "toml",
  "tracing",
+ "tracing-core",
+ "zeroize",
 ]
 
 [[package]]
···
 version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
-
-[[package]]
-name = "winnow"
-version = "0.6.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
-dependencies = [
- "memchr",
-]
 
 [[package]]
 name = "winnow"

Cargo.toml

···
 
 serde = { version = "1.0", features = ["derive"] }
 merde = { version = "10.0.6", features = ["full"] }
-facet = { version = "0.9.6", features = ["camino"] }
 
 minijinja = { version = "2.9.0", default-features = false }
 minijinja-contrib = { version = "2.9.0", default-features = false }

crates/weaver-appview/Cargo.toml

···
 diesel =  { version = "2.2.0", features = ["postgres", "serde_json","chrono"] }
 diesel-async = { version = "0.5.2", features = ["postgres", "deadpool"] }
 diesel_migrations = "2.2.0"
-facet = { workspace = true }
 
-kdl = "6.3.4"
 toml = { version = "0.8.22", features = ["preserve_order"] }
 jose = { version = "0.0.2", features = ["crypto-rustcrypto"] }
 jose-jwk = "0.1.2"

crates/weaver-appview/src/oauth.rs

···
 use miette::IntoDiagnostic;
 use miette::Result;
 use miette::miette;
-use weaver_common::client::WeaverHttpClient;
+use weaver_common::agent::WeaverHttpClient;
 use weaver_common::oauth::WeaverOAuthClient;
 use weaver_common::resolver::HickoryDnsTxtResolver;
 

crates/weaver-cli/src/main.rs

···
 use rouille::Server;
 use std::error;
 use tokio::sync::mpsc;
+use weaver_common::agent::WeaverAgent;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn error::Error>> {
···
 
     let params = rx.recv().await.unwrap();
     let (session, _) = client.callback(params).await?;
-    server_stop.send(()).expect("Failed to stop callbackserver");
-    let agent = Agent::new(session);
+    server_stop
+        .send(())
+        .expect("Failed to stop callback server");
+    let agent = WeaverAgent::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(),
-        )
+        .get_profile_pds(agent.did().await.unwrap().into())
         .await?;
-    for feed in &output.feed {
-        println!("{feed:?}");
-    }
+    println!("{output:?}");
+
+    // let agent = Agent::new(session);
+    // let output = agent
+    //     .api
+    //     .app
+    //     .bsky
+    //     .feed
+    //     .get_timeline(
+    //         weaver_common::app::bsky::feed::get_timeline::ParametersData {
+    //             algorithm: None,
+    //             cursor: None,
+    //             limit: 3.try_into().ok(),
+    //         }
+    //         .into(),
+    //     )
+    //     .await?;
+    // for feed in &output.feed {
+    //     println!("{feed:?}");
+    // }
     server_handle.join().unwrap();
     Ok(())
 }

crates/weaver-common/Cargo.toml

···
 atrium-common = "0.1.1"
 atrium-identity = "0.1.3"
 atrium-oauth = "0.1.1"
-atrium-xrpc-client = "0.5.13"
-atrium-lex = { workspace = true }
+
 
 merde = { workspace = true, features = ["yaml", "serde"] }
 serde = { workspace = true }
···
 tracing = { workspace = true }
 hickory-resolver = "0.24.1"
 toml = "0.8.22"
-compact_string = "0.1.0"
-jose = { version = "0.0.2", features = ["crypto-rustcrypto"] }
+#jose = { version = "0.0.2", features = ["crypto-rustcrypto"] }
 jose-jwk = "0.1.2"
 reqwest = "0.12.15"
 
+
+tower-service = "0.3.3"
+tower-layer = "0.3.3"
+multibase = "0.9.1"
 
 
 

crates/weaver-common/src/agent.rs

···
+use crate::app::bsky::actor::defs::ProfileViewDetailedData;
+use crate::error::GenericXrpcError;
+use crate::resolver::HickoryDnsTxtResolver;
+use crate::sh::weaver::actor::defs::ProfileDataViewInnerRefs;
+use atrium_api::agent::{CloneWithProxy, Configure};
+use atrium_api::types::string::{Cid, Did, Handle, Nsid, RecordKey};
+use atrium_api::types::{Collection, Union, Unknown};
+use atrium_api::{agent::SessionManager, types::string::AtIdentifier};
+use atrium_common::resolver::Resolver;
+use atrium_identity::did::{CommonDidResolver, CommonDidResolverConfig, DEFAULT_PLC_DIRECTORY_URL};
+use atrium_identity::handle::{AtprotoHandleResolver, AtprotoHandleResolverConfig};
+use atrium_identity::identity_resolver::IdentityResolver;
+use atrium_xrpc::{Error as XrpcError, HttpClient, OutputDataOrBytes, XrpcClient, XrpcRequest};
+use http::{Request, Response};
+use serde::{Serialize, de::DeserializeOwned};
+use std::{fmt::Debug, ops::Deref, sync::Arc};
+
+use crate::Error;
+use crate::client::Service;
+
+pub struct WeaverHttpClient {
+    pub client: reqwest::Client,
+}
+
+impl atrium_xrpc::HttpClient for WeaverHttpClient {
+    async fn send_http(
+        &self,
+        request: atrium_xrpc::http::Request<Vec<u8>>,
+    ) -> core::result::Result<
+        atrium_xrpc::http::Response<Vec<u8>>,
+        Box<dyn std::error::Error + Send + Sync + 'static>,
+    > {
+        let response = self.client.execute(request.try_into()?).await?;
+        let mut builder = atrium_xrpc::http::Response::builder().status(response.status());
+        for (k, v) in response.headers() {
+            builder = builder.header(k, v);
+        }
+        builder
+            .body(response.bytes().await?.to_vec())
+            .map_err(Into::into)
+    }
+}
+
+impl Default for WeaverHttpClient {
+    fn default() -> Self {
+        Self {
+            client: reqwest::Client::new(),
+        }
+    }
+}
+
+pub struct WeaverAgent<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    session_manager: Arc<Wrapper<M>>,
+    resolver: Arc<
+        IdentityResolver<
+            CommonDidResolver<WeaverHttpClient>,
+            AtprotoHandleResolver<HickoryDnsTxtResolver, WeaverHttpClient>,
+        >,
+    >,
+    pub api: Service<Wrapper<M>>,
+}
+
+impl<M> WeaverAgent<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    /// Creates a new agent with the given session manager.
+
+    pub fn new(session_manager: M) -> Self {
+        let session_manager = Arc::new(Wrapper::new(session_manager));
+        let api = Service::new(session_manager.clone());
+        let http_client = Arc::new(WeaverHttpClient::default());
+        let resolver_config = atrium_identity::identity_resolver::IdentityResolverConfig {
+            did_resolver: CommonDidResolver::new(CommonDidResolverConfig {
+                plc_directory_url: DEFAULT_PLC_DIRECTORY_URL.to_string(),
+                http_client: Arc::clone(&http_client),
+            }),
+            handle_resolver: AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+                dns_txt_resolver: HickoryDnsTxtResolver::default(),
+                http_client: Arc::clone(&http_client),
+            }),
+        };
+        Self {
+            session_manager,
+            resolver: Arc::new(IdentityResolver::new(resolver_config)),
+            api,
+        }
+    }
+
+    /// Returns the DID of the current session.
+
+    pub async fn did(&self) -> Option<Did> {
+        self.session_manager.did().await
+    }
+}
+
+impl<M> WeaverAgent<M>
+where
+    M: SessionManager + Configure + Send + Sync,
+{
+    pub async fn get_bsky_profile(
+        &self,
+        actor: AtIdentifier,
+    ) -> Result<ProfileViewDetailedData, Error> {
+        use crate::app::bsky::actor::get_profile::*;
+        let result = self
+            .api
+            .app
+            .bsky
+            .actor
+            .get_profile(ParametersData { actor }.into())
+            .await?;
+        Ok(result.data)
+    }
+
+    pub async fn get_weaver_profile_pds(
+        &self,
+        actor: AtIdentifier,
+    ) -> Result<crate::sh::weaver::actor::defs::ProfileViewData, Error> {
+        use crate::sh::weaver::actor::*;
+        let identity = self
+            .resolver
+            .resolve(actor.as_ref())
+            .await
+            .expect("valid identifier");
+        let did = Did::new(identity.did).expect("valid did");
+        let record = self
+            .get_record(
+                Nsid::new(Profile::NSID.into()).expect("valid nsid"),
+                RecordKey::new(Profile::NSID.to_string()).expect("valid key"),
+                AtIdentifier::Did(did.clone()),
+                None,
+            )
+            .await?;
+        let profile_record = profile::RecordData::from(record.value);
+
+        Ok(defs::ProfileViewData {
+            avatar: profile_record
+                .avatar
+                .map(|avatar| crate::avatar_cdn_url(&did, &avatar)),
+            created_at: profile_record.created_at,
+            did,
+            display_name: profile_record.display_name,
+            handle: Handle::new(actor.as_ref().to_string()).expect("valid handle"),
+            labels: None,
+            links: profile_record.links,
+            location: profile_record.location,
+            description: profile_record.description,
+            pronouns: profile_record.pronouns,
+            indexed_at: None,
+        })
+    }
+
+    pub async fn get_profile_pds(
+        &self,
+        actor: AtIdentifier,
+    ) -> Result<crate::sh::weaver::actor::defs::ProfileDataViewInnerRefs, Error> {
+        use crate::sh::weaver::actor::defs::ProfileDataViewInnerRefs::*;
+        let maybe_profile = self.get_weaver_profile_pds(actor.clone()).await;
+        match maybe_profile {
+            Ok(profile) => Ok(ShWeaverActorDefsProfileView(Box::new(profile.into()))),
+            Err(e1) => {
+                let maybe_profile = self.get_bsky_profile(actor.clone()).await;
+                match maybe_profile {
+                    Ok(profile) => Ok(AppBskyActorDefsProfileViewDetailed(Box::new(
+                        profile.into(),
+                    ))),
+                    Err(e2) => Err(e2.with_errors(e1)),
+                }
+            }
+        }
+    }
+
+    pub async fn put_record(
+        &self,
+        collection: Nsid,
+        record: Unknown,
+        repo: AtIdentifier,
+        rkey: RecordKey,
+    ) -> Result<crate::com::atproto::repo::put_record::OutputData, Error> {
+        use crate::com::atproto::repo::put_record::*;
+        let result = self
+            .api
+            .com
+            .atproto
+            .repo
+            .put_record(
+                InputData {
+                    collection,
+                    record,
+                    repo,
+                    rkey,
+                    swap_commit: None,
+                    swap_record: None,
+                    validate: None,
+                }
+                .into(),
+            )
+            .await?;
+        Ok(result.data)
+    }
+
+    pub async fn get_record(
+        &self,
+        collection: Nsid,
+        rkey: RecordKey,
+        repo: AtIdentifier,
+        cid: Option<Cid>,
+    ) -> Result<crate::com::atproto::repo::get_record::OutputData, Error> {
+        use crate::com::atproto::repo::get_record::*;
+        let result = self
+            .api
+            .com
+            .atproto
+            .repo
+            .get_record(
+                ParametersData {
+                    collection,
+                    rkey,
+                    repo,
+                    cid,
+                }
+                .into(),
+            )
+            .await?;
+        Ok(result.data)
+    }
+
+    pub async fn get_blob(&self, did: Did, cid: Cid) -> Result<Vec<u8>, Error> {
+        use crate::com::atproto::sync::get_blob::*;
+        let result = self
+            .api
+            .com
+            .atproto
+            .sync
+            .get_blob(ParametersData { did, cid }.into())
+            .await?;
+        Ok(result)
+    }
+
+    pub async fn upload_blob(
+        &self,
+        input: Vec<u8>,
+    ) -> Result<crate::com::atproto::repo::upload_blob::OutputData, Error> {
+        let result = self.api.com.atproto.repo.upload_blob(input.into()).await?;
+        Ok(result.data)
+    }
+
+    pub async fn upload_artifact(
+        &self,
+        content: String,
+        mime_type: Option<String>,
+    ) -> Result<crate::com::atproto::repo::upload_blob::OutputData, Error> {
+        let encoding = if let Some(mime_type) = mime_type {
+            Some(mime_type)
+        } else {
+            Some(String::from("*/*"))
+        };
+        let input = content.into_bytes();
+        let response = self
+            .session_manager
+            .inner
+            .send_xrpc::<(), Vec<u8>, crate::com::atproto::repo::upload_blob::OutputData, crate::com::atproto::repo::upload_blob::Error>(
+                &atrium_xrpc::XrpcRequest {
+                    method: http::Method::POST,
+                    nsid: crate::com::atproto::repo::upload_blob::NSID.into(),
+                    parameters: None,
+                    input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
+                    encoding,
+                },
+            )
+            .await.map_err(Error::from)?;
+        Ok(match response {
+            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
+            _ => Err(GenericXrpcError::Other(
+                "Unexpected Respose Type".to_owned(),
+            )),
+        }?)
+    }
+
+    pub async fn delete_record(
+        &self,
+        collection: Nsid,
+        rkey: RecordKey,
+        repo: AtIdentifier,
+    ) -> Result<crate::com::atproto::repo::delete_record::OutputData, Error> {
+        use crate::com::atproto::repo::delete_record::*;
+        let result = self
+            .api
+            .com
+            .atproto
+            .repo
+            .delete_record(
+                InputData {
+                    collection,
+                    rkey,
+                    repo,
+                    swap_commit: None,
+                    swap_record: None,
+                }
+                .into(),
+            )
+            .await?;
+        Ok(result.data)
+    }
+}
+
+impl<M> WeaverAgent<M>
+where
+    M: CloneWithProxy + SessionManager + Send + Sync,
+{
+    /// Configures the atproto-proxy header to be applied on requests.
+
+    ///
+
+    /// Returns a new client service with the proxy header configured.
+
+    pub fn api_with_proxy(&self, did: Did, service_type: impl AsRef<str>) -> Service<Wrapper<M>> {
+        Service::new(Arc::new(
+            self.session_manager.clone_with_proxy(did, service_type),
+        ))
+    }
+
+    pub fn weaver_api(&self) -> Service<Wrapper<M>> {
+        self.api_with_proxy(
+            Did::new("did:web:appview.weaver.sh".into()).expect("valid did"),
+            &"atproto_weaver",
+        )
+    }
+
+    pub async fn get_profile_appview(
+        &self,
+        actor: AtIdentifier,
+    ) -> Result<Union<ProfileDataViewInnerRefs>, Error> {
+        use crate::sh::weaver::actor::get_profile::*;
+        let result = self
+            .weaver_api()
+            .sh
+            .weaver
+            .actor
+            .get_profile(ParametersData { actor }.into())
+            .await?;
+        Ok(result.inner.clone())
+    }
+}
+
+impl<M> Configure for WeaverAgent<M>
+where
+    M: Configure + SessionManager + Send + Sync,
+{
+    fn configure_endpoint(&self, endpoint: String) {
+        self.session_manager.configure_endpoint(endpoint);
+    }
+
+    fn configure_labelers_header(&self, labeler_dids: Option<Vec<(Did, bool)>>) {
+        self.session_manager.configure_labelers_header(labeler_dids);
+    }
+
+    fn configure_proxy_header(&self, did: Did, service_type: impl AsRef<str>) {
+        self.session_manager
+            .configure_proxy_header(did, service_type);
+    }
+}
+
+pub struct Wrapper<M> {
+    inner: Arc<M>,
+}
+
+impl<M> Wrapper<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    pub fn new(inner: M) -> Self {
+        Self {
+            inner: Arc::new(inner),
+        }
+    }
+}
+
+impl<M> HttpClient for Wrapper<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    async fn send_http(
+        &self,
+        request: Request<Vec<u8>>,
+    ) -> Result<Response<Vec<u8>>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+        self.inner.send_http(request).await
+    }
+}
+
+impl<M> XrpcClient for Wrapper<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    fn base_uri(&self) -> String {
+        self.inner.base_uri()
+    }
+    async fn send_xrpc<P, I, O, E>(
+        &self,
+        request: &XrpcRequest<P, I>,
+    ) -> Result<OutputDataOrBytes<O>, XrpcError<E>>
+    where
+        P: Serialize + Send + Sync,
+        I: Serialize + Send + Sync,
+        O: DeserializeOwned + Send + Sync,
+        E: DeserializeOwned + Send + Sync + Debug,
+    {
+        self.inner.send_xrpc(request).await
+    }
+}
+
+impl<M> SessionManager for Wrapper<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    async fn did(&self) -> Option<Did> {
+        self.inner.did().await
+    }
+}
+
+impl<M> Configure for Wrapper<M>
+where
+    M: Configure,
+{
+    fn configure_endpoint(&self, endpoint: String) {
+        self.inner.configure_endpoint(endpoint);
+    }
+    fn configure_labelers_header(&self, labeler_dids: Option<Vec<(Did, bool)>>) {
+        self.inner.configure_labelers_header(labeler_dids);
+    }
+    fn configure_proxy_header(&self, did: Did, service_type: impl AsRef<str>) {
+        self.inner.configure_proxy_header(did, service_type);
+    }
+}
+
+impl<M> CloneWithProxy for Wrapper<M>
+where
+    M: CloneWithProxy,
+{
+    fn clone_with_proxy(&self, did: Did, service_type: impl AsRef<str>) -> Self {
+        Self {
+            inner: Arc::new(self.inner.clone_with_proxy(did, service_type)),
+        }
+    }
+}
+
+impl<M> Clone for Wrapper<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<M> Deref for Wrapper<M>
+where
+    M: SessionManager + Send + Sync,
+{
+    type Target = M;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

crates/weaver-common/src/client.rs

···
-use atrium_api::app::bsky::actor::defs::ProfileViewDetailedData;
-use atrium_api::{agent::SessionManager, types::string::AtIdentifier};
-
-use crate::Error;
-
-pub struct WeaverHttpClient {
-    pub client: reqwest::Client,
-}
-
-impl atrium_xrpc::HttpClient for WeaverHttpClient {
-    async fn send_http(
-        &self,
-        request: atrium_xrpc::http::Request<Vec<u8>>,
-    ) -> core::result::Result<
-        atrium_xrpc::http::Response<Vec<u8>>,
-        Box<dyn std::error::Error + Send + Sync + 'static>,
-    > {
-        let response = self.client.execute(request.try_into()?).await?;
-        let mut builder = atrium_xrpc::http::Response::builder().status(response.status());
-        for (k, v) in response.headers() {
-            builder = builder.header(k, v);
-        }
-        builder
-            .body(response.bytes().await?.to_vec())
-            .map_err(Into::into)
-    }
-}
-
-impl Default for WeaverHttpClient {
-    fn default() -> Self {
-        Self {
-            client: reqwest::Client::new(),
-        }
-    }
-}
-
-pub struct WeaverAgent<M>
-where
-    M: SessionManager + Send + Sync,
-{
-    pub a: atrium_api::agent::Agent<M>,
-}
-
-impl<M> WeaverAgent<M>
-where
-    M: SessionManager + Send + Sync,
-{
-    pub fn new(session_manager: M) -> Self {
-        Self {
-            a: atrium_api::agent::Agent::new(session_manager),
-        }
-    }
-
-    pub async fn get_profile(&self, actor: AtIdentifier) -> Result<ProfileViewDetailedData, Error> {
-        use atrium_api::app::bsky::actor::get_profile::*;
-        let resp = self
-            .a
-            .api
-            .app
-            .bsky
-            .actor
-            .get_profile(ParametersData { actor }.into())
-            .await?;
-
-        Ok(resp.data)
-    }
-}

crates/weaver-common/src/compat.rs

···
-// This module contains compatability shims for the atrium_api crate.

crates/weaver-common/src/error.rs

···
     advice: Option<String>,
 }
 
+impl Error {
+    pub fn new(errors: Vec<WeaverErrorKind>) -> Self {
+        Self {
+            errors,
+            advice: None,
+        }
+    }
+
+    pub fn with_advice(mut self, advice: String) -> Self {
+        self.advice = Some(advice);
+        self
+    }
+
+    pub fn with_error(mut self, error: WeaverErrorKind) -> Self {
+        self.errors.push(error);
+        self
+    }
+
+    pub fn with_errors(mut self, errors: Error) -> Self {
+        self.errors.extend(errors.errors);
+        self
+    }
+}
+
 #[derive(thiserror::Error, Debug, Diagnostic)]
 pub enum WeaverErrorKind {
     #[error(transparent)]
···
         error: Option<String>,
     },
     Other(String),
+}
+
+impl From<GenericXrpcError> for Error {
+    fn from(err: GenericXrpcError) -> Self {
+        Self {
+            errors: vec![WeaverErrorKind::AtprotoError(AtprotoError {
+                kind: AtprotoErrorKind::AtriumCatchall(err),
+            })],
+            advice: None,
+        }
+    }
 }
 
 impl std::fmt::Display for GenericXrpcError {

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

···
     pub app: app::Service<T>,
     pub chat: chat::Service<T>,
     pub com: com::Service<T>,
+    pub sh: sh::Service<T>,
     pub tools: tools::Service<T>,
     pub(crate) _phantom: core::marker::PhantomData<T>,
 }
···
         }
     }
 }
+pub mod sh {
+    pub struct Service<T>
+    where
+        T: atrium_xrpc::XrpcClient + Send + Sync,
+    {
+        pub weaver: weaver::Service<T>,
+        pub(crate) _phantom: core::marker::PhantomData<T>,
+    }
+    pub mod weaver {
+        pub struct Service<T>
+        where
+            T: atrium_xrpc::XrpcClient + Send + Sync,
+        {
+            pub actor: actor::Service<T>,
+            pub(crate) _phantom: core::marker::PhantomData<T>,
+        }
+        pub mod actor {
+            pub struct Service<T>
+            where
+                T: atrium_xrpc::XrpcClient + Send + Sync,
+            {
+                pub(crate) xrpc: std::sync::Arc<T>,
+                pub(crate) _phantom: core::marker::PhantomData<T>,
+            }
+        }
+    }
+}
 pub mod tools {
     pub struct Service<T>
     where
···
             app: app::Service::new(std::sync::Arc::clone(&xrpc)),
             chat: chat::Service::new(std::sync::Arc::clone(&xrpc)),
             com: com::Service::new(std::sync::Arc::clone(&xrpc)),
+            sh: sh::Service::new(std::sync::Arc::clone(&xrpc)),
             tools: tools::Service::new(std::sync::Arc::clone(&xrpc)),
             _phantom: core::marker::PhantomData,
         }
···
             .await?;
         match response {
             atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
+            _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
+        }
+    }
+}
+impl<T> sh::Service<T>
+where
+    T: atrium_xrpc::XrpcClient + Send + Sync,
+{
+    #[allow(unused_variables)]
+    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
+        Self {
+            weaver: sh::weaver::Service::new(std::sync::Arc::clone(&xrpc)),
+            _phantom: core::marker::PhantomData,
+        }
+    }
+}
+impl<T> sh::weaver::Service<T>
+where
+    T: atrium_xrpc::XrpcClient + Send + Sync,
+{
+    #[allow(unused_variables)]
+    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
+        Self {
+            actor: sh::weaver::actor::Service::new(std::sync::Arc::clone(&xrpc)),
+            _phantom: core::marker::PhantomData,
+        }
+    }
+}
+impl<T> sh::weaver::actor::Service<T>
+where
+    T: atrium_xrpc::XrpcClient + Send + Sync,
+{
+    #[allow(unused_variables)]
+    pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
+        Self {
+            xrpc,
+            _phantom: core::marker::PhantomData,
+        }
+    }
+    ///Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth.
+    pub async fn get_profile(
+        &self,
+        params: crate::sh::weaver::actor::get_profile::Parameters,
+    ) -> atrium_xrpc::Result<
+        crate::sh::weaver::actor::get_profile::Output,
+        crate::sh::weaver::actor::get_profile::Error,
+    > {
+        let response = self
+            .xrpc
+            .send_xrpc::<
+                _,
+                (),
+                _,
+                _,
+            >(
+                &atrium_xrpc::XrpcRequest {
+                    method: http::Method::GET,
+                    nsid: crate::sh::weaver::actor::get_profile::NSID.into(),
+                    parameters: Some(params),
+                    input: None,
+                    encoding: None,
+                },
+            )
+            .await?;
+        match response {
+            atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
             _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
         }
     }

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

···
 // @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
 //!Definitions for the `sh.weaver.actor` namespace.
 pub mod defs;
+pub mod get_profile;
 pub mod profile;
 #[derive(Debug)]
 pub struct Profile;

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

···
 //!Definitions for the `sh.weaver.actor.defs` namespace.
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
+pub struct ProfileDataViewData {
+    pub inner: atrium_api::types::Union<ProfileDataViewInnerRefs>,
+}
+pub type ProfileDataView = atrium_api::types::Object<ProfileDataViewData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
 pub struct ProfileViewData {
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub avatar: core::option::Option<String>,
···
     ///Free-form location text.
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub location: core::option::Option<String>,
+    ///Pronouns to use in user-generated content.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub pronouns: core::option::Option<crate::sh::weaver::actor::profile::PronounsList>,
 }
 pub type ProfileView = atrium_api::types::Object<ProfileViewData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TangledProfileViewData {
+    ///Include link to this account on Bluesky.
+    pub bluesky: bool,
+    ///Free-form profile description text.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub description: core::option::Option<String>,
+    pub did: atrium_api::types::string::Did,
+    pub handle: atrium_api::types::string::Handle,
+    #[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>,
+    ///Any ATURI, it is up to appviews to validate these fields.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub pinned_repositories: core::option::Option<Vec<String>>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub stats: core::option::Option<Vec<String>>,
+}
+pub type TangledProfileView = atrium_api::types::Object<TangledProfileViewData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(tag = "$type")]
+pub enum ProfileDataViewInnerRefs {
+    #[serde(rename = "sh.weaver.actor.defs#profileView")]
+    ShWeaverActorDefsProfileView(Box<crate::sh::weaver::actor::defs::ProfileView>),
+    #[serde(rename = "app.bsky.actor.defs#profileViewDetailed")]
+    AppBskyActorDefsProfileViewDetailed(
+        Box<crate::app::bsky::actor::defs::ProfileViewDetailed>,
+    ),
+}

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

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.actor.getProfile` namespace.
+pub const NSID: &str = "sh.weaver.actor.getProfile";
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ParametersData {
+    ///Handle or DID of account to fetch profile of.
+    pub actor: atrium_api::types::string::AtIdentifier,
+}
+pub type Parameters = atrium_api::types::Object<ParametersData>;
+pub type Output = crate::sh::weaver::actor::defs::ProfileDataView;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(tag = "error", content = "message")]
+pub enum Error {}
+impl std::fmt::Display for Error {
+    fn fmt(&self, _f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        Ok(())
+    }
+}

crates/weaver-common/src/lib.rs

···
-pub mod client;
-pub mod compat;
+pub mod agent;
 pub mod config;
 pub mod error;
 pub mod lexicons;
 pub mod oauth;
 pub mod resolver;
+pub mod xrpc_server;
+use atrium_api::types::{BlobRef, TypedBlobRef, string::Did};
 pub use lexicons::*;
 
 pub use crate::error::{Error, IoError, ParseError, SerDeError};
···
         markdown_weaver::CowStr::Inlined(s) => std::borrow::Cow::Owned(s.as_ref().to_owned()),
     }
 }
+
+pub fn avatar_cdn_url(did: &Did, blob_ref: &BlobRef) -> String {
+    let (cid, mime_type) = match blob_ref {
+        BlobRef::Typed(TypedBlobRef::Blob(b)) => (
+            atrium_api::types::string::Cid::new(b.r#ref.0)
+                .as_ref()
+                .to_string(),
+            &b.mime_type,
+        ),
+        BlobRef::Untyped(r) => (r.cid.clone(), &r.mime_type),
+    };
+    format!(
+        "https://cdn.bsky.app/img/avatar/plain/{}/{}@{}",
+        did.as_str(),
+        cid,
+        mime_type.strip_prefix("image/").unwrap_or(mime_type)
+    )
+}

crates/weaver-common/src/oauth.rs

···
 
 use std::sync::Arc;
 
-use crate::{client::WeaverHttpClient, resolver::HickoryDnsTxtResolver};
+use crate::{agent::WeaverHttpClient, resolver::HickoryDnsTxtResolver};
 
 pub struct NativeOAuthClient {
     oauth: NativeBasicOAuthClient,

crates/weaver-common/src/xrpc_server.rs

···
+pub async fn serve<T, E>(
+    namespace: String,
+) -> Result<atrium_xrpc::OutputDataOrBytes<T>, atrium_xrpc::Error<E>>
+where
+    T: serde::de::DeserializeOwned,
+    E: serde::de::DeserializeOwned + std::fmt::Debug,
+{
+    todo!()
+}

crates/weaver-renderer/Cargo.toml

···
 
 [dependencies]
 n0-future = { workspace = true }
+atrium-api = { version = "0.25.3", default-features = false }
 
 weaver-common = { path = "../weaver-common" }
+
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
+compact_string = "0.1.0"

crates/weaver-renderer/src/lib.rs

···
+//! Weaver renderer
+//!
+//! This crate works with the weaver-markdown crate to render and optionally upload markdown notebooks to your ATProto PDS.
+//!
 
+pub mod types;

crates/weaver-renderer/src/types.rs

···
+use atrium_api::types::string::{Cid, Did};
+use compact_string::CompactString;
+
+pub type MimeType = CompactString;
+
+pub enum BlobLink {
+    PDS {
+        pds_host: String,
+        did: Did,
+        cid: Cid,
+        mime_type: MimeType,
+    },
+    BskyCdn(CdnLink),
+    WeaverCdn(CdnLink),
+}
+
+pub enum CdnLink {
+    Avatar(Did, Cid, MimeType),
+    Banner(Did, Cid, MimeType),
+    Thumbnail(Did, Cid, MimeType),
+    PostImage(Did, Cid, MimeType),
+    EmbedImage(Did, Cid, MimeType),
+}
+
+impl std::fmt::Display for BlobLink {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}{}/{}@{}",
+            self.url_prefix(),
+            self.did().as_str(),
+            self.cid().as_ref(),
+            self.mime_type().rsplit('/').next().unwrap()
+        )
+    }
+}
+
+impl BlobLink {
+    #[inline]
+    pub fn url_prefix(&self) -> &str {
+        match self {
+            BlobLink::PDS { pds_host, .. } => pds_host,
+            BlobLink::BskyCdn(CdnLink::Avatar(..)) => "https://cdn.bsky.app/img/avatar/plain/",
+            BlobLink::BskyCdn(CdnLink::Banner(..)) => "https://cdn.bsky.app/img/banner/plain/",
+            BlobLink::BskyCdn(CdnLink::Thumbnail(..)) => {
+                "https://cdn.bsky.app/img/feed_thumbnail/plain/"
+            }
+            BlobLink::BskyCdn(CdnLink::PostImage(..)) => {
+                "https://cdn.bsky.app/img/feed_fullsize/plain/"
+            }
+            BlobLink::BskyCdn(CdnLink::EmbedImage(..)) => {
+                "https://cdn.bsky.app/img/feed_fullsize/plain/"
+            }
+            BlobLink::WeaverCdn(CdnLink::Avatar(..)) => "https://cdn.weaver.sh/img/avatar/",
+            BlobLink::WeaverCdn(CdnLink::Banner(..)) => "https://cdn.weaver.sh/img/full/",
+            BlobLink::WeaverCdn(CdnLink::Thumbnail(..)) => "https://cdn.weaver.sh/img/thumbnail/",
+            BlobLink::WeaverCdn(CdnLink::PostImage(..)) => "https://cdn.weaver.sh/img/full/",
+            BlobLink::WeaverCdn(CdnLink::EmbedImage(..)) => "https://cdn.weaver.sh/img/embed/",
+        }
+    }
+
+    #[inline]
+    pub const fn did(&self) -> &Did {
+        match self {
+            BlobLink::PDS { did, .. } => did,
+            BlobLink::BskyCdn(CdnLink::Avatar(did, ..))
+            | BlobLink::BskyCdn(CdnLink::Banner(did, ..))
+            | BlobLink::BskyCdn(CdnLink::Thumbnail(did, ..))
+            | BlobLink::BskyCdn(CdnLink::PostImage(did, ..))
+            | BlobLink::BskyCdn(CdnLink::EmbedImage(did, ..)) => did,
+            BlobLink::WeaverCdn(CdnLink::Avatar(did, ..))
+            | BlobLink::WeaverCdn(CdnLink::Banner(did, ..))
+            | BlobLink::WeaverCdn(CdnLink::Thumbnail(did, ..))
+            | BlobLink::WeaverCdn(CdnLink::PostImage(did, ..))
+            | BlobLink::WeaverCdn(CdnLink::EmbedImage(did, ..)) => did,
+        }
+    }
+
+    #[inline]
+    pub const fn cid(&self) -> &Cid {
+        match self {
+            BlobLink::PDS { cid, .. } => cid,
+            BlobLink::BskyCdn(CdnLink::Avatar(_, cid, ..))
+            | BlobLink::BskyCdn(CdnLink::Banner(_, cid, ..))
+            | BlobLink::BskyCdn(CdnLink::Thumbnail(_, cid, ..))
+            | BlobLink::BskyCdn(CdnLink::PostImage(_, cid, ..))
+            | BlobLink::BskyCdn(CdnLink::EmbedImage(_, cid, ..)) => cid,
+            BlobLink::WeaverCdn(CdnLink::Avatar(_, cid, ..))
+            | BlobLink::WeaverCdn(CdnLink::Banner(_, cid, ..))
+            | BlobLink::WeaverCdn(CdnLink::Thumbnail(_, cid, ..))
+            | BlobLink::WeaverCdn(CdnLink::PostImage(_, cid, ..))
+            | BlobLink::WeaverCdn(CdnLink::EmbedImage(_, cid, ..)) => cid,
+        }
+    }
+
+    #[inline]
+    pub const fn mime_type(&self) -> &MimeType {
+        match self {
+            BlobLink::PDS { mime_type, .. } => mime_type,
+            BlobLink::BskyCdn(CdnLink::Avatar(_, _, mime_type))
+            | BlobLink::BskyCdn(CdnLink::Banner(_, _, mime_type))
+            | BlobLink::BskyCdn(CdnLink::Thumbnail(_, _, mime_type))
+            | BlobLink::BskyCdn(CdnLink::PostImage(_, _, mime_type))
+            | BlobLink::BskyCdn(CdnLink::EmbedImage(_, _, mime_type)) => mime_type,
+            BlobLink::WeaverCdn(CdnLink::Avatar(_, _, mime_type))
+            | BlobLink::WeaverCdn(CdnLink::Banner(_, _, mime_type))
+            | BlobLink::WeaverCdn(CdnLink::Thumbnail(_, _, mime_type))
+            | BlobLink::WeaverCdn(CdnLink::PostImage(_, _, mime_type))
+            | BlobLink::WeaverCdn(CdnLink::EmbedImage(_, _, mime_type)) => mime_type,
+        }
+    }
+}

crates/weaver-server/Cargo.toml

···
 weaver-common = { path = "../weaver-common" }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
 
-axum = "0.7.5"
+axum = "0.8"
 tokio = { version = "1.44", features = ["full"] }
-
+notify = "8.0"
 
 clap = { version = "4.5", features = ["derive", "env", "cargo", "unicode"] }

crates/weaver-server/src/main.rs

···
+//! Weaver server
+//!
+//! This crate is a lightweight HTTP server which can serve a notebook.
+//! It will auto-reload
+
+use axum::{Router, response::Html, routing::get};
+
+use tokio::net::TcpListener;
+
 #[tokio::main]
 async fn main() {}
+
+async fn handler() -> Html<&'static str> {
+    Html("<h1>Hello, World!</h1>")
+}

crates/weaver-workspace-hack/Cargo.toml

···
 
 ### BEGIN HAKARI SECTION
 [dependencies]
+base16ct = { version = "0.2", default-features = false, features = ["alloc"] }
+byteorder = { version = "1" }
+chrono = { version = "0.4", features = ["serde"] }
 data-encoding = { version = "2" }
-futures-channel = { version = "0.3" }
-futures-core = { version = "0.3" }
+der = { version = "0.7", default-features = false, features = ["oid", "pem"] }
+diesel = { version = "2", features = ["chrono", "i-implement-a-third-party-backend-and-opt-into-breaking-changes", "postgres", "serde_json", "sqlite"] }
+diesel-async = { version = "0.5", features = ["deadpool", "postgres", "sync-connection-wrapper"] }
+ecdsa = { version = "0.16", features = ["alloc", "der", "signing", "verifying"] }
+either = { version = "1", features = ["use_std"] }
+elliptic-curve = { version = "0.13", features = ["digest", "hazmat", "jwk", "pem"] }
+fastrand = { version = "2" }
+ff = { version = "0.13", default-features = false, features = ["alloc"] }
+futures-channel = { version = "0.3", features = ["sink"] }
+generic-array = { version = "0.14", default-features = false, features = ["more_lengths", "serde", "zeroize"] }
+group = { version = "0.13", default-features = false, features = ["alloc"] }
+hashbrown = { version = "0.15", features = ["serde"] }
 idna = { version = "1" }
-memchr = { version = "2" }
+libsqlite3-sys = { version = "0.30", features = ["bundled"] }
+log = { version = "0.4", default-features = false, features = ["std"] }
+memchr = { version = "2", features = ["use_std"] }
+miette = { version = "7", features = ["fancy", "syntect-highlighter"] }
+mime_guess = { version = "2" }
+minijinja = { version = "2" }
+num-traits = { version = "0.2", default-features = false, features = ["i128", "libm", "std"] }
+p384 = { version = "0.13", default-features = false, features = ["ecdsa"] }
 percent-encoding = { version = "2" }
-proc-macro2 = { version = "1" }
+pkcs8 = { version = "0.10", default-features = false, features = ["pem"] }
+proc-macro2 = { version = "1", features = ["span-locations"] }
 quote = { version = "1" }
+rand_core = { version = "0.6", default-features = false, features = ["std"] }
+reqwest = { version = "0.12", features = ["gzip", "json", "rustls-tls"] }
 scopeguard = { version = "1" }
+sec1 = { version = "0.7", features = ["pem", "serde", "subtle"] }
+serde = { version = "1", features = ["alloc", "derive"] }
+serde_json = { version = "1", features = ["alloc", "preserve_order", "raw_value"] }
+sha2 = { version = "0.10", features = ["oid"] }
 smallvec = { version = "1", default-features = false, features = ["const_new"] }
+spki = { version = "0.7", default-features = false, features = ["pem"] }
+subtle = { version = "2" }
 syn = { version = "2", features = ["extra-traits", "fold", "full", "visit", "visit-mut"] }
+time = { version = "0.3", features = ["formatting", "local-offset", "macros", "parsing"] }
 tokio = { version = "1", features = ["full"] }
+tokio-util = { version = "0.7", features = ["codec", "io"] }
+toml = { version = "0.8", features = ["preserve_order"] }
 tracing = { version = "0.1", features = ["log"] }
+tracing-core = { version = "0.1" }
+zeroize = { version = "1", features = ["derive", "serde"] }
 
 [build-dependencies]
 data-encoding = { version = "2" }
-proc-macro2 = { version = "1" }
+diesel_derives = { version = "2", features = ["32-column-tables", "chrono", "postgres", "sqlite", "with-deprecated"] }
+either = { version = "1", features = ["use_std"] }
+hashbrown = { version = "0.15", features = ["serde"] }
+proc-macro2 = { version = "1", features = ["span-locations"] }
 quote = { version = "1" }
+serde = { version = "1", features = ["alloc", "derive"] }
 syn = { version = "2", features = ["extra-traits", "fold", "full", "visit", "visit-mut"] }
+toml = { version = "0.8", features = ["preserve_order"] }
 
 ### END HAKARI SECTION

flake.lock

···
     "advisory-db": {
       "flake": false,
       "locked": {
-        "lastModified": 1744288177,
-        "narHash": "sha256-HxYhdWc6YJ8Q8gOZtv7+teCucmDf6+Ntickvb62Au58=",
+        "lastModified": 1747489415,
+        "narHash": "sha256-CLQVUrdiRhJx0JppNZxx8FhgUbcliQUIYVI9Aclk39g=",
         "owner": "rustsec",
         "repo": "advisory-db",
-        "rev": "1273f0099ce6882659ff64b852c8fdb5f8cdd5b9",
+        "rev": "f16bc6329058299fb558e8f78eb3b065a4d14ea5",
         "type": "github"
       },
       "original": {
···
     },
     "crane": {
       "locked": {
-        "lastModified": 1745022865,
-        "narHash": "sha256-tXL4qUlyYZEGOHUKUWjmmcvJjjLQ+4U38lPWSc8Cgdo=",
+        "lastModified": 1747587869,
+        "narHash": "sha256-Zay3WJdSvC2VQmNqWSVLBOg/1iS/0/Q0c9JOBsB+3qw=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "25ca4c50039d91ad88cc0b8feacb9ad7f748dedf",
+        "rev": "76603d32f18e0e378d9f6335c8fc286413493655",
         "type": "github"
       },
       "original": {
···
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1744868846,
-        "narHash": "sha256-5RJTdUHDmj12Qsv7XOhuospjAjATNiTMElplWnJE9Hs=",
+        "lastModified": 1747467164,
+        "narHash": "sha256-JBXbjJ0t6T6BbVc9iPVquQI9XSXCGQJD8c8SgnUquus=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "ebe4301cbd8f81c4f8d3244b3632338bbeb6d49c",
+        "rev": "3fcbdcfc707e0aa42c541b7743e05820472bdaec",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1744536153,
+        "narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11",
         "type": "github"
       },
       "original": {
···
     },
     "rust-overlay": {
       "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
+        "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1745375696,
-        "narHash": "sha256-zFRCHNRJ1Ei8GD3iP+wcedkJzLo84OO7JEu/gmhSllU=",
+        "lastModified": 1747535902,
+        "narHash": "sha256-rKWBtLcqQeu8PpfKIBn1ORXS2udSH/MwnQFwfSpFOLg=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "19d1b5002d43c019880dd5cc0f8420efd20d5faf",
+        "rev": "b7a99615d26b82c39b73ccc9026545c3f3403b71",
         "type": "github"
       },
       "original": {

flake.nix

···
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-
-    crane.url = "github:ipetkov/crane";
-
     flake-utils.url = "github:numtide/flake-utils";
 
     advisory-db = {
       url = "github:rustsec/advisory-db";
       flake = false;
     };
-    rust-overlay = {
-      url = "github:oxalica/rust-overlay";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
+
+    rust-overlay.url = "github:oxalica/rust-overlay";
+    crane.url = "github:ipetkov/crane";
   };
+
 
   outputs = {
     self,
···
       inherit (pkgs) lib;
 
       rustToolchainFor = p:
-        p.rust-bin.stable.latest.default.override {
+        p.rust-bin.selectLatestNightlyWith(toolchain: toolchain.default.override {
           # Set the build targets supported by the toolchain,
           # wasm32-unknown-unknown is required for trunk.
-          targets = ["wasm32-unknown-unknown"];
-          extensions = ["llvm-tools"];
-        };
+          #targets = ["wasm32-unknown-unknown"];
+          extensions = [
+            "llvm-tools"
+            "rust-src"
+            "rust-analyzer"
+            "clippy"
+          ];
+        });
       craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchainFor;
-      # When filtering sources, we want to allow assets other than .rs files
-      unfilteredRoot = ./.; # The original, unfiltered source
-      src = lib.fileset.toSource {
-        root = unfilteredRoot;
-        fileset = lib.fileset.unions [
-          # Default files from crane (Rust and cargo files)
-          (craneLib.fileset.commonCargoSources unfilteredRoot)
-          (
-            lib.fileset.fileFilter
-            (file: lib.any file.hasExt ["html" "scss"])
-            unfilteredRoot
-          )
-          # Example of a folder for images, icons, etc
-          (lib.fileset.maybeMissing ./assets)
-        ];
-      };
+      src = craneLib.cleanCargoSource ./.;
 
       # Common arguments can be set here to avoid repeating them later
       commonArgs = {
···
         # Additional environment variables can be set directly
         # MY_CUSTOM_VAR = "some value";
       };
-
-      # Wasm packages
-
-      # it's not possible to build the server on the
-      # wasm32 target, so we only build the client.
-      wasmArgs =
-        commonArgs
-        // {
-          pname = "trunk-workspace-wasm";
-          cargoExtraArgs = "--package=client";
-          CARGO_BUILD_TARGET = "wasm32-unknown-unknown";
-        };
-
-      cargoArtifactsWasm = craneLib.buildDepsOnly (wasmArgs
-        // {
-          doCheck = false;
-        });
-
-      # craneLibLLvmTools = craneLib.overrideToolchain
-      #   (fenix.packages.${system}.complete.withComponents [
-      #     "cargo"
-      #     "llvm-tools"
-      #     "rustc"
-      #   ]);
 
       # Build *just* the cargo dependencies (of the entire workspace),
       # so we can reuse all of that work (e.g. via cachix) when running in CI
···
 
           nativeBuildInputs = with pkgs; [
             cargo-hakari
-            sqlite
-            pkg-config
-            openssl
           ];
         };
       };
···
           alejandra
           diesel-cli
           postgresql
-          cargo-watch
           jq
         ];
       };

lexicons/sh/weaver/actor/defs.json

···
         "labels": {
           "type": "array",
           "items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+        },
+        "pronouns": {
+          "type": "ref",
+          "description": "Pronouns to use in user-generated content.",
+          "ref": "sh.weaver.actor.profile#pronounsList"
+        }
+      }
+    },
+    "profileDataView": {
+      "type": "object",
+      "required": ["inner"],
+      "properties": {
+        "inner": {
+          "type": "union",
+          "refs": ["sh.weaver.actor.defs#profileView", "app.bsky.actor.defs#profileViewDetailed"]
+        }
+      }
+    },
+    "tangledProfileView": {
+      "type": "object",
+      "required": ["bluesky", "did", "handle"],
+      "properties": {
+        "did": { "type": "string", "format": "did" },
+        "handle": { "type": "string", "format": "handle" },
+        "description": {
+          "type": "string",
+          "description": "Free-form profile description text.",
+          "maxGraphemes": 256,
+          "maxLength": 2560
+        },
+        "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"
+          }
+        },
+        "stats": {
+          "type": "array",
+          "minLength": 0,
+          "maxLength": 2,
+          "items": {
+            "type": "string",
+            "description": "Vanity stats.",
+            "enum": [
+              "merged-pull-request-count",
+              "closed-pull-request-count",
+              "open-pull-request-count",
+              "open-issue-count",
+              "closed-issue-count",
+              "repository-count"
+            ]
+          }
+        },
+        "bluesky": {
+          "type": "boolean",
+          "description": "Include link to this account on Bluesky."
+        },
+        "location": {
+          "type": "string",
+          "description": "Free-form location text.",
+          "maxGraphemes": 40,
+          "maxLength": 400
+        },
+        "pinnedRepositories": {
+          "type": "array",
+          "description": "Any ATURI, it is up to appviews to validate these fields.",
+          "minLength": 0,
+          "maxLength": 6,
+          "items": {
+            "type": "string",
+            "format": "at-uri"
+          }
         }
       }
     }

lexicons/sh/weaver/actor/getProfile.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.actor.getProfile",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth.",
+      "parameters": {
+        "type": "params",
+        "required": ["actor"],
+        "properties": {
+          "actor": {
+            "type": "string",
+            "format": "at-identifier",
+            "description": "Handle or DID of account to fetch profile of."
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "sh.weaver.actor.defs#profileDataView"
+        }
+      }
+    }
+  }
+}