atproto preprocessor and renderer

Cargo.lock

···
  "jacquard",
  "jacquard-api",
  "kdl",
+ "markdown-weaver",
+ "markdown-weaver-escape",
  "miette 7.6.0",
+ "n0-future",
  "tokio",
+ "weaver-api",
  "weaver-common",
  "weaver-renderer",
 ]
···
  "http",
  "ignore",
  "insta",
+ "jacquard",
  "markdown-weaver",
  "markdown-weaver-escape",
  "miette 7.6.0",
+ "mime-sniffer",
  "n0-future",
  "pin-project",
  "pin-utils",

crates/weaver-cli/Cargo.toml

···
 clap = { version = "4.5", features = ["derive", "env", "cargo", "unicode"] }
 weaver-common = { path = "../weaver-common", features = ["native"] }
 weaver-renderer = { path = "../weaver-renderer" }
+weaver-api = { path = "../weaver-api" }
 miette = { workspace = true, features = ["fancy"] }
 
 jacquard = { workspace = true, features = ["loopback", "dns"] }
 jacquard-api = { workspace = true, features = ["sh_weaver"] }
+
+markdown-weaver = { workspace = true }
+markdown-weaver-escape = { workspace = true }
+n0-future = { workspace = true }
 
 tokio = { version = "1.45.0", features = ["full"] }
 dirs = "6.0.0"

crates/weaver-cli/src/main.rs

···
 use jacquard::identity::JacquardResolver;
 use jacquard::oauth::client::{OAuthClient, OAuthSession};
 use jacquard::oauth::loopback::LoopbackConfig;
-use jacquard::prelude::XrpcClient;
-use jacquard::types::ident::AtIdentifier;
-use jacquard::types::string::CowStr;
-use jacquard_api::app_bsky::actor::get_profile::GetProfile;
+use jacquard::prelude::*;
+use jacquard::types::string::Handle;
+use jacquard::IntoStatic;
 use miette::{IntoDiagnostic, Result};
+use std::io::BufRead;
 use std::path::PathBuf;
+use std::sync::Arc;
 use weaver_renderer::static_site::StaticSiteWriter;
+use weaver_renderer::walker::{WalkOptions, vault_contents};
+use weaver_renderer::atproto::AtProtoPreprocessContext;
+use weaver_renderer::utils::VaultBrokenLinkCallback;
 
 use clap::{Parser, Subcommand};
 
···
         #[arg(long)]
         store: Option<PathBuf>,
     },
+    /// Publish notebook to AT Protocol
+    Publish {
+        /// Path to notebook directory
+        source: PathBuf,
+
+        /// Notebook title
+        #[arg(long)]
+        title: String,
+
+        /// Path to auth store file
+        #[arg(long)]
+        store: Option<PathBuf>,
+    },
 }
 
 #[tokio::main]
···
         Some(Commands::Auth { handle, store }) => {
             let store_path = store.unwrap_or_else(default_auth_store_path);
             authenticate(handle, store_path).await?;
+        }
+        Some(Commands::Publish { source, title, store }) => {
+            let store_path = store.unwrap_or_else(default_auth_store_path);
+            publish_notebook(source, title, store_path).await?;
         }
         None => {
             // Render command (default)
···
         .join("auth.json")
 }
 
+async fn publish_notebook(source: PathBuf, title: String, store_path: PathBuf) -> Result<()> {
+    println!("Publishing notebook from: {}", source.display());
+    println!("Title: {}", title);
+
+    // Validate source exists
+    if !source.exists() {
+        return Err(miette::miette!(
+            "Source directory not found: {}",
+            source.display()
+        ));
+    }
+
+    // Try to load session, trigger auth if needed
+    let session = match try_load_session(&store_path).await {
+        Some(session) => {
+            println!("✓ Authenticated");
+            session
+        }
+        None => {
+            println!("⚠ No authentication found");
+            println!("Please enter your handle to authenticate:");
+
+            let mut handle = String::new();
+            let stdin = std::io::stdin();
+            stdin.lock().read_line(&mut handle).into_diagnostic()?;
+            let handle = handle.trim().to_string();
+
+            authenticate(handle, store_path.clone()).await?;
+
+            // Load the session we just created
+            try_load_session(&store_path).await
+                .ok_or_else(|| miette::miette!("Failed to load session after authentication"))?
+        }
+    };
+
+    // Get user DID and handle from session
+
+    // Create agent and resolve DID document to get handle
+    let agent = Agent::new(session);
+    let (did, _session_id) = agent.info().await
+        .ok_or_else(|| miette::miette!("No session info available"))?;
+    let did_doc_response = agent.resolve_did_doc(&did).await?;
+    let did_doc = did_doc_response.parse()?;
+
+    // Extract handle from alsoKnownAs
+    let aka_vec = did_doc
+        .also_known_as
+        .ok_or_else(|| miette::miette!("No alsoKnownAs in DID document"))?;
+    let handle_str = aka_vec
+        .get(0)
+        .and_then(|aka| aka.as_ref().strip_prefix("at://"))
+        .ok_or_else(|| miette::miette!("No handle found in DID document"))?;
+    let handle = Handle::new(handle_str)?;
+
+    println!("Publishing as @{}", handle.as_ref());
+
+    // Walk vault directory
+    println!("→ Scanning vault...");
+    let contents = vault_contents(&source, WalkOptions::new())?;
+
+    // Convert to Arc first
+    let agent = Arc::new(agent);
+    let vault_arc: Arc<[PathBuf]> = contents.into();
+
+    // Filter markdown files after converting to Arc
+    let md_files: Vec<PathBuf> = vault_arc
+        .iter()
+        .filter(|path| {
+            path.extension()
+                .and_then(|ext| ext.to_str())
+                .map(|ext| ext == "md" || ext == "markdown")
+                .unwrap_or(false)
+        })
+        .cloned()
+        .collect();
+
+    println!("Found {} markdown files", md_files.len());
+
+    // Create preprocessing context
+    let context = AtProtoPreprocessContext::new(
+        vault_arc.clone(),
+        title.clone(),
+        agent.clone(),
+    ).with_creator(did.clone().into_static(), handle.clone().into_static());
+
+    // Process each file
+    for file_path in &md_files {
+        println!("Processing: {}", file_path.display());
+
+        // Read file content
+        let contents = tokio::fs::read_to_string(&file_path)
+            .await
+            .into_diagnostic()?;
+
+        // Clone context for this file
+        let mut file_context = context.clone();
+        file_context.set_current_path(file_path.clone());
+        let callback = Some(VaultBrokenLinkCallback {
+            vault_contents: vault_arc.clone(),
+        });
+
+        // Parse markdown
+        use weaver_renderer::default_md_options;
+        use markdown_weaver::Parser;
+        let parser = Parser::new_with_broken_link_callback(&contents, default_md_options(), callback);
+        let iterator = weaver_renderer::ContextIterator::default(parser);
+
+        // Process through NotebookProcessor
+        use weaver_renderer::{NotebookProcessor, NotebookContext};
+        use n0_future::StreamExt;
+        let mut processor = NotebookProcessor::new(file_context.clone(), iterator);
+
+        // Write canonical markdown with MarkdownWriter
+        use markdown_weaver_escape::FmtWriter;
+        use weaver_renderer::atproto::MarkdownWriter;
+        let mut output = String::new();
+        let mut md_writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        // Process all events
+        while let Some(event) = processor.next().await {
+            md_writer.write_event(event).map_err(|e| {
+                miette::miette!("Failed to write markdown: {:?}", e)
+            })?;
+        }
+
+        // Extract blobs and entry metadata
+        let blobs = file_context.blobs();
+        let entry_title = file_context.entry_title();
+
+        // Build Entry record with blobs
+        use weaver_api::sh_weaver::notebook::entry::{Entry, EntryEmbeds};
+        use weaver_api::sh_weaver::embed::images::{Images, Image};
+        use jacquard::types::string::Datetime;
+        use jacquard::types::blob::BlobRef;
+
+        let embeds = if !blobs.is_empty() {
+            // Build images from blobs
+            let images: Vec<Image> = blobs
+                .iter()
+                .map(|blob_info| {
+                    Image::new()
+                        .image(BlobRef::Blob(blob_info.blob.clone()))
+                        .alt(blob_info.alt.as_ref().map(|a| a.as_ref()).unwrap_or(""))
+                        .maybe_name(Some(blob_info.name.as_str().into()))
+                        .build()
+                })
+                .collect();
+
+            Some(EntryEmbeds {
+                images: Some(Images::new().images(images).build()),
+                externals: None,
+                records: None,
+                records_with_media: None,
+                videos: None,
+                extra_data: None,
+            })
+        } else {
+            None
+        };
+
+        let entry = Entry::new()
+            .content(output.as_str())
+            .title(entry_title.as_ref())
+            .created_at(Datetime::now())
+            .maybe_embeds(embeds)
+            .build();
+
+        // Use WeaverExt to upsert entry (handles notebook + entry creation/updates)
+        use weaver_common::WeaverExt;
+        let (entry_uri, was_created) = (*agent)
+            .upsert_entry(&title, entry_title.as_ref(), entry)
+            .await?;
+
+        if was_created {
+            println!("  ✓ Created new entry: {}", entry_uri.as_ref());
+        } else {
+            println!("  ✓ Updated existing entry: {}", entry_uri.as_ref());
+        }
+    }
+
+    println!("✓ Published {} entries", md_files.len());
+
+    Ok(())
+}
+
 fn init_miette() {
     miette::set_hook(Box::new(|_| {
         Box::new(
             miette::MietteHandlerOpts::new()
                 .terminal_links(true)
                 .with_cause_chain()
-                .with_syntax_highlighting(miette::highlighters::SyntectHighlighter::default())
                 .color(true)
                 .context_lines(5)
                 .tab_width(2)

crates/weaver-common/src/lib.rs

···
 use jacquard::bytes::Bytes;
 use jacquard::client::{Agent, AgentError, AgentErrorKind, AgentSession, AgentSessionExt};
 use jacquard::prelude::*;
-use jacquard::smol_str::SmolStr;
 use jacquard::types::blob::{BlobRef, MimeType};
 use jacquard::types::string::{AtUri, Cid, Did, Handle, RecordKey};
 use jacquard::xrpc::Response;
···
 use tokio::sync::Mutex;
 use weaver_api::com_atproto::repo::get_record::GetRecordResponse;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
-use weaver_api::sh_weaver::notebook::{book, chapter, entry};
+use weaver_api::sh_weaver::notebook::entry;
 use weaver_api::sh_weaver::publish::blob::Blob as PublishedBlob;
-
-use crate::error::ParseError;
 
 static W_TICKER: LazyLock<Mutex<Ticker>> = LazyLock::new(|| Mutex::new(Ticker::new()));
 
···
         &self,
         uri: &AtUri<'_>,
     ) -> impl Future<Output = Result<StrongRef<'_>, WeaverError>>;
+
+    /// Find or create a notebook by title, returning its URI and entry list
+    ///
+    /// If the notebook doesn't exist, creates it with the given DID as author.
+    fn upsert_notebook(
+        &self,
+        title: &str,
+        author_did: &Did<'_>,
+    ) -> impl Future<Output = Result<(AtUri<'static>, Vec<StrongRef<'static>>), WeaverError>>;
+
+    /// Find or create an entry within a notebook by title
+    ///
+    /// Multi-step workflow:
+    /// 1. Find the notebook by title
+    /// 2. Check notebook's entry_list for entry with matching title
+    /// 3. If found: update the entry with new content
+    /// 4. If not found: create new entry and append to notebook's entry_list
+    ///
+    /// Returns (entry_uri, was_created)
+    fn upsert_entry(
+        &self,
+        notebook_title: &str,
+        entry_title: &str,
+        entry: entry::Entry<'_>,
+    ) -> impl Future<Output = Result<(AtUri<'static>, bool), WeaverError>>;
+
+    /// View functions - generic versions that work with any Agent
+
+    /// Fetch a notebook and construct NotebookView with author profiles
+    fn view_notebook(
+        &self,
+        uri: &AtUri<'_>,
+    ) -> impl Future<Output = Result<(view::NotebookView<'static>, Vec<StrongRef<'static>>), WeaverError>>;
+
+    /// Fetch an entry and construct EntryView
+    fn fetch_entry_view<'a>(
+        &self,
+        notebook: &view::NotebookView<'a>,
+        entry_ref: &StrongRef<'_>,
+    ) -> impl Future<Output = Result<view::EntryView<'a>, WeaverError>>;
+
+    /// Search for an entry by title within a notebook's entry list
+    fn entry_by_title<'a>(
+        &self,
+        notebook: &view::NotebookView<'a>,
+        entries: &[StrongRef<'_>],
+        title: &str,
+    ) -> impl Future<Output = Result<Option<(view::BookEntryView<'a>, entry::Entry<'a>)>, WeaverError>>;
+
+    /// Search for a notebook by title for a given DID or handle
+    fn notebook_by_title(
+        &self,
+        ident: &jacquard::types::ident::AtIdentifier<'_>,
+        title: &str,
+    ) -> impl Future<Output = Result<Option<(view::NotebookView<'static>, Vec<StrongRef<'static>>)>, WeaverError>>;
 }
 
 impl<A: AgentSession + IdentityResolver> WeaverExt for Agent<A> {
···
         let strong_ref = StrongRef::new().uri(record.uri).cid(record.cid).build();
 
         Ok((strong_ref, publish_record))
+    }
+
+    async fn upsert_notebook(
+        &self,
+        title: &str,
+        author_did: &Did<'_>,
+    ) -> Result<(AtUri<'static>, Vec<StrongRef<'static>>), WeaverError> {
+        use jacquard::types::collection::Collection;
+        use jacquard::types::nsid::Nsid;
+        use jacquard::xrpc::XrpcExt;
+        use weaver_api::com_atproto::repo::list_records::ListRecords;
+        use weaver_api::sh_weaver::notebook::book::Book;
+
+        // Find the PDS for this DID
+        let pds_url = self.pds_for_did(author_did).await.map_err(|e| {
+            AgentError::from(ClientError::from(e).with_context("Failed to resolve PDS for DID"))
+        })?;
+
+        // Search for existing notebook with this title
+        let resp = self
+            .xrpc(pds_url)
+            .send(
+                &ListRecords::new()
+                    .repo(author_did.clone())
+                    .collection(Nsid::raw(Book::NSID))
+                    .limit(100)
+                    .build(),
+            )
+            .await
+            .map_err(|e| AgentError::from(ClientError::from(e)))?;
+
+        if let Ok(list) = resp.parse() {
+            for record in list.records {
+                let notebook: Book = jacquard::from_data(&record.value).map_err(|_| {
+                    AgentError::from(ClientError::invalid_request("Failed to parse notebook record"))
+                })?;
+                if let Some(book_title) = notebook.title
+                    && book_title == title
+                {
+                    let entries = notebook
+                        .entry_list
+                        .iter()
+                        .cloned()
+                        .map(IntoStatic::into_static)
+                        .collect();
+                    return Ok((record.uri.into_static(), entries));
+                }
+            }
+        }
+
+        // Notebook doesn't exist, create it
+        use weaver_api::sh_weaver::actor::Author;
+        let author = Author::new().did(author_did.clone()).build();
+        let book = Book::new()
+            .authors(vec![author])
+            .entry_list(vec![])
+            .maybe_title(Some(title.into()))
+            .maybe_created_at(Some(jacquard::types::string::Datetime::now()))
+            .build();
+
+        let response = self.create_record(book, None).await?;
+        Ok((response.uri, Vec::new()))
+    }
+
+    async fn upsert_entry(
+        &self,
+        notebook_title: &str,
+        entry_title: &str,
+        entry: entry::Entry<'_>,
+    ) -> Result<(AtUri<'static>, bool), WeaverError> {
+        // Get our own DID
+        let (did, _) = self.info().await.ok_or_else(|| {
+            AgentError::from(ClientError::invalid_request("No session info available"))
+        })?;
+
+        // Find or create notebook
+        let (notebook_uri, entry_refs) = self.upsert_notebook(notebook_title, &did).await?;
+
+        // Check if entry with this title exists in the notebook
+        for entry_ref in &entry_refs {
+            let existing = self
+                .get_record::<entry::Entry>(&entry_ref.uri)
+                .await
+                .map_err(|e| AgentError::from(ClientError::from(e)))?;
+            if let Ok(existing_entry) = existing.parse() {
+                if existing_entry.value.title == entry_title {
+                    // Update existing entry
+                    self.update_record::<entry::Entry>(&entry_ref.uri, |e| {
+                        e.content = entry.content.clone();
+                        e.embeds = entry.embeds.clone();
+                        e.tags = entry.tags.clone();
+                    })
+                    .await?;
+                    return Ok((entry_ref.uri.clone().into_static(), false));
+                }
+            }
+        }
+
+        // Entry doesn't exist, create it
+        let response = self.create_record(entry, None).await?;
+        let entry_uri = response.uri.clone();
+
+        // Add to notebook's entry_list
+        use weaver_api::sh_weaver::notebook::book::Book;
+        let new_ref = StrongRef::new()
+            .uri(response.uri)
+            .cid(response.cid)
+            .build();
+
+        self.update_record::<Book>(&notebook_uri, |book| {
+            book.entry_list.push(new_ref);
+        })
+        .await?;
+
+        Ok((entry_uri, true))
+    }
+
+    async fn view_notebook(
+        &self,
+        uri: &AtUri<'_>,
+    ) -> Result<(view::NotebookView<'static>, Vec<StrongRef<'static>>), WeaverError> {
+        use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+        use weaver_api::sh_weaver::notebook::book::Book;
+        use weaver_api::sh_weaver::notebook::AuthorListView;
+        use jacquard::to_data;
+
+        let notebook = self
+            .get_record::<Book>(uri)
+            .await
+            .map_err(|e| AgentError::from(e))?
+            .into_output()
+            .map_err(|_| {
+                AgentError::from(ClientError::invalid_request("Failed to parse Book record"))
+            })?;
+
+        let title = notebook.value.title.clone();
+        let tags = notebook.value.tags.clone();
+
+        let mut authors = Vec::new();
+
+        for (index, author) in notebook.value.authors.iter().enumerate() {
+            let author_uri = BskyProfile::uri(format!("at://{}/app.bsky.actor.profile/self", author.did))
+                .map_err(|_| AgentError::from(ClientError::invalid_request("Invalid author profile URI")))?;
+            let author_profile = self.fetch_record(&author_uri).await?;
+
+            authors.push(
+                AuthorListView::new()
+                    .uri(author_uri.as_uri().clone())
+                    .record(to_data(&author_profile).map_err(|_| {
+                        AgentError::from(ClientError::invalid_request("Failed to serialize author profile"))
+                    })?)
+                    .index(index as i64)
+                    .build(),
+            );
+        }
+        let entries = notebook
+            .value
+            .entry_list
+            .iter()
+            .cloned()
+            .map(IntoStatic::into_static)
+            .collect();
+
+        Ok((
+            view::NotebookView::new()
+                .cid(notebook.cid.ok_or_else(|| {
+                    AgentError::from(ClientError::invalid_request("Notebook missing CID"))
+                })?)
+                .uri(notebook.uri)
+                .indexed_at(jacquard::types::string::Datetime::now())
+                .maybe_title(title)
+                .maybe_tags(tags)
+                .authors(authors)
+                .record(to_data(&notebook.value).map_err(|_| {
+                    AgentError::from(ClientError::invalid_request("Failed to serialize notebook"))
+                })?)
+                .build(),
+            entries,
+        ))
+    }
+
+    async fn fetch_entry_view<'a>(
+        &self,
+        notebook: &view::NotebookView<'a>,
+        entry_ref: &StrongRef<'_>,
+    ) -> Result<view::EntryView<'a>, WeaverError> {
+        use weaver_api::sh_weaver::notebook::entry::Entry;
+        use jacquard::to_data;
+
+        let entry_uri = Entry::uri(entry_ref.uri.clone())
+            .map_err(|_| AgentError::from(ClientError::invalid_request("Invalid entry URI")))?;
+        let entry = self.fetch_record(&entry_uri).await?;
+
+        let title = entry.value.title.clone();
+        let tags = entry.value.tags.clone();
+
+        Ok(view::EntryView::new()
+            .cid(entry.cid.ok_or_else(|| {
+                AgentError::from(ClientError::invalid_request("Entry missing CID"))
+            })?)
+            .uri(entry.uri)
+            .indexed_at(jacquard::types::string::Datetime::now())
+            .record(to_data(&entry.value).map_err(|_| {
+                AgentError::from(ClientError::invalid_request("Failed to serialize entry"))
+            })?)
+            .maybe_tags(tags)
+            .title(title)
+            .authors(notebook.authors.clone())
+            .build())
+    }
+
+    async fn entry_by_title<'a>(
+        &self,
+        notebook: &view::NotebookView<'a>,
+        entries: &[StrongRef<'_>],
+        title: &str,
+    ) -> Result<Option<(view::BookEntryView<'a>, entry::Entry<'a>)>, WeaverError> {
+        use weaver_api::sh_weaver::notebook::entry::Entry;
+        use weaver_api::sh_weaver::notebook::BookEntryRef;
+
+        for (index, entry_ref) in entries.iter().enumerate() {
+            let resp = self
+                .get_record::<Entry>(&entry_ref.uri)
+                .await
+                .map_err(|e| AgentError::from(e))?;
+            if let Ok(entry) = resp.parse() {
+                if entry.value.title == title {
+                    // Build BookEntryView with prev/next
+                    let entry_view = self.fetch_entry_view(notebook, entry_ref).await?;
+
+                    let prev_entry = if index > 0 {
+                        let prev_entry_ref = &entries[index - 1];
+                        self.fetch_entry_view(notebook, prev_entry_ref).await.ok()
+                    } else {
+                        None
+                    }
+                    .map(|e| BookEntryRef::new().entry(e).build());
+
+                    let next_entry = if index < entries.len() - 1 {
+                        let next_entry_ref = &entries[index + 1];
+                        self.fetch_entry_view(notebook, next_entry_ref).await.ok()
+                    } else {
+                        None
+                    }
+                    .map(|e| BookEntryRef::new().entry(e).build());
+
+                    let book_entry_view = view::BookEntryView::new()
+                        .entry(entry_view)
+                        .maybe_next(next_entry)
+                        .maybe_prev(prev_entry)
+                        .index(index as i64)
+                        .build();
+
+                    return Ok(Some((book_entry_view, entry.value.into_static())));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    async fn notebook_by_title(
+        &self,
+        ident: &jacquard::types::ident::AtIdentifier<'_>,
+        title: &str,
+    ) -> Result<Option<(view::NotebookView<'static>, Vec<StrongRef<'static>>)>, WeaverError> {
+        use jacquard::types::collection::Collection;
+        use jacquard::types::nsid::Nsid;
+        use jacquard::xrpc::XrpcExt;
+        use weaver_api::com_atproto::repo::list_records::ListRecords;
+        use weaver_api::sh_weaver::notebook::book::Book;
+        use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+        use weaver_api::sh_weaver::notebook::AuthorListView;
+        use jacquard::to_data;
+
+        let (repo_did, pds_url) = match ident {
+            jacquard::types::ident::AtIdentifier::Did(did) => {
+                let pds = self.pds_for_did(did).await.map_err(|e| {
+                    AgentError::from(ClientError::from(e).with_context("Failed to resolve PDS for DID"))
+                })?;
+                (did.clone(), pds)
+            }
+            jacquard::types::ident::AtIdentifier::Handle(handle) => self.pds_for_handle(handle).await.map_err(|e| {
+                AgentError::from(ClientError::from(e).with_context("Failed to resolve handle"))
+            })?,
+        };
+
+        // TODO: use the cursor to search through all records with this NSID for the repo
+        let resp = self
+            .xrpc(pds_url)
+            .send(
+                &ListRecords::new()
+                    .repo(repo_did)
+                    .collection(Nsid::raw(Book::NSID))
+                    .limit(100)
+                    .build(),
+            )
+            .await
+            .map_err(|e| AgentError::from(ClientError::from(e)))?;
+
+        if let Ok(list) = resp.parse() {
+            for record in list.records {
+                let notebook: Book = jacquard::from_data(&record.value).map_err(|_| {
+                    AgentError::from(ClientError::invalid_request("Failed to parse notebook record"))
+                })?;
+                if let Some(book_title) = notebook.title
+                    && book_title == title
+                {
+                    let tags = notebook.tags.clone();
+
+                    let mut authors = Vec::new();
+
+                    for (index, author) in notebook.authors.iter().enumerate() {
+                        let author_uri = BskyProfile::uri(format!(
+                            "at://{}/app.bsky.actor.profile/self",
+                            author.did
+                        ))
+                        .map_err(|_| AgentError::from(ClientError::invalid_request("Invalid author profile URI")))?;
+                        let author_profile = self.fetch_record(&author_uri).await?;
+
+                        authors.push(
+                            AuthorListView::new()
+                                .uri(author_uri.as_uri().clone())
+                                .record(to_data(&author_profile).map_err(|_| {
+                                    AgentError::from(ClientError::invalid_request("Failed to serialize author profile"))
+                                })?)
+                                .index(index as i64)
+                                .build(),
+                        );
+                    }
+                    let entries = notebook
+                        .entry_list
+                        .iter()
+                        .cloned()
+                        .map(IntoStatic::into_static)
+                        .collect();
+
+                    return Ok(Some((
+                        view::NotebookView::new()
+                            .cid(record.cid)
+                            .uri(record.uri)
+                            .indexed_at(jacquard::types::string::Datetime::now())
+                            .title(book_title)
+                            .maybe_tags(tags)
+                            .authors(authors)
+                            .record(record.value.clone())
+                            .build()
+                            .into_static(),
+                        entries,
+                    )));
+                }
+            }
+        }
+
+        Ok(None)
     }
 
     async fn confirm_record_ref(&self, uri: &AtUri<'_>) -> Result<StrongRef<'_>, WeaverError> {

crates/weaver-common/src/view.rs

···
     prelude::IdentityResolver,
     to_data,
     types::{
-        aturi::AtUri, collection::Collection, did::Did, ident::AtIdentifier, nsid::Nsid,
+        aturi::AtUri, collection::Collection, ident::AtIdentifier, nsid::Nsid,
         string::Datetime,
     },
     xrpc::XrpcExt,
···
 use weaver_api::{
     app_bsky::actor::profile::Profile as BskyProfile,
     com_atproto::repo::{list_records::ListRecords, strong_ref::StrongRef},
-    sh_weaver::notebook::{
-        AuthorListView, BookEntryRef, BookEntryView, EntryView, NotebookView, book::Book,
-        entry::Entry, page::Page,
-    },
+    sh_weaver::notebook::{book::Book, entry::Entry, page::Page},
+};
+
+// Re-export view types for use elsewhere
+pub use weaver_api::sh_weaver::notebook::{
+    AuthorListView, BookEntryRef, BookEntryView, EntryView, NotebookView,
 };
 
 pub async fn view_notebook(

crates/weaver-renderer/Cargo.toml

···
 n0-future.workspace = true
 weaver-common = { path = "../weaver-common" }
 weaver-api = { path = "../weaver-api" }
+jacquard.workspace = true
 markdown-weaver = { workspace = true }
 compact_string = "0.1.0"
 http = "1.3.1"
···
 pin-project = "1.1.10"
 dynosaur = "0.2.0"
 smol_str = { version = "0.3", features = ["serde"] }
+mime-sniffer = "0.1.3"
 reqwest = { version = "0.12.7", default-features = false, features = [
     "json",
     "rustls-tls",

crates/weaver-renderer/src/atproto.rs

···
-//! Atproto renderer
-//!
-//! This mode of the renderer renders either an entire notebook or entries in it to files suitable for inclusion
-//! in a single-page app and uploads them to your Atproto PDS
-//! It can be accessed via the appview at {your-handle}.weaver.sh/{notebook-name}.
-//!
-//! It can also be edited there.
-//!
-//! Link altering logic:
-//!  - Option 1: leave (non-embed) links the same as in the markdown, have the CSM deal with them via some means
-//!    such as adding "data-did" and "data-cid" attributes to the `<a/>` tag containing the DID and CID
-//!    Pushes toward having the SPA/Appview do a bit more, but makes this step MUCH simpler
-//!     - In this scenario, the rendering step can happen upon access (and then be cached) in the appview
-//!     - More flexible in some ways, less in others
-//!  - Option 2: alter links to point to other rendered blobs. Requires a certain amount of work to handle
-//!    scenarios with a complex mesh of internal links, as the CID is altered by the editing of the link.
-//!    Such cycles are handled in the simplest way, by rendering an absolute url which will make a call to the appview.
+//! AT Protocol renderer for weaver notebooks
 //!
+//! Two-stage pipeline: markdown→markdown preprocessing (CLI),
+//! then client-side markdown→HTML rendering (WASM).
+
+mod error;
+mod types;
+mod markdown_writer;
+mod preprocess;
+mod client;
+mod embed_renderer;
+mod writer;
+
+pub use error::{AtProtoPreprocessError, ClientRenderError};
+pub use types::{BlobName, BlobInfo};
+pub use preprocess::AtProtoPreprocessContext;
+pub use client::{ClientContext, EmbedResolver, DefaultEmbedResolver};
+pub use markdown_writer::MarkdownWriter;
+pub use embed_renderer::{fetch_and_render_profile, fetch_and_render_post, fetch_and_render_generic};
+pub use writer::{ClientWriter, EmbedContentProvider};

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

···
+use crate::{Frontmatter, NotebookContext};
+use super::{types::BlobName, error::ClientRenderError};
+use jacquard::{
+    client::{Agent, AgentSession},
+    prelude::IdentityResolver,
+    types::string::{AtUri, Cid, Did},
+};
+use markdown_weaver::{Tag, CowStr as MdCowStr, WeaverAttributes};
+use std::collections::HashMap;
+use std::sync::Arc;
+use weaver_api::sh_weaver::notebook::entry::Entry;
+
+/// Trait for resolving embed content on the client side
+///
+/// Implementations can fetch from cache, make HTTP requests, or use other sources.
+pub trait EmbedResolver: Send + Sync {
+    /// Resolve a profile embed by AT URI
+    fn resolve_profile(
+        &self,
+        uri: &AtUri<'_>,
+    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>> + Send;
+
+    /// Resolve a post/record embed by AT URI
+    fn resolve_post(
+        &self,
+        uri: &AtUri<'_>,
+    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>> + Send;
+
+    /// Resolve a markdown embed from URL
+    ///
+    /// `depth` parameter tracks recursion depth to prevent infinite loops
+    fn resolve_markdown(
+        &self,
+        url: &str,
+        depth: usize,
+    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>> + Send;
+}
+
+/// Default embed resolver that fetches records from PDSs
+///
+/// This uses the same fetch/render logic as the preprocessor.
+pub struct DefaultEmbedResolver<A: AgentSession + IdentityResolver> {
+    agent: Arc<Agent<A>>,
+}
+
+impl<A: AgentSession + IdentityResolver> DefaultEmbedResolver<A> {
+    pub fn new(agent: Arc<Agent<A>>) -> Self {
+        Self { agent }
+    }
+}
+
+impl<A: AgentSession + IdentityResolver> EmbedResolver for DefaultEmbedResolver<A> {
+    async fn resolve_profile(&self, uri: &AtUri<'_>) -> Result<String, ClientRenderError> {
+        use crate::atproto::fetch_and_render_profile;
+        use jacquard::types::ident::AtIdentifier;
+
+        // Extract DID from authority
+        let did = match uri.authority() {
+            AtIdentifier::Did(did) => did,
+            AtIdentifier::Handle(_) => {
+                return Err(ClientRenderError::EntryFetch {
+                    uri: uri.as_ref().to_string(),
+                    source: "Profile URI should use DID not handle".into(),
+                });
+            }
+        };
+
+        fetch_and_render_profile(&did, &*self.agent)
+            .await
+            .map_err(|e| ClientRenderError::EntryFetch {
+                uri: uri.as_ref().to_string(),
+                source: Box::new(e),
+            })
+    }
+
+    async fn resolve_post(&self, uri: &AtUri<'_>) -> Result<String, ClientRenderError> {
+        use crate::atproto::{fetch_and_render_post, fetch_and_render_generic};
+
+        // Check if it's a known type
+        if let Some(collection) = uri.collection() {
+            match collection.as_ref() {
+                "app.bsky.feed.post" => {
+                    fetch_and_render_post(uri, &*self.agent)
+                        .await
+                        .map_err(|e| ClientRenderError::EntryFetch {
+                            uri: uri.as_ref().to_string(),
+                            source: Box::new(e),
+                        })
+                }
+                _ => {
+                    fetch_and_render_generic(uri, &*self.agent)
+                        .await
+                        .map_err(|e| ClientRenderError::EntryFetch {
+                            uri: uri.as_ref().to_string(),
+                            source: Box::new(e),
+                        })
+                }
+            }
+        } else {
+            Err(ClientRenderError::EntryFetch {
+                uri: uri.as_ref().to_string(),
+                source: "AT URI missing collection".into(),
+            })
+        }
+    }
+
+    async fn resolve_markdown(
+        &self,
+        url: &str,
+        _depth: usize,
+    ) -> Result<String, ClientRenderError> {
+        // TODO: implement HTTP fetch + markdown rendering
+        Err(ClientRenderError::EntryFetch {
+            uri: url.to_string(),
+            source: "Markdown URL embeds not yet implemented".into(),
+        })
+    }
+}
+
+const MAX_EMBED_DEPTH: usize = 3;
+
+pub struct ClientContext<'a, R = ()> {
+    // Entry being rendered
+    entry: Entry<'a>,
+    creator_did: Did<'a>,
+
+    // Blob resolution
+    blob_map: HashMap<BlobName<'static>, Cid<'static>>,
+
+    // Embed resolution (optional, generic over resolver type)
+    embed_resolver: Option<Arc<R>>,
+    embed_depth: usize,
+
+    // Shared state
+    frontmatter: Frontmatter,
+    title: MdCowStr<'a>,
+}
+
+impl<'a> ClientContext<'a, ()> {
+    pub fn new(entry: Entry<'a>, creator_did: Did<'a>) -> Self {
+        let blob_map = Self::build_blob_map(&entry);
+        let title = MdCowStr::Boxed(entry.title.as_ref().into());
+
+        Self {
+            entry,
+            creator_did,
+            blob_map,
+            embed_resolver: None,
+            embed_depth: 0,
+            frontmatter: Frontmatter::default(),
+            title,
+        }
+    }
+
+    /// Add an embed resolver for fetching embed content
+    pub fn with_embed_resolver<R: EmbedResolver>(
+        self,
+        resolver: Arc<R>,
+    ) -> ClientContext<'a, R> {
+        ClientContext {
+            entry: self.entry,
+            creator_did: self.creator_did,
+            blob_map: self.blob_map,
+            embed_resolver: Some(resolver),
+            embed_depth: self.embed_depth,
+            frontmatter: self.frontmatter,
+            title: self.title,
+        }
+    }
+}
+
+impl<'a, R> ClientContext<'a, R> {
+    /// Create a child context with incremented embed depth (for recursive embeds)
+    fn with_depth(&self, depth: usize) -> Self
+    where
+        R: Clone,
+    {
+        Self {
+            entry: self.entry.clone(),
+            creator_did: self.creator_did.clone(),
+            blob_map: self.blob_map.clone(),
+            embed_resolver: self.embed_resolver.clone(),
+            embed_depth: depth,
+            frontmatter: self.frontmatter.clone(),
+            title: self.title.clone(),
+        }
+    }
+
+    fn build_blob_map<'b>(entry: &Entry<'b>) -> HashMap<BlobName<'static>, Cid<'static>> {
+        use jacquard::IntoStatic;
+
+        let mut map = HashMap::new();
+        if let Some(embeds) = &entry.embeds {
+            if let Some(images) = &embeds.images {
+                for img in &images.images {
+                    if let Some(name) = &img.name {
+                        let blob_name = BlobName::from_filename(name.as_ref());
+                        map.insert(blob_name, img.image.blob().cid().clone().into_static());
+                    }
+                }
+            }
+        }
+        map
+    }
+
+    pub fn get_blob_cid(&self, name: &str) -> Option<&Cid<'static>> {
+        let blob_name = BlobName::from_filename(name);
+        self.blob_map.get(&blob_name)
+    }
+}
+
+/// Convert an AT URI to a web URL based on collection type
+///
+/// Maps AT Protocol URIs to their web equivalents:
+/// - Profile: `at://did:plc:xyz` → `https://weaver.sh/did:plc:xyz`
+/// - Bluesky post: `at://{actor}/app.bsky.feed.post/{rkey}` → `https://bsky.app/profile/{actor}/post/{rkey}`
+/// - Bluesky list: `at://{actor}/app.bsky.graph.list/{rkey}` → `https://bsky.app/profile/{actor}/lists/{rkey}`
+/// - Bluesky feed: `at://{actor}/app.bsky.feed.generator/{rkey}` → `https://bsky.app/profile/{actor}/feed/{rkey}`
+/// - Bluesky starterpack: `at://{actor}/app.bsky.graph.starterpack/{rkey}` → `https://bsky.app/starter-pack/{actor}/{rkey}`
+/// - Weaver/other: `at://{actor}/{collection}/{rkey}` → `https://weaver.sh/{actor}/{collection}/{rkey}`
+fn at_uri_to_web_url(at_uri: &AtUri<'_>) -> String {
+    let authority = at_uri.authority().as_ref();
+
+    // Profile-only link (no collection/rkey)
+    if at_uri.collection().is_none() && at_uri.rkey().is_none() {
+        return format!("https://weaver.sh/{}", authority);
+    }
+
+    // Record link
+    if let (Some(collection), Some(rkey)) = (at_uri.collection(), at_uri.rkey()) {
+        let collection_str = collection.as_ref();
+        let rkey_str = rkey.as_ref();
+
+        // Map known Bluesky collections to bsky.app URLs
+        match collection_str {
+            "app.bsky.feed.post" => {
+                format!("https://bsky.app/profile/{}/post/{}", authority, rkey_str)
+            }
+            "app.bsky.graph.list" => {
+                format!("https://bsky.app/profile/{}/lists/{}", authority, rkey_str)
+            }
+            "app.bsky.feed.generator" => {
+                format!("https://bsky.app/profile/{}/feed/{}", authority, rkey_str)
+            }
+            "app.bsky.graph.starterpack" => {
+                format!("https://bsky.app/starter-pack/{}/{}", authority, rkey_str)
+            }
+            // Weaver records and unknown collections go to weaver.sh
+            _ => {
+                format!("https://weaver.sh/{}/{}/{}", authority, collection_str, rkey_str)
+            }
+        }
+    } else {
+        // Fallback for malformed URIs
+        format!("https://weaver.sh/{}", authority)
+    }
+}
+
+// Stub NotebookContext implementation
+impl<'a, R> NotebookContext for ClientContext<'a, R>
+where
+    R: EmbedResolver,
+{
+    fn set_entry_title(&self, _title: MdCowStr<'_>) {
+        // No-op for client context
+    }
+
+    fn entry_title(&self) -> MdCowStr<'_> {
+        self.title.clone()
+    }
+
+    fn frontmatter(&self) -> Frontmatter {
+        self.frontmatter.clone()
+    }
+
+    fn set_frontmatter(&self, _frontmatter: Frontmatter) {
+        // No-op for client context
+    }
+
+    async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s> {
+        match &link {
+            Tag::Link { link_type, dest_url, title, id } => {
+                let url = dest_url.as_ref();
+
+                // Try to parse as AT URI
+                if let Ok(at_uri) = AtUri::new(url) {
+                    let web_url = at_uri_to_web_url(&at_uri);
+
+                    return Tag::Link {
+                        link_type: *link_type,
+                        dest_url: MdCowStr::Boxed(web_url.into_boxed_str()),
+                        title: title.clone(),
+                        id: id.clone(),
+                    };
+                }
+
+                // Entry links starting with / are server-relative, pass through
+                // External links pass through
+                link
+            }
+            _ => link,
+        }
+    }
+
+    async fn handle_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
+        // Images already have canonical paths like /{notebook}/image/{name}
+        // The server will handle routing these to the actual blobs
+        image
+    }
+
+    async fn handle_embed<'s>(&self, embed: Tag<'s>) -> Tag<'s> {
+        match &embed {
+            Tag::Embed {
+                embed_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                // If content already in attrs (from preprocessor), pass through
+                if let Some(attrs) = attrs {
+                    if attrs.attrs.iter().any(|(k, _)| k.as_ref() == "content") {
+                        return embed;
+                    }
+                }
+
+                // Check if we have a resolver
+                let Some(resolver) = &self.embed_resolver else {
+                    return embed;
+                };
+
+                // Check recursion depth
+                if self.embed_depth >= MAX_EMBED_DEPTH {
+                    return embed;
+                }
+
+                // Try to fetch content based on URL type
+                let content_result = if dest_url.starts_with("at://") {
+                    // AT Protocol embed
+                    if let Ok(at_uri) = AtUri::new(dest_url.as_ref()) {
+                        if at_uri.collection().is_none() && at_uri.rkey().is_none() {
+                            // Profile embed
+                            resolver.resolve_profile(&at_uri).await
+                        } else {
+                            // Post/record embed
+                            resolver.resolve_post(&at_uri).await
+                        }
+                    } else {
+                        return embed;
+                    }
+                } else if dest_url.starts_with("http://") || dest_url.starts_with("https://") {
+                    // Markdown embed (could be other types, but assume markdown for now)
+                    resolver
+                        .resolve_markdown(dest_url.as_ref(), self.embed_depth + 1)
+                        .await
+                } else {
+                    // Local path or other - skip for now
+                    return embed;
+                };
+
+                // If we got content, attach it to attrs
+                if let Ok(content) = content_result {
+                    let mut new_attrs = attrs.clone().unwrap_or_else(|| WeaverAttributes {
+                        classes: vec![],
+                        attrs: vec![],
+                    });
+
+                    new_attrs.attrs.push(("content".into(), content.into()));
+
+                    // Add metadata for client-side enhancement
+                    if dest_url.starts_with("at://") {
+                        new_attrs
+                            .attrs
+                            .push(("data-embed-uri".into(), dest_url.clone()));
+
+                        if let Ok(at_uri) = AtUri::new(dest_url.as_ref()) {
+                            if at_uri.collection().is_none() {
+                                new_attrs
+                                    .attrs
+                                    .push(("data-embed-type".into(), "profile".into()));
+                            } else {
+                                new_attrs
+                                    .attrs
+                                    .push(("data-embed-type".into(), "post".into()));
+                            }
+                        }
+                    } else {
+                        new_attrs
+                            .attrs
+                            .push(("data-embed-type".into(), "markdown".into()));
+                    }
+
+                    Tag::Embed {
+                        embed_type: *embed_type,
+                        dest_url: dest_url.clone(),
+                        title: title.clone(),
+                        id: id.clone(),
+                        attrs: Some(new_attrs),
+                    }
+                } else {
+                    // Fetch failed, return original
+                    embed
+                }
+            }
+            _ => embed,
+        }
+    }
+
+    fn handle_reference(&self, reference: MdCowStr<'_>) -> MdCowStr<'_> {
+        reference.into_static()
+    }
+
+    fn add_reference(&self, _reference: MdCowStr<'_>) {
+        // No-op for client context
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use weaver_api::sh_weaver::notebook::entry::Entry;
+    use jacquard::types::string::{Did, Datetime};
+
+    #[test]
+    fn test_client_context_creation() {
+        let entry = Entry::new()
+            .title("Test")
+            .content("# Test")
+            .created_at(Datetime::now())
+            .build();
+
+        let ctx = ClientContext::new(entry, Did::new("did:plc:test").unwrap());
+        assert_eq!(ctx.title.as_ref(), "Test");
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_profile() {
+        let uri = AtUri::new("at://did:plc:xyz123").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://weaver.sh/did:plc:xyz123"
+        );
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_bsky_post() {
+        let uri = AtUri::new("at://did:plc:xyz123/app.bsky.feed.post/3k7qrw5h2").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://bsky.app/profile/did:plc:xyz123/post/3k7qrw5h2"
+        );
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_bsky_list() {
+        let uri = AtUri::new("at://alice.bsky.social/app.bsky.graph.list/abc123").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://bsky.app/profile/alice.bsky.social/lists/abc123"
+        );
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_bsky_feed() {
+        let uri = AtUri::new("at://alice.bsky.social/app.bsky.feed.generator/my-feed").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://bsky.app/profile/alice.bsky.social/feed/my-feed"
+        );
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_bsky_starterpack() {
+        let uri = AtUri::new("at://alice.bsky.social/app.bsky.graph.starterpack/pack123").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://bsky.app/starter-pack/alice.bsky.social/pack123"
+        );
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_weaver_entry() {
+        let uri = AtUri::new("at://did:plc:xyz123/sh.weaver.notebook.entry/entry123").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://weaver.sh/did:plc:xyz123/sh.weaver.notebook.entry/entry123"
+        );
+    }
+
+    #[test]
+    fn test_at_uri_to_web_url_unknown_collection() {
+        let uri = AtUri::new("at://did:plc:xyz123/com.example.unknown/rkey").unwrap();
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://weaver.sh/did:plc:xyz123/com.example.unknown/rkey"
+        );
+    }
+}

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

···
+//! Fetch and render AT Protocol records as HTML embeds
+//!
+//! This module provides functions to fetch records from PDSs and render them
+//! as HTML strings suitable for embedding in markdown content.
+
+use jacquard::{
+    client::{Agent, AgentSession, AgentSessionExt, ClientError},
+    prelude::IdentityResolver,
+    types::string::{AtUri, Did, Nsid},
+    xrpc::{self, Response, XrpcClient},
+    http_client::HttpClient,
+    Data,
+};
+use weaver_api::com_atproto::repo::get_record::{GetRecord, GetRecordResponse, GetRecordOutput};
+use super::error::AtProtoPreprocessError;
+
+/// Get a record without type validation, returning untyped Data
+///
+/// This is similar to jacquard's `get_record` but skips collection validation
+/// and returns the raw Data value instead of a typed response.
+async fn get_record_untyped<'a, A: AgentSession + IdentityResolver>(
+    uri: &AtUri<'_>,
+    agent: &Agent<A>,
+) -> Result<Response<GetRecordResponse>, ClientError> {
+    use jacquard::types::ident::AtIdentifier;
+
+    // Extract collection and rkey from URI
+    let collection = uri.collection().ok_or_else(|| {
+        ClientError::invalid_request("AtUri missing collection")
+            .with_help("ensure the URI includes a collection")
+    })?;
+
+    let rkey = uri.rkey().ok_or_else(|| {
+        ClientError::invalid_request("AtUri missing rkey")
+            .with_help("ensure the URI includes a record key after the collection")
+    })?;
+
+    // Resolve authority (DID or handle) to get DID and PDS
+    let (repo_did, pds_url) = match uri.authority() {
+        AtIdentifier::Did(did) => {
+            let pds = agent.pds_for_did(did).await.map_err(|e| {
+                ClientError::from(e)
+                    .with_context("DID document resolution failed during record retrieval")
+            })?;
+            (did.clone(), pds)
+        }
+        AtIdentifier::Handle(handle) => agent.pds_for_handle(handle).await.map_err(|e| {
+            ClientError::from(e)
+                .with_context("handle resolution failed during record retrieval")
+        })?,
+    };
+
+    // Make stateless XRPC call to that PDS (no auth required for public records)
+    let request = GetRecord::new()
+        .repo(AtIdentifier::Did(repo_did))
+        .collection(collection.clone())
+        .rkey(rkey.clone())
+        .build();
+
+    let http_request = xrpc::build_http_request(&pds_url, &request, &agent.opts().await)?;
+
+    let http_response = agent
+        .send_http(http_request)
+        .await
+        .map_err(|e| ClientError::transport(e))?;
+
+    xrpc::process_response(http_response)
+}
+
+/// Fetch and render a profile record as HTML
+///
+/// Constructs the profile URI `at://did/app.bsky.actor.profile/self` and fetches it.
+pub async fn fetch_and_render_profile<A: AgentSession + IdentityResolver>(
+    did: &Did<'_>,
+    agent: &Agent<A>,
+) -> Result<String, AtProtoPreprocessError> {
+    use weaver_api::app_bsky::actor::profile::Profile;
+
+    // Construct profile URI: at://did/app.bsky.actor.profile/self
+    let profile_uri = format!("at://{}/app.bsky.actor.profile/self", did.as_ref());
+
+    // Fetch using typed collection
+    let record_uri = Profile::uri(&profile_uri)
+        .map_err(|e| AtProtoPreprocessError::InvalidUri(e.to_string()))?;
+
+    let output = agent.fetch_record(&record_uri).await
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
+
+    // Render profile to HTML
+    render_profile(&output.value, did)
+}
+
+/// Fetch and render a Bluesky post as HTML
+pub async fn fetch_and_render_post<A: AgentSession + IdentityResolver>(
+    uri: &AtUri<'_>,
+    agent: &Agent<A>,
+) -> Result<String, AtProtoPreprocessError> {
+    use weaver_api::app_bsky::feed::post::Post;
+
+    // Fetch using typed collection
+    let record_uri = Post::uri(uri.as_ref())
+        .map_err(|e| AtProtoPreprocessError::InvalidUri(e.to_string()))?;
+
+    let output = agent.fetch_record(&record_uri).await
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
+
+    // Render post to HTML
+    render_post(&output.value, uri)
+}
+
+/// Fetch and render an unknown record type generically
+///
+/// This fetches the record as untyped Data and probes for likely meaningful fields.
+pub async fn fetch_and_render_generic<A: AgentSession + IdentityResolver>(
+    uri: &AtUri<'_>,
+    agent: &Agent<A>,
+) -> Result<String, AtProtoPreprocessError> {
+    // Use untyped fetch
+    let response = get_record_untyped(uri, agent).await
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
+
+    // Parse to get GetRecordOutput with Data value
+    let output: GetRecordOutput = response.into_output()
+        .map_err(|e| AtProtoPreprocessError::ParseFailed(e.to_string()))?;
+
+    // Probe for meaningful fields
+    render_generic_record(&output.value, uri)
+}
+
+/// Render a profile record as HTML
+fn render_profile<'a>(
+    profile: &weaver_api::app_bsky::actor::profile::Profile<'a>,
+    did: &Did<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    let mut html = String::new();
+
+    html.push_str("<div class=\"atproto-embed atproto-profile\">");
+
+    if let Some(display_name) = &profile.display_name {
+        html.push_str("<div class=\"profile-name\">");
+        html.push_str(&html_escape(display_name.as_ref()));
+        html.push_str("</div>");
+    }
+
+    html.push_str("<div class=\"profile-did\">");
+    html.push_str(&html_escape(did.as_ref()));
+    html.push_str("</div>");
+
+    if let Some(description) = &profile.description {
+        html.push_str("<div class=\"profile-description\">");
+        html.push_str(&html_escape(description.as_ref()));
+        html.push_str("</div>");
+    }
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Render a Bluesky post as HTML
+fn render_post<'a>(
+    post: &weaver_api::app_bsky::feed::post::Post<'a>,
+    _uri: &AtUri<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    let mut html = String::new();
+
+    html.push_str("<div class=\"atproto-embed atproto-post\">");
+
+    html.push_str("<div class=\"post-text\">");
+    html.push_str(&html_escape(post.text.as_ref()));
+    html.push_str("</div>");
+
+    html.push_str("<div class=\"post-meta\">");
+    html.push_str("<time>");
+    html.push_str(&html_escape(&post.created_at.to_string()));
+    html.push_str("</time>");
+    html.push_str("</div>");
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Render a generic record by probing Data for meaningful fields
+fn render_generic_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    let mut html = String::new();
+
+    html.push_str("<div class=\"atproto-embed atproto-record\">");
+
+    // Try common field patterns
+    if let Some(text) = data.query("/text").single().and_then(|d| d.as_str()) {
+        html.push_str("<div class=\"record-text\">");
+        html.push_str(&html_escape(text));
+        html.push_str("</div>");
+    }
+
+    if let Some(name) = data.query("/name").single().and_then(|d| d.as_str()) {
+        html.push_str("<div class=\"record-name\">");
+        html.push_str(&html_escape(name));
+        html.push_str("</div>");
+    }
+
+    if let Some(description) = data.query("/description").single().and_then(|d| d.as_str()) {
+        html.push_str("<div class=\"record-description\">");
+        html.push_str(&html_escape(description));
+        html.push_str("</div>");
+    }
+
+    // Show record type
+    if let Some(collection) = uri.collection() {
+        html.push_str("<div class=\"record-type\">");
+        html.push_str(&html_escape(collection.as_ref()));
+        html.push_str("</div>");
+    }
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Simple HTML escaping
+fn html_escape(s: &str) -> String {
+    s.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
+        .replace('\'', "&#39;")
+}

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

···
+use miette::Diagnostic;
+use thiserror::Error;
+
+#[derive(Debug, Error, Diagnostic)]
+pub enum AtProtoPreprocessError {
+    #[error("blob upload failed: {0}")]
+    #[diagnostic(code(atproto::preprocess::blob_upload))]
+    BlobUpload(String, #[source] Box<dyn std::error::Error + Send + Sync>),
+
+    #[error("failed to resolve handle {handle} to DID")]
+    #[diagnostic(code(atproto::preprocess::handle_resolution))]
+    HandleResolution {
+        handle: String,
+        #[source]
+        source: Box<dyn std::error::Error + Send + Sync>,
+    },
+
+    #[error("entry not found in vault: {0}")]
+    #[diagnostic(code(atproto::preprocess::entry_not_found))]
+    EntryNotFound(String),
+
+    #[error("invalid image path: {0}")]
+    #[diagnostic(code(atproto::preprocess::invalid_image))]
+    InvalidImage(String),
+
+    #[error("io error: {0}")]
+    #[diagnostic(code(atproto::preprocess::io))]
+    Io(#[from] std::io::Error),
+
+    #[error("invalid AT URI: {0}")]
+    #[diagnostic(code(atproto::preprocess::invalid_uri))]
+    InvalidUri(String),
+
+    #[error("failed to fetch record: {0}")]
+    #[diagnostic(code(atproto::preprocess::fetch_failed))]
+    FetchFailed(String),
+
+    #[error("failed to parse record: {0}")]
+    #[diagnostic(code(atproto::preprocess::parse_failed))]
+    ParseFailed(String),
+}
+
+#[derive(Debug, Error, Diagnostic)]
+pub enum ClientRenderError {
+    #[error("failed to fetch embedded entry: {uri}")]
+    #[diagnostic(code(atproto::client::entry_fetch))]
+    EntryFetch {
+        uri: String,
+        #[source]
+        source: Box<dyn std::error::Error + Send + Sync>,
+    },
+
+    #[error("blob not found in entry embeds: {name}")]
+    #[diagnostic(code(atproto::client::blob_not_found))]
+    BlobNotFound { name: String },
+}

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

···
+use markdown_weaver::{Event, Tag, TagEnd, CowStr};
+use markdown_weaver_escape::StrWrite;
+
+/// Writes markdown events back to markdown text
+pub struct MarkdownWriter<W: StrWrite> {
+    writer: W,
+    in_list: bool,
+    list_depth: usize,
+    current_link_url: Option<CowStr<'static>>,
+    current_link_title: Option<CowStr<'static>>,
+}
+
+impl<W: StrWrite> MarkdownWriter<W> {
+    pub fn new(writer: W) -> Self {
+        Self {
+            writer,
+            in_list: false,
+            list_depth: 0,
+            current_link_url: None,
+            current_link_title: None,
+        }
+    }
+
+    pub fn write_event(&mut self, event: Event<'_>) -> Result<(), W::Error> {
+        match event {
+            Event::Start(tag) => self.start_tag(tag),
+            Event::End(tag) => self.end_tag(tag),
+            Event::Text(text) => write!(self.writer, "{}", text),
+            Event::Code(code) => write!(self.writer, "`{}`", code),
+            Event::Html(html) => write!(self.writer, "{}", html),
+            Event::InlineHtml(html) => write!(self.writer, "{}", html),
+            Event::SoftBreak => write!(self.writer, "\n"),
+            Event::HardBreak => write!(self.writer, "  \n"),
+            Event::Rule => write!(self.writer, "\n---\n\n"),
+            Event::InlineMath(math) => write!(self.writer, "${}$", math),
+            Event::DisplayMath(math) => write!(self.writer, "\n$$\n{}\n$$\n", math),
+            Event::FootnoteReference(name) => write!(self.writer, "[^{}]", name),
+            Event::TaskListMarker(checked) => {
+                if checked {
+                    write!(self.writer, "[x] ")
+                } else {
+                    write!(self.writer, "[ ] ")
+                }
+            }
+            _ => Ok(()),
+        }
+    }
+
+    fn start_tag(&mut self, tag: Tag<'_>) -> Result<(), W::Error> {
+        match tag {
+            Tag::Paragraph => Ok(()),
+            Tag::Heading { level, .. } => {
+                write!(self.writer, "{} ", "#".repeat(level as usize))
+            }
+            Tag::BlockQuote(_) => write!(self.writer, "> "),
+            Tag::CodeBlock(kind) => {
+                match kind {
+                    markdown_weaver::CodeBlockKind::Fenced(lang) => {
+                        write!(self.writer, "\n```{}\n", lang)
+                    }
+                    markdown_weaver::CodeBlockKind::Indented => {
+                        write!(self.writer, "\n    ")
+                    }
+                }
+            }
+            Tag::List(_) => {
+                self.in_list = true;
+                self.list_depth += 1;
+                Ok(())
+            }
+            Tag::Item => {
+                let indent = "  ".repeat(self.list_depth.saturating_sub(1));
+                write!(self.writer, "{}* ", indent)
+            }
+            Tag::Link { dest_url, title, .. } => {
+                self.current_link_url = Some(dest_url.into_static());
+                self.current_link_title = if title.is_empty() {
+                    None
+                } else {
+                    Some(title.into_static())
+                };
+                write!(self.writer, "[")
+            }
+            Tag::Image { dest_url, title, .. } => {
+                self.current_link_url = Some(dest_url.into_static());
+                self.current_link_title = if title.is_empty() {
+                    None
+                } else {
+                    Some(title.into_static())
+                };
+                write!(self.writer, "![")
+            }
+            Tag::Embed { dest_url, title, .. } => {
+                self.current_link_url = Some(dest_url.into_static());
+                self.current_link_title = if title.is_empty() {
+                    None
+                } else {
+                    Some(title.into_static())
+                };
+                write!(self.writer, "![")
+            }
+            Tag::Emphasis => write!(self.writer, "*"),
+            Tag::Strong => write!(self.writer, "**"),
+            Tag::Strikethrough => write!(self.writer, "~~"),
+            Tag::Table(_) => write!(self.writer, "\n"),
+            _ => Ok(()),
+        }
+    }
+
+    fn end_tag(&mut self, tag: TagEnd) -> Result<(), W::Error> {
+        match tag {
+            TagEnd::Paragraph => write!(self.writer, "\n\n"),
+            TagEnd::Heading(_) => write!(self.writer, "\n\n"),
+            TagEnd::BlockQuote(_) => write!(self.writer, "\n\n"),
+            TagEnd::CodeBlock => write!(self.writer, "```\n\n"),
+            TagEnd::List(_) => {
+                self.list_depth = self.list_depth.saturating_sub(1);
+                if self.list_depth == 0 {
+                    self.in_list = false;
+                    write!(self.writer, "\n")
+                } else {
+                    Ok(())
+                }
+            }
+            TagEnd::Item => write!(self.writer, "\n"),
+            TagEnd::Link => {
+                let url = self.current_link_url.take().unwrap_or(CowStr::Borrowed(""));
+                if let Some(title) = self.current_link_title.take() {
+                    write!(self.writer, "]({} \"{}\")", url, title)
+                } else {
+                    write!(self.writer, "]({})", url)
+                }
+            }
+            TagEnd::Image => {
+                let url = self.current_link_url.take().unwrap_or(CowStr::Borrowed(""));
+                if let Some(title) = self.current_link_title.take() {
+                    write!(self.writer, "]({} \"{}\")", url, title)
+                } else {
+                    write!(self.writer, "]({})", url)
+                }
+            }
+            TagEnd::Embed => {
+                let url = self.current_link_url.take().unwrap_or(CowStr::Borrowed(""));
+                if let Some(title) = self.current_link_title.take() {
+                    write!(self.writer, "]({} \"{}\")", url, title)
+                } else {
+                    write!(self.writer, "]({})", url)
+                }
+            }
+            TagEnd::Emphasis => write!(self.writer, "*"),
+            TagEnd::Strong => write!(self.writer, "**"),
+            TagEnd::Strikethrough => write!(self.writer, "~~"),
+            _ => Ok(()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use markdown_weaver::{Event, Tag, CowStr};
+    use markdown_weaver_escape::FmtWriter;
+
+    #[test]
+    fn test_write_paragraph() {
+        let mut output = String::new();
+        let mut writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        writer.write_event(Event::Start(Tag::Paragraph)).unwrap();
+        writer.write_event(Event::Text(CowStr::Borrowed("Hello"))).unwrap();
+        writer.write_event(Event::End(markdown_weaver::TagEnd::Paragraph)).unwrap();
+
+        assert_eq!(output, "Hello\n\n");
+    }
+
+    #[test]
+    fn test_write_heading() {
+        let mut output = String::new();
+        let mut writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        writer.write_event(Event::Start(Tag::Heading {
+            level: markdown_weaver::HeadingLevel::H2,
+            id: None,
+            classes: vec![],
+            attrs: vec![],
+        })).unwrap();
+        writer.write_event(Event::Text(CowStr::Borrowed("Title"))).unwrap();
+        writer.write_event(Event::End(markdown_weaver::TagEnd::Heading(markdown_weaver::HeadingLevel::H2))).unwrap();
+
+        assert_eq!(output, "## Title\n\n");
+    }
+
+    #[test]
+    fn test_write_code() {
+        let mut output = String::new();
+        let mut writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        writer.write_event(Event::Code(CowStr::Borrowed("let x = 5;"))).unwrap();
+
+        assert_eq!(output, "`let x = 5;`");
+    }
+
+    #[test]
+    fn test_write_link() {
+        let mut output = String::new();
+        let mut writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        writer.write_event(Event::Start(Tag::Link {
+            link_type: markdown_weaver::LinkType::Inline,
+            dest_url: CowStr::Borrowed("/path/to/page"),
+            title: CowStr::Borrowed(""),
+            id: CowStr::Borrowed(""),
+        })).unwrap();
+        writer.write_event(Event::Text(CowStr::Borrowed("Link text"))).unwrap();
+        writer.write_event(Event::End(markdown_weaver::TagEnd::Link)).unwrap();
+
+        assert_eq!(output, "[Link text](/path/to/page)");
+    }
+
+    #[test]
+    fn test_write_link_with_title() {
+        let mut output = String::new();
+        let mut writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        writer.write_event(Event::Start(Tag::Link {
+            link_type: markdown_weaver::LinkType::Inline,
+            dest_url: CowStr::Borrowed("/path"),
+            title: CowStr::Borrowed("Hover tooltip"),  // The quoted "title" attribute
+            id: CowStr::Borrowed(""),
+        })).unwrap();
+        writer.write_event(Event::Text(CowStr::Borrowed("link text"))).unwrap();
+        writer.write_event(Event::End(markdown_weaver::TagEnd::Link)).unwrap();
+
+        assert_eq!(output, "[link text](/path \"Hover tooltip\")");
+    }
+
+    #[test]
+    fn test_write_image() {
+        let mut output = String::new();
+        let mut writer = MarkdownWriter::new(FmtWriter(&mut output));
+
+        writer.write_event(Event::Start(Tag::Image {
+            link_type: markdown_weaver::LinkType::Inline,
+            dest_url: CowStr::Borrowed("/image.png"),
+            title: CowStr::Borrowed("Hover tooltip"),  // The quoted "title" attribute
+            id: CowStr::Borrowed(""),
+            attrs: None,
+        })).unwrap();
+        writer.write_event(Event::Text(CowStr::Borrowed("Alt text in brackets"))).unwrap();
+        writer.write_event(Event::End(markdown_weaver::TagEnd::Image)).unwrap();
+
+        assert_eq!(output, "![Alt text in brackets](/image.png \"Hover tooltip\")");
+    }
+}

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

···
+use crate::{Frontmatter, NotebookContext};
+use super::types::{BlobName, BlobInfo};
+use dashmap::DashMap;
+use jacquard::{
+    client::{Agent, AgentSession, AgentSessionExt},
+    prelude::IdentityResolver,
+    types::string::{CowStr, Did, Handle},
+};
+use markdown_weaver::{Tag, CowStr as MdCowStr, WeaverAttributes};
+use std::{
+    path::PathBuf,
+    sync::Arc,
+};
+
+pub struct AtProtoPreprocessContext<A: AgentSession + IdentityResolver> {
+    // Vault information
+    pub(crate) vault_contents: Arc<[PathBuf]>,
+    pub(crate) current_path: PathBuf,
+
+    // AT Protocol agent
+    agent: Arc<Agent<A>>,
+
+    // Notebook metadata
+    pub(crate) notebook_title: CowStr<'static>,
+    pub(crate) creator_did: Option<Did<'static>>,
+    pub(crate) creator_handle: Option<Handle<'static>>,
+
+    // Blob tracking
+    blob_tracking: Arc<DashMap<BlobName<'static>, BlobInfo>>,
+
+    // Shared with static site
+    frontmatter: Arc<DashMap<PathBuf, Frontmatter>>,
+    titles: Arc<DashMap<PathBuf, MdCowStr<'static>>>,
+    reference_map: Arc<DashMap<MdCowStr<'static>, PathBuf>>,
+
+    // Recursion tracking for markdown embeds
+    embed_depth: usize,
+}
+
+impl<A: AgentSession + IdentityResolver> Clone for AtProtoPreprocessContext<A> {
+    fn clone(&self) -> Self {
+        Self {
+            vault_contents: self.vault_contents.clone(),
+            current_path: self.current_path.clone(),
+            agent: self.agent.clone(),
+            notebook_title: self.notebook_title.clone(),
+            creator_did: self.creator_did.clone(),
+            creator_handle: self.creator_handle.clone(),
+            blob_tracking: self.blob_tracking.clone(),
+            frontmatter: self.frontmatter.clone(),
+            titles: self.titles.clone(),
+            reference_map: self.reference_map.clone(),
+            embed_depth: self.embed_depth,
+        }
+    }
+}
+
+impl<A: AgentSession + IdentityResolver> AtProtoPreprocessContext<A> {
+    pub fn new(
+        vault_contents: Arc<[PathBuf]>,
+        notebook_title: impl Into<CowStr<'static>>,
+        agent: Arc<Agent<A>>,
+    ) -> Self {
+        Self {
+            vault_contents,
+            current_path: PathBuf::new(),
+            agent,
+            notebook_title: notebook_title.into(),
+            creator_did: None,
+            creator_handle: None,
+            blob_tracking: Arc::new(DashMap::new()),
+            frontmatter: Arc::new(DashMap::new()),
+            titles: Arc::new(DashMap::new()),
+            reference_map: Arc::new(DashMap::new()),
+            embed_depth: 0,
+        }
+    }
+
+    pub fn with_creator(mut self, did: Did<'static>, handle: Handle<'static>) -> Self {
+        self.creator_did = Some(did);
+        self.creator_handle = Some(handle);
+        self
+    }
+
+    pub fn blobs(&self) -> Vec<BlobInfo> {
+        self.blob_tracking
+            .iter()
+            .map(|entry| entry.value().clone())
+            .collect()
+    }
+
+    pub fn set_current_path(&mut self, path: PathBuf) {
+        self.current_path = path;
+    }
+
+    fn with_depth(&self, depth: usize) -> Self {
+        Self {
+            vault_contents: self.vault_contents.clone(),
+            current_path: self.current_path.clone(),
+            agent: self.agent.clone(),
+            notebook_title: self.notebook_title.clone(),
+            creator_did: self.creator_did.clone(),
+            creator_handle: self.creator_handle.clone(),
+            blob_tracking: self.blob_tracking.clone(),
+            frontmatter: self.frontmatter.clone(),
+            titles: self.titles.clone(),
+            reference_map: self.reference_map.clone(),
+            embed_depth: depth,
+        }
+    }
+}
+
+// Stub NotebookContext implementation
+impl<A: AgentSession + IdentityResolver> NotebookContext for AtProtoPreprocessContext<A> {
+    fn set_entry_title(&self, title: MdCowStr<'_>) {
+        self.titles.insert(self.current_path.clone(), title.into_static());
+    }
+
+    fn entry_title(&self) -> MdCowStr<'_> {
+        self.titles
+            .get(&self.current_path)
+            .map(|t| t.value().clone())
+            .unwrap_or(MdCowStr::Borrowed(""))
+    }
+
+    fn frontmatter(&self) -> Frontmatter {
+        self.frontmatter
+            .get(&self.current_path)
+            .map(|f| f.value().clone())
+            .unwrap_or_default()
+    }
+
+    fn set_frontmatter(&self, frontmatter: Frontmatter) {
+        self.frontmatter.insert(self.current_path.clone(), frontmatter);
+    }
+
+    async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s> {
+        use crate::utils::lookup_filename_in_vault;
+        use weaver_common::LinkUri;
+
+        match &link {
+            Tag::Link {
+                link_type,
+                dest_url,
+                title,
+                id,
+            } => {
+                // Resolve link using LinkUri helper
+                let resolved = LinkUri::resolve(dest_url.as_ref(), &*self.agent).await;
+
+                match resolved {
+                    LinkUri::Path(path) => {
+                        // Local wikilink - look up in vault
+                        if let Some(file_path) = lookup_filename_in_vault(path.as_ref(), &self.vault_contents) {
+                            let entry_title = file_path
+                                .file_stem()
+                                .and_then(|s| s.to_str())
+                                .unwrap_or("untitled");
+                            let normalized_title = normalize_title(entry_title);
+
+                            let canonical_url = if let Some(handle) = &self.creator_handle {
+                                format!(
+                                    "/{}/{}/{}",
+                                    handle.as_ref(),
+                                    self.notebook_title.as_ref(),
+                                    normalized_title
+                                )
+                            } else {
+                                format!(
+                                    "/{}/{}",
+                                    self.notebook_title.as_ref(),
+                                    normalized_title
+                                )
+                            };
+
+                            return Tag::Link {
+                                link_type: *link_type,
+                                dest_url: MdCowStr::Boxed(canonical_url.into_boxed_str()),
+                                title: title.clone(),
+                                id: id.clone(),
+                            };
+                        }
+                    }
+                    LinkUri::AtIdent(did, _handle) => {
+                        // Profile link - use at://did format
+                        let at_uri = format!("at://{}", did.as_ref());
+                        return Tag::Link {
+                            link_type: *link_type,
+                            dest_url: MdCowStr::Boxed(at_uri.into_boxed_str()),
+                            title: title.clone(),
+                            id: id.clone(),
+                        };
+                    }
+                    LinkUri::AtRecord(uri) => {
+                        // AT URI - keep as-is or convert to HTTP
+                        // For now, keep the at:// URI
+                        return Tag::Link {
+                            link_type: *link_type,
+                            dest_url: MdCowStr::Boxed(uri.as_str().into()),
+                            title: title.clone(),
+                            id: id.clone(),
+                        };
+                    }
+                    _ => {}
+                }
+
+                // Pass through other link types (web URLs, headings, etc.)
+                link.clone()
+            }
+            _ => link,
+        }
+    }
+
+    async fn handle_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
+        use crate::utils::is_local_path;
+        use tokio::fs;
+        use jacquard::bytes::Bytes;
+        use jacquard::types::blob::MimeType;
+        use mime_sniffer::MimeTypeSniffer;
+
+        match &image {
+            Tag::Image {
+                link_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                if is_local_path(dest_url) {
+                    // Read local file
+                    let file_path = if dest_url.starts_with('/') {
+                        PathBuf::from(dest_url.as_ref())
+                    } else {
+                        self.current_path
+                            .parent()
+                            .unwrap_or(&self.current_path)
+                            .join(dest_url.as_ref())
+                    };
+
+                    if let Ok(image_data) = fs::read(&file_path).await {
+                        // Derive blob name from filename
+                        let filename = file_path
+                            .file_stem()
+                            .and_then(|s| s.to_str())
+                            .unwrap_or("image");
+                        let blob_name = BlobName::from_filename(filename);
+
+                        // Sniff mime type from data
+                        let bytes = Bytes::from(image_data.clone());
+                        let mime = MimeType::new_owned(
+                            bytes.sniff_mime_type().unwrap_or("application/octet-stream")
+                        );
+
+                        // Upload blob (dereference Arc)
+                        if let Ok(blob) = (*self.agent).upload_blob(bytes, mime.clone()).await {
+                            use jacquard::IntoStatic;
+
+                            // Store blob info
+                            let blob_info = BlobInfo {
+                                name: blob_name.clone(),
+                                blob: blob.into_static(),
+                                alt: if title.is_empty() {
+                                    None
+                                } else {
+                                    Some(CowStr::Owned(title.as_ref().into()))
+                                },
+                            };
+                            self.blob_tracking.insert(blob_name.clone(), blob_info);
+
+                            // Rewrite to canonical path
+                            let canonical_url = format!(
+                                "/{}/image/{}",
+                                self.notebook_title.as_ref(),
+                                blob_name.as_str()
+                            );
+
+                            return Tag::Image {
+                                link_type: *link_type,
+                                dest_url: MdCowStr::Boxed(canonical_url.into_boxed_str()),
+                                title: title.clone(),
+                                id: id.clone(),
+                                attrs: attrs.clone(),
+                            };
+                        }
+                    }
+                }
+                // If not local or upload failed, pass through
+                image
+            }
+            _ => image,
+        }
+    }
+
+    async fn handle_embed<'s>(&self, embed: Tag<'s>) -> Tag<'s> {
+        use crate::utils::lookup_filename_in_vault;
+        use weaver_common::LinkUri;
+
+        match &embed {
+            Tag::Embed {
+                embed_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                // Resolve embed using LinkUri helper
+                let resolved = LinkUri::resolve(dest_url.as_ref(), &*self.agent).await;
+
+                match resolved {
+                    LinkUri::Path(path) => {
+                        // Entry embed - look up in vault
+                        if let Some(file_path) = lookup_filename_in_vault(path.as_ref(), &self.vault_contents) {
+                            let entry_title = file_path
+                                .file_stem()
+                                .and_then(|s| s.to_str())
+                                .unwrap_or("untitled");
+                            let normalized_title = normalize_title(entry_title);
+
+                            let canonical_url = if let Some(handle) = &self.creator_handle {
+                                format!(
+                                    "/{}/{}/{}",
+                                    handle.as_ref(),
+                                    self.notebook_title.as_ref(),
+                                    normalized_title
+                                )
+                            } else {
+                                format!(
+                                    "/{}/{}",
+                                    self.notebook_title.as_ref(),
+                                    normalized_title
+                                )
+                            };
+
+                            return Tag::Embed {
+                                embed_type: *embed_type,
+                                dest_url: MdCowStr::Boxed(canonical_url.into_boxed_str()),
+                                title: title.clone(),
+                                id: id.clone(),
+                                attrs: attrs.clone(),
+                            };
+                        }
+                    }
+                    LinkUri::AtIdent(did, _handle) => {
+                        // Profile embed - fetch and render
+                        use crate::atproto::fetch_and_render_profile;
+                        use markdown_weaver::WeaverAttributes;
+
+                        let at_uri = format!("at://{}", did.as_ref());
+
+                        // Fetch and render the profile
+                        let content = match fetch_and_render_profile(&did, &*self.agent).await {
+                            Ok(html) => Some(html),
+                            Err(e) => {
+                                eprintln!("Failed to fetch profile {}: {}", did.as_ref(), e);
+                                None
+                            }
+                        };
+
+                        // Build or update attributes
+                        let mut new_attrs = attrs.clone().unwrap_or_else(|| WeaverAttributes {
+                            classes: vec![],
+                            attrs: vec![],
+                        });
+
+                        if let Some(content_html) = content {
+                            new_attrs.attrs.push(("content".into(), content_html.into()));
+                        }
+
+                        return Tag::Embed {
+                            embed_type: *embed_type,
+                            dest_url: MdCowStr::Boxed(at_uri.into_boxed_str()),
+                            title: title.clone(),
+                            id: id.clone(),
+                            attrs: Some(new_attrs),
+                        };
+                    }
+                    LinkUri::AtRecord(uri) => {
+                        // AT URI embed - fetch and render
+                        use crate::atproto::{fetch_and_render_post, fetch_and_render_generic};
+                        use markdown_weaver::WeaverAttributes;
+
+                        // Determine if this is a known type
+                        let content = if let Some(collection) = uri.collection() {
+                            match collection.as_ref() {
+                                "app.bsky.feed.post" => {
+                                    // Bluesky post
+                                    match fetch_and_render_post(&uri, &*self.agent).await {
+                                        Ok(html) => Some(html),
+                                        Err(e) => {
+                                            eprintln!("Failed to fetch post {}: {}", uri.as_ref(), e);
+                                            None
+                                        }
+                                    }
+                                }
+                                _ => {
+                                    // Generic record
+                                    match fetch_and_render_generic(&uri, &*self.agent).await {
+                                        Ok(html) => Some(html),
+                                        Err(e) => {
+                                            eprintln!("Failed to fetch record {}: {}", uri.as_ref(), e);
+                                            None
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            None
+                        };
+
+                        // Build or update attributes
+                        let mut new_attrs = attrs.clone().unwrap_or_else(|| WeaverAttributes {
+                            classes: vec![],
+                            attrs: vec![],
+                        });
+
+                        if let Some(content_html) = content {
+                            new_attrs.attrs.push(("content".into(), content_html.into()));
+                        }
+
+                        return Tag::Embed {
+                            embed_type: *embed_type,
+                            dest_url: MdCowStr::Boxed(uri.as_str().into()),
+                            title: title.clone(),
+                            id: id.clone(),
+                            attrs: Some(new_attrs),
+                        };
+                    }
+                    LinkUri::Path(path) => {
+                        // Markdown embed - look up in vault and render
+                        use crate::utils::lookup_filename_in_vault;
+                        use tokio::fs;
+
+                        // Check depth limit
+                        const MAX_DEPTH: usize = 1;
+                        if self.embed_depth >= MAX_DEPTH {
+                            eprintln!("Max embed depth reached for {}", path.as_ref());
+                            return embed.clone();
+                        }
+
+                        if let Some(file_path) = lookup_filename_in_vault(path.as_ref(), &self.vault_contents) {
+                            // Read the markdown file
+                            match fs::read_to_string(&file_path).await {
+                                Ok(markdown_content) => {
+                                    // Create a child context with incremented depth
+                                    let mut child_ctx = self.with_depth(self.embed_depth + 1);
+                                    child_ctx.current_path = file_path.clone();
+
+                                    // Render the markdown through the processor
+                                    // We'll use markdown_weaver to parse and render to HTML
+                                    use markdown_weaver::{Parser, Options};
+                                    use markdown_weaver_escape::StrWrite;
+
+                                    let parser = Parser::new_ext(&markdown_content, Options::all());
+                                    let mut html_output = String::new();
+
+                                    // Process events through context callbacks
+                                    for event in parser {
+                                        match event {
+                                            markdown_weaver::Event::Start(tag) => {
+                                                let processed = match tag {
+                                                    Tag::Link { .. } => child_ctx.handle_link(tag).await,
+                                                    Tag::Image { .. } => child_ctx.handle_image(tag).await,
+                                                    Tag::Embed { .. } => child_ctx.handle_embed(tag).await,
+                                                    _ => tag,
+                                                };
+                                                // Simple HTML writing (reuse escape logic)
+                                                match processed {
+                                                    Tag::Paragraph => html_output.write_str("<p>").ok(),
+                                                    _ => None,
+                                                };
+                                            }
+                                            markdown_weaver::Event::End(tag_end) => {
+                                                match tag_end {
+                                                    markdown_weaver::TagEnd::Paragraph => html_output.write_str("</p>\n").ok(),
+                                                    _ => None,
+                                                };
+                                            }
+                                            markdown_weaver::Event::Text(text) => {
+                                                use markdown_weaver_escape::escape_html_body_text;
+                                                escape_html_body_text(&mut html_output, &text).ok();
+                                            }
+                                            _ => {}
+                                        }
+                                    }
+
+                                    let mut new_attrs = attrs.clone().unwrap_or_else(|| WeaverAttributes {
+                                        classes: vec![],
+                                        attrs: vec![],
+                                    });
+
+                                    new_attrs.attrs.push(("content".into(), html_output.into()));
+
+                                    return Tag::Embed {
+                                        embed_type: *embed_type,
+                                        dest_url: dest_url.clone(),
+                                        title: title.clone(),
+                                        id: id.clone(),
+                                        attrs: Some(new_attrs),
+                                    };
+                                }
+                                Err(e) => {
+                                    eprintln!("Failed to read file {:?}: {}", file_path, e);
+                                }
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+
+                // Pass through other embed types
+                embed.clone()
+            }
+            Tag::Image {
+                link_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                // Some embeds come through as explicit Tag::Image
+                // Delegate to handle_image for image-specific processing
+                self.handle_image(embed).await
+            }
+            _ => embed,
+        }
+    }
+
+    fn handle_reference(&self, reference: MdCowStr<'_>) -> MdCowStr<'_> {
+        reference.into_static()
+    }
+
+    fn add_reference(&self, reference: MdCowStr<'_>) {
+        self.reference_map.insert(reference.into_static(), self.current_path.clone());
+    }
+}
+
+/// Normalize entry title to URL-safe format
+fn normalize_title(title: &str) -> String {
+    let mut normalized = String::new();
+    let mut last_was_space = false;
+
+    for c in title.chars() {
+        if c.is_ascii_alphanumeric() {
+            normalized.push(c);
+            last_was_space = false;
+        } else if c.is_whitespace() && !last_was_space && !normalized.is_empty() {
+            normalized.push('_');
+            last_was_space = true;
+        }
+    }
+
+    // Remove trailing underscore if present
+    if normalized.ends_with('_') {
+        normalized.pop();
+    }
+
+    normalized
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Tests require an actual Agent instance, which needs authentication setup.
+    // These will be tested via integration tests instead.
+}

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

···
+use jacquard::types::string::CowStr;
+use jacquard::types::blob::Blob;
+use jacquard::smol_str::{SmolStrBuilder, ToSmolStr};
+
+/// Blob name, validated to be URL-safe snake_case
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct BlobName<'a>(CowStr<'a>);
+
+impl<'a> BlobName<'a> {
+    /// Create blob name from filename, normalizing to lowercase snake_case
+    pub fn from_filename(filename: &str) -> BlobName<'static> {
+        let mut builder = SmolStrBuilder::new();
+        for c in filename.chars() {
+            if c.is_ascii_alphanumeric() {
+                builder.push_str(&c.to_lowercase().to_smolstr());
+            } else {
+                builder.push_str("_");
+            }
+        }
+        BlobName(CowStr::Owned(builder.finish()))
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+
+impl AsRef<str> for BlobName<'_> {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+/// Blob metadata tracked during preprocessing
+#[derive(Debug, Clone)]
+pub struct BlobInfo {
+    pub name: BlobName<'static>,
+    pub blob: Blob<'static>,
+    pub alt: Option<CowStr<'static>>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_blob_name_normalization() {
+        assert_eq!(BlobName::from_filename("My Image.PNG").as_str(), "my_image_png");
+        assert_eq!(BlobName::from_filename("test-file!@#.jpg").as_str(), "test_file____jpg");
+        assert_eq!(BlobName::from_filename("already_good").as_str(), "already_good");
+        assert_eq!(BlobName::from_filename("CAPS").as_str(), "caps");
+        assert_eq!(BlobName::from_filename("with spaces.txt").as_str(), "with_spaces_txt");
+    }
+
+    #[test]
+    fn test_blob_name_hash_equality() {
+        use std::collections::HashMap;
+
+        let name1 = BlobName::from_filename("test.png");
+        let name2 = BlobName::from_filename("test.png");
+
+        let mut map = HashMap::new();
+        map.insert(name1.clone(), "value");
+
+        assert_eq!(map.get(&name2), Some(&"value"));
+    }
+}

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

···
+//! HTML writer for client-side rendering of AT Protocol entries
+//!
+//! Similar to StaticPageWriter but designed for client-side use with
+//! synchronous embed content injection.
+
+use markdown_weaver::{
+    Alignment, BlockQuoteKind, CodeBlockKind, CowStr, EmbedType, Event, LinkType, Tag,
+};
+use markdown_weaver_escape::{escape_href, escape_html, escape_html_body_text, StrWrite};
+use std::collections::HashMap;
+
+/// Synchronous callback for injecting embed content
+///
+/// Takes the embed tag and returns optional HTML content to inject.
+pub trait EmbedContentProvider {
+    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<String>;
+}
+
+/// Simple writer that outputs HTML from markdown events
+///
+/// This writer is designed for client-side rendering where embeds may have
+/// pre-rendered content in their attributes.
+pub struct ClientWriter<W: StrWrite, E = ()> {
+    writer: W,
+    end_newline: bool,
+    in_non_writing_block: bool,
+
+    table_state: TableState,
+    table_alignments: Vec<Alignment>,
+    table_cell_index: usize,
+
+    numbers: HashMap<String, usize>,
+
+    embed_provider: Option<E>,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum TableState {
+    Head,
+    Body,
+}
+
+impl<W: StrWrite> ClientWriter<W, ()> {
+    pub fn new(writer: W) -> Self {
+        Self {
+            writer,
+            end_newline: true,
+            in_non_writing_block: false,
+            table_state: TableState::Head,
+            table_alignments: vec![],
+            table_cell_index: 0,
+            numbers: HashMap::new(),
+            embed_provider: None,
+        }
+    }
+
+    /// Add an embed content provider
+    pub fn with_embed_provider<E: EmbedContentProvider>(self, provider: E) -> ClientWriter<W, E> {
+        ClientWriter {
+            writer: self.writer,
+            end_newline: self.end_newline,
+            in_non_writing_block: self.in_non_writing_block,
+            table_state: self.table_state,
+            table_alignments: self.table_alignments,
+            table_cell_index: self.table_cell_index,
+            numbers: self.numbers,
+            embed_provider: Some(provider),
+        }
+    }
+}
+
+impl<W: StrWrite, E: EmbedContentProvider> ClientWriter<W, E> {
+    #[inline]
+    fn write_newline(&mut self) -> Result<(), W::Error> {
+        self.end_newline = true;
+        self.writer.write_str("\n")
+    }
+
+    #[inline]
+    fn write(&mut self, s: &str) -> Result<(), W::Error> {
+        self.writer.write_str(s)?;
+        if !s.is_empty() {
+            self.end_newline = s.ends_with('\n');
+        }
+        Ok(())
+    }
+
+    /// Process markdown events and write HTML
+    pub fn run<'a>(mut self, events: impl Iterator<Item = Event<'a>>) -> Result<W, W::Error> {
+        for event in events {
+            self.process_event(event)?;
+        }
+        Ok(self.writer)
+    }
+
+    fn process_event(&mut self, event: Event<'_>) -> Result<(), W::Error> {
+        use Event::*;
+        match event {
+            Start(tag) => self.start_tag(tag)?,
+            End(tag) => self.end_tag(tag)?,
+            Text(text) => {
+                if !self.in_non_writing_block {
+                    escape_html_body_text(&mut self.writer, &text)?;
+                    self.end_newline = text.ends_with('\n');
+                }
+            }
+            Code(text) => {
+                self.write("<code>")?;
+                escape_html_body_text(&mut self.writer, &text)?;
+                self.write("</code>")?;
+            }
+            InlineMath(text) => {
+                self.write(r#"<span class="math math-inline">"#)?;
+                escape_html(&mut self.writer, &text)?;
+                self.write("</span>")?;
+            }
+            DisplayMath(text) => {
+                self.write(r#"<span class="math math-display">"#)?;
+                escape_html(&mut self.writer, &text)?;
+                self.write("</span>")?;
+            }
+            Html(html) | InlineHtml(html) => {
+                self.write(&html)?;
+            }
+            SoftBreak => self.write_newline()?,
+            HardBreak => self.write("<br />\n")?,
+            Rule => {
+                if self.end_newline {
+                    self.write("<hr />\n")?;
+                } else {
+                    self.write("\n<hr />\n")?;
+                }
+            }
+            FootnoteReference(name) => {
+                let len = self.numbers.len() + 1;
+                self.write("<sup class=\"footnote-reference\"><a href=\"#")?;
+                escape_html(&mut self.writer, &name)?;
+                self.write("\">")?;
+                let number = *self.numbers.entry(name.to_string()).or_insert(len);
+                write!(&mut self.writer, "{}", number)?;
+                self.write("</a></sup>")?;
+            }
+            TaskListMarker(checked) => {
+                if checked {
+                    self.write("<input disabled=\"\" type=\"checkbox\" checked=\"\"/>\n")?;
+                } else {
+                    self.write("<input disabled=\"\" type=\"checkbox\"/>\n")?;
+                }
+            }
+            WeaverBlock(_) => {}
+        }
+        Ok(())
+    }
+
+    fn start_tag(&mut self, tag: Tag<'_>) -> Result<(), W::Error> {
+        match tag {
+            Tag::HtmlBlock => Ok(()),
+            Tag::Paragraph => {
+                if self.end_newline {
+                    self.write("<p>")
+                } else {
+                    self.write("\n<p>")
+                }
+            }
+            Tag::Heading { level, id, classes, attrs } => {
+                if !self.end_newline {
+                    self.write("\n")?;
+                }
+                self.write("<")?;
+                write!(&mut self.writer, "{}", level)?;
+                if let Some(id) = id {
+                    self.write(" id=\"")?;
+                    escape_html(&mut self.writer, &id)?;
+                    self.write("\"")?;
+                }
+                if !classes.is_empty() {
+                    self.write(" class=\"")?;
+                    for (i, class) in classes.iter().enumerate() {
+                        if i > 0 {
+                            self.write(" ")?;
+                        }
+                        escape_html(&mut self.writer, class)?;
+                    }
+                    self.write("\"")?;
+                }
+                for (attr, value) in attrs {
+                    self.write(" ")?;
+                    escape_html(&mut self.writer, &attr)?;
+                    if let Some(val) = value {
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, &val)?;
+                        self.write("\"")?;
+                    } else {
+                        self.write("=\"\"")?;
+                    }
+                }
+                self.write(">")
+            }
+            Tag::Table(alignments) => {
+                self.table_alignments = alignments;
+                self.write("<table>")
+            }
+            Tag::TableHead => {
+                self.table_state = TableState::Head;
+                self.table_cell_index = 0;
+                self.write("<thead><tr>")
+            }
+            Tag::TableRow => {
+                self.table_cell_index = 0;
+                self.write("<tr>")
+            }
+            Tag::TableCell => {
+                match self.table_state {
+                    TableState::Head => self.write("<th")?,
+                    TableState::Body => self.write("<td")?,
+                }
+                match self.table_alignments.get(self.table_cell_index) {
+                    Some(&Alignment::Left) => self.write(" style=\"text-align: left\">"),
+                    Some(&Alignment::Center) => self.write(" style=\"text-align: center\">"),
+                    Some(&Alignment::Right) => self.write(" style=\"text-align: right\">"),
+                    _ => self.write(">"),
+                }
+            }
+            Tag::BlockQuote(kind) => {
+                let class_str = match kind {
+                    None => "",
+                    Some(BlockQuoteKind::Note) => " class=\"markdown-alert-note\"",
+                    Some(BlockQuoteKind::Tip) => " class=\"markdown-alert-tip\"",
+                    Some(BlockQuoteKind::Important) => " class=\"markdown-alert-important\"",
+                    Some(BlockQuoteKind::Warning) => " class=\"markdown-alert-warning\"",
+                    Some(BlockQuoteKind::Caution) => " class=\"markdown-alert-caution\"",
+                };
+                if self.end_newline {
+                    write!(&mut self.writer, "<blockquote{}>\n", class_str)?;
+                } else {
+                    write!(&mut self.writer, "\n<blockquote{}>\n", class_str)?;
+                }
+                Ok(())
+            }
+            Tag::CodeBlock(info) => {
+                if !self.end_newline {
+                    self.write_newline()?;
+                }
+                match info {
+                    CodeBlockKind::Fenced(info) => {
+                        let lang = info.split(' ').next().unwrap_or("");
+                        if !lang.is_empty() {
+                            self.write("<pre><code class=\"language-")?;
+                            escape_html(&mut self.writer, lang)?;
+                            self.write("\">")?;
+                        } else {
+                            self.write("<pre><code>")?;
+                        }
+                    }
+                    CodeBlockKind::Indented => {
+                        self.write("<pre><code>")?;
+                    }
+                }
+                Ok(())
+            }
+            Tag::List(Some(1)) => {
+                if self.end_newline {
+                    self.write("<ol>\n")
+                } else {
+                    self.write("\n<ol>\n")
+                }
+            }
+            Tag::List(Some(start)) => {
+                if self.end_newline {
+                    self.write("<ol start=\"")?;
+                } else {
+                    self.write("\n<ol start=\"")?;
+                }
+                write!(&mut self.writer, "{}", start)?;
+                self.write("\">\n")
+            }
+            Tag::List(None) => {
+                if self.end_newline {
+                    self.write("<ul>\n")
+                } else {
+                    self.write("\n<ul>\n")
+                }
+            }
+            Tag::Item => {
+                if self.end_newline {
+                    self.write("<li>")
+                } else {
+                    self.write("\n<li>")
+                }
+            }
+            Tag::DefinitionList => {
+                if self.end_newline {
+                    self.write("<dl>\n")
+                } else {
+                    self.write("\n<dl>\n")
+                }
+            }
+            Tag::DefinitionListTitle => {
+                if self.end_newline {
+                    self.write("<dt>")
+                } else {
+                    self.write("\n<dt>")
+                }
+            }
+            Tag::DefinitionListDefinition => {
+                if self.end_newline {
+                    self.write("<dd>")
+                } else {
+                    self.write("\n<dd>")
+                }
+            }
+            Tag::Subscript => self.write("<sub>"),
+            Tag::Superscript => self.write("<sup>"),
+            Tag::Emphasis => self.write("<em>"),
+            Tag::Strong => self.write("<strong>"),
+            Tag::Strikethrough => self.write("<del>"),
+            Tag::Link { link_type: LinkType::Email, dest_url, title, .. } => {
+                self.write("<a href=\"mailto:")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Link { dest_url, title, .. } => {
+                self.write("<a href=\"")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Image { dest_url, title, attrs, .. } => {
+                self.write("<img src=\"")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                self.write("\" alt=\"")?;
+                if !title.is_empty() {
+                    escape_html(&mut self.writer, &title)?;
+                }
+                if let Some(attrs) = attrs {
+                    if !attrs.classes.is_empty() {
+                        self.write("\" class=\"")?;
+                        for (i, class) in attrs.classes.iter().enumerate() {
+                            if i > 0 {
+                                self.write(" ")?;
+                            }
+                            escape_html(&mut self.writer, class)?;
+                        }
+                    }
+                    self.write("\"")?;
+                    for (attr, value) in &attrs.attrs {
+                        self.write(" ")?;
+                        escape_html(&mut self.writer, attr)?;
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, value)?;
+                        self.write("\"")?;
+                    }
+                } else {
+                    self.write("\"")?;
+                }
+                self.write(" />")
+            }
+            Tag::Embed { embed_type, dest_url, title, id, attrs } => {
+                self.write_embed(embed_type, dest_url, title, id, attrs)
+            }
+            Tag::WeaverBlock(_, _) => {
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+            Tag::FootnoteDefinition(name) => {
+                if self.end_newline {
+                    self.write("<div class=\"footnote-definition\" id=\"")?;
+                } else {
+                    self.write("\n<div class=\"footnote-definition\" id=\"")?;
+                }
+                escape_html(&mut self.writer, &name)?;
+                self.write("\"><sup class=\"footnote-definition-label\">")?;
+                let len = self.numbers.len() + 1;
+                let number = *self.numbers.entry(name.to_string()).or_insert(len);
+                write!(&mut self.writer, "{}", number)?;
+                self.write("</sup>")
+            }
+            Tag::MetadataBlock(_) => {
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+        }
+    }
+
+    fn end_tag(&mut self, tag: markdown_weaver::TagEnd) -> Result<(), W::Error> {
+        use markdown_weaver::TagEnd;
+        match tag {
+            TagEnd::HtmlBlock => Ok(()),
+            TagEnd::Paragraph => self.write("</p>\n"),
+            TagEnd::Heading(level) => {
+                self.write("</")?;
+                write!(&mut self.writer, "{}", level)?;
+                self.write(">\n")
+            }
+            TagEnd::Table => self.write("</tbody></table>\n"),
+            TagEnd::TableHead => {
+                self.write("</tr></thead><tbody>\n")?;
+                self.table_state = TableState::Body;
+                Ok(())
+            }
+            TagEnd::TableRow => self.write("</tr>\n"),
+            TagEnd::TableCell => {
+                match self.table_state {
+                    TableState::Head => self.write("</th>")?,
+                    TableState::Body => self.write("</td>")?,
+                }
+                self.table_cell_index += 1;
+                Ok(())
+            }
+            TagEnd::BlockQuote(_) => self.write("</blockquote>\n"),
+            TagEnd::CodeBlock => self.write("</code></pre>\n"),
+            TagEnd::List(true) => self.write("</ol>\n"),
+            TagEnd::List(false) => self.write("</ul>\n"),
+            TagEnd::Item => self.write("</li>\n"),
+            TagEnd::DefinitionList => self.write("</dl>\n"),
+            TagEnd::DefinitionListTitle => self.write("</dt>\n"),
+            TagEnd::DefinitionListDefinition => self.write("</dd>\n"),
+            TagEnd::Emphasis => self.write("</em>"),
+            TagEnd::Superscript => self.write("</sup>"),
+            TagEnd::Subscript => self.write("</sub>"),
+            TagEnd::Strong => self.write("</strong>"),
+            TagEnd::Strikethrough => self.write("</del>"),
+            TagEnd::Link => self.write("</a>"),
+            TagEnd::Image => Ok(()),
+            TagEnd::Embed => Ok(()),
+            TagEnd::WeaverBlock(_) => {
+                self.in_non_writing_block = false;
+                Ok(())
+            }
+            TagEnd::FootnoteDefinition => self.write("</div>\n"),
+            TagEnd::MetadataBlock(_) => {
+                self.in_non_writing_block = false;
+                Ok(())
+            }
+        }
+    }
+
+    fn write_embed(
+        &mut self,
+        embed_type: EmbedType,
+        dest_url: CowStr<'_>,
+        title: CowStr<'_>,
+        id: CowStr<'_>,
+        attrs: Option<markdown_weaver::WeaverAttributes<'_>>,
+    ) -> Result<(), W::Error> {
+        // Try to get content from attributes first
+        let content_from_attrs = if let Some(ref attrs) = attrs {
+            attrs.attrs.iter()
+                .find(|(k, _)| k.as_ref() == "content")
+                .map(|(_, v)| v.as_ref().to_string())
+        } else {
+            None
+        };
+
+        // If no content in attrs, try provider
+        let content = if let Some(content) = content_from_attrs {
+            Some(content)
+        } else if let Some(ref provider) = self.embed_provider {
+            let tag = Tag::Embed {
+                embed_type,
+                dest_url: dest_url.clone(),
+                title: title.clone(),
+                id: id.clone(),
+                attrs: attrs.clone(),
+            };
+            provider.get_embed_content(&tag)
+        } else {
+            None
+        };
+
+        if let Some(html_content) = content {
+            // Write the pre-rendered content directly
+            self.write(&html_content)?;
+            self.write_newline()?;
+        } else {
+            // Fallback: render as iframe
+            self.write("<iframe src=\"")?;
+            escape_href(&mut self.writer, &dest_url)?;
+            self.write("\" title=\"")?;
+            escape_html(&mut self.writer, &title)?;
+            if !id.is_empty() {
+                self.write("\" id=\"")?;
+                escape_html(&mut self.writer, &id)?;
+            }
+            self.write("\"")?;
+
+            if let Some(attrs) = attrs {
+                if !attrs.classes.is_empty() {
+                    self.write(" class=\"")?;
+                    for (i, class) in attrs.classes.iter().enumerate() {
+                        if i > 0 {
+                            self.write(" ")?;
+                        }
+                        escape_html(&mut self.writer, class)?;
+                    }
+                    self.write("\"")?;
+                }
+                for (attr, value) in &attrs.attrs {
+                    // Skip the content attr in HTML output
+                    if attr.as_ref() != "content" {
+                        self.write(" ")?;
+                        escape_html(&mut self.writer, attr)?;
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, value)?;
+                        self.write("\"")?;
+                    }
+                }
+            }
+            self.write("></iframe>")?;
+        }
+
+        Ok(())
+    }
+}

crates/weaver-renderer/src/lib.rs

···
 use markdown_weaver::CowStr;
 use markdown_weaver::Event;
 use markdown_weaver::Tag;
-use n0_future::Stream;
 use n0_future::pin;
 use n0_future::stream::once_future;
+use n0_future::Stream;
 use yaml_rust2::Yaml;
 use yaml_rust2::YamlLoader;
 
···
         }
     }
 }
+
+pub fn default_md_options() -> markdown_weaver::Options {
+    markdown_weaver::Options::ENABLE_WIKILINKS
+        | markdown_weaver::Options::ENABLE_FOOTNOTES
+        | markdown_weaver::Options::ENABLE_TABLES
+        | markdown_weaver::Options::ENABLE_GFM
+        | markdown_weaver::Options::ENABLE_STRIKETHROUGH
+        | markdown_weaver::Options::ENABLE_YAML_STYLE_METADATA_BLOCKS
+        | markdown_weaver::Options::ENABLE_OBSIDIAN_EMBEDS
+        | markdown_weaver::Options::ENABLE_MATH
+        | markdown_weaver::Options::ENABLE_HEADING_ATTRIBUTES
+}

crates/weaver-renderer/src/static_site.rs

···
     path::{Path, PathBuf},
     sync::Arc,
 };
+use crate::utils::VaultBrokenLinkCallback;
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use tokio::io::AsyncWriteExt;
 use unicode_normalization::UnicodeNormalization;
···
     }
 }
 
-pub fn default_md_options() -> markdown_weaver::Options {
-    markdown_weaver::Options::ENABLE_WIKILINKS
-        | markdown_weaver::Options::ENABLE_FOOTNOTES
-        | markdown_weaver::Options::ENABLE_TABLES
-        | markdown_weaver::Options::ENABLE_GFM
-        | markdown_weaver::Options::ENABLE_STRIKETHROUGH
-        | markdown_weaver::Options::ENABLE_YAML_STYLE_METADATA_BLOCKS
-        | markdown_weaver::Options::ENABLE_OBSIDIAN_EMBEDS
-        | markdown_weaver::Options::ENABLE_MATH
-        | markdown_weaver::Options::ENABLE_HEADING_ATTRIBUTES
-}
 
 pub struct StaticSiteWriter<A>
 where
···
     Ok(())
 }
 
-/// Path lookup in an Obsidian vault
-///
-/// Credit to https://github.com/zoni
-///
-/// Taken from https://github.com/zoni/obsidian-export/blob/main/src/lib.rs.rs on 2025-05-21
-///
-pub fn lookup_filename_in_vault<'a>(
-    filename: &str,
-    vault_contents: &'a [PathBuf],
-) -> Option<&'a PathBuf> {
-    let filename = PathBuf::from(filename);
-    let filename_normalized: String = filename.to_string_lossy().nfc().collect();
 
-    vault_contents.iter().find(|path| {
-        let path_normalized_str: String = path.to_string_lossy().nfc().collect();
-        let path_normalized = PathBuf::from(&path_normalized_str);
-        let path_normalized_lowered = PathBuf::from(&path_normalized_str.to_lowercase());
-
-        // It would be convenient if we could just do `filename.set_extension("md")` at the start
-        // of this funtion so we don't need multiple separate + ".md" match cases here, however
-        // that would break with a reference of `[[Note.1]]` linking to `[[Note.1.md]]`.
-
-        path_normalized.ends_with(&filename_normalized)
-            || path_normalized.ends_with(filename_normalized.clone() + ".md")
-            || path_normalized_lowered.ends_with(filename_normalized.to_lowercase())
-            || path_normalized_lowered.ends_with(filename_normalized.to_lowercase() + ".md")
-    })
-}
-
-pub struct VaultBrokenLinkCallback {
-    vault_contents: Arc<[PathBuf]>,
-}
-
-impl<'input> markdown_weaver::BrokenLinkCallback<'input> for VaultBrokenLinkCallback {
-    fn handle_broken_link(
-        &mut self,
-        link: BrokenLink<'input>,
-    ) -> Option<(CowStr<'input>, CowStr<'input>)> {
-        let text = link.reference;
-        let captures = crate::OBSIDIAN_NOTE_LINK_RE
-            .captures(&text)
-            .expect("note link regex didn't match - bad input?");
-        let file = captures.name("file").map(|v| v.as_str().trim());
-        let label = captures.name("label").map(|v| v.as_str());
-        let section = captures.name("section").map(|v| v.as_str().trim());
-
-        if let Some(file) = file {
-            if let Some(path) = lookup_filename_in_vault(file, self.vault_contents.as_ref()) {
-                let mut link_text = String::from(path.to_string_lossy());
-                if let Some(section) = section {
-                    link_text.push('#');
-                    link_text.push_str(section);
-                    if let Some(label) = label {
-                        let label = label.to_string();
-                        Some((CowStr::from(link_text), CowStr::from(label)))
-                    } else {
-                        Some((link_text.into(), format!("{} > {}", file, section).into()))
-                    }
-                } else {
-                    Some((link_text.into(), format!("{}", file).into()))
-                }
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-}
 
 #[cfg(test)]
 mod tests;

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

···
-use crate::static_site::{StaticSiteOptions, default_md_options};
+use crate::static_site::{StaticSiteOptions};
 use crate::theme::Theme;
-use crate::{Frontmatter, NotebookContext};
+use crate::{Frontmatter, NotebookContext,default_md_options};
 use dashmap::DashMap;
 use markdown_weaver::{CowStr, EmbedType, Tag, WeaverAttributes};
 use std::{

crates/weaver-renderer/src/utils.rs

···
 use std::{path::Path, sync::OnceLock};
-
 use markdown_weaver::{CodeBlockKind, CowStr, Event, Tag};
 use miette::IntoDiagnostic;
 use n0_future::TryFutureExt;
 use regex::Regex;
+use markdown_weaver::BrokenLink;
+use std::path::PathBuf;
+use std::sync::Arc;
+use unicode_normalization::UnicodeNormalization;
 
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub async fn inline_file(path: impl AsRef<Path>) -> Option<String> {
···
         .into_diagnostic()?;
     Ok(file)
 }
+
+
+/// Path lookup in an Obsidian vault
+///
+/// Credit to https://github.com/zoni
+///
+/// Taken from https://github.com/zoni/obsidian-export/blob/main/src/lib.rs.rs on 2025-05-21
+///
+pub fn lookup_filename_in_vault<'a>(
+    filename: &str,
+    vault_contents: &'a [PathBuf],
+) -> Option<&'a PathBuf> {
+    let filename = PathBuf::from(filename);
+    let filename_normalized: String = filename.to_string_lossy().nfc().collect();
+
+    vault_contents.iter().find(|path| {
+        let path_normalized_str: String = path.to_string_lossy().nfc().collect();
+        let path_normalized = PathBuf::from(&path_normalized_str);
+        let path_normalized_lowered = PathBuf::from(&path_normalized_str.to_lowercase());
+
+        // It would be convenient if we could just do `filename.set_extension("md")` at the start
+        // of this funtion so we don't need multiple separate + ".md" match cases here, however
+        // that would break with a reference of `[[Note.1]]` linking to `[[Note.1.md]]`.
+
+        path_normalized.ends_with(&filename_normalized)
+            || path_normalized.ends_with(filename_normalized.clone() + ".md")
+            || path_normalized_lowered.ends_with(filename_normalized.to_lowercase())
+            || path_normalized_lowered.ends_with(filename_normalized.to_lowercase() + ".md")
+    })
+}
+
+pub struct VaultBrokenLinkCallback {
+    pub vault_contents: Arc<[PathBuf]>,
+}
+
+impl<'input> markdown_weaver::BrokenLinkCallback<'input> for VaultBrokenLinkCallback {
+    fn handle_broken_link(
+        &mut self,
+        link: BrokenLink<'input>,
+    ) -> Option<(CowStr<'input>, CowStr<'input>)> {
+        let text = link.reference;
+        let captures = crate::OBSIDIAN_NOTE_LINK_RE
+            .captures(&text)
+            .expect("note link regex didn't match - bad input?");
+        let file = captures.name("file").map(|v| v.as_str().trim());
+        let label = captures.name("label").map(|v| v.as_str());
+        let section = captures.name("section").map(|v| v.as_str().trim());
+
+        if let Some(file) = file {
+            if let Some(path) = lookup_filename_in_vault(file, self.vault_contents.as_ref()) {
+                let mut link_text = String::from(path.to_string_lossy());
+                if let Some(section) = section {
+                    link_text.push('#');
+                    link_text.push_str(section);
+                    if let Some(label) = label {
+                        let label = label.to_string();
+                        Some((CowStr::from(link_text), CowStr::from(label)))
+                    } else {
+                        Some((link_text.into(), format!("{} > {}", file, section).into()))
+                    }
+                } else {
+                    Some((link_text.into(), format!("{}", file).into()))
+                }
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+}

crates/weaver-renderer/tests/atproto_integration.rs

···
+// Integration tests for AT Protocol rendering pipeline
+//
+// These tests verify the full markdown→markdown transformation pipeline:
+// 1. Parse input markdown
+// 2. Process through AtProtoPreprocessContext
+// 3. Upload images to PDS
+// 4. Canonicalize wikilinks and profile links
+// 5. Write transformed markdown
+
+// NOTE: Full implementation pending processor streaming support
+// For now, these are placeholders that will be completed when:
+// - NotebookProcessor can stream events through contexts
+// - MarkdownWriter can consume event streams
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[ignore]
+    fn test_markdown_to_markdown_pipeline() {
+        // TODO: Implement once processor streaming is available
+        // This test should:
+        // 1. Create mock vault with test markdown files
+        // 2. Set up AtProtoPreprocessContext with test agent
+        // 3. Process markdown through the pipeline
+        // 4. Verify output contains canonical links
+        // 5. Verify blob tracking captured image metadata
+    }
+
+    #[test]
+    #[ignore]
+    fn test_wikilink_canonicalization() {
+        // TODO: Test that [[Entry Name]] becomes /{handle}/{notebook}/Entry_Name
+    }
+
+    #[test]
+    #[ignore]
+    fn test_image_upload_and_rewrite() {
+        // TODO: Test that ![alt](./image.png) uploads blob and rewrites to /{notebook}/image/{name}
+    }
+
+    #[test]
+    #[ignore]
+    fn test_profile_link_resolution() {
+        // TODO: Test that [[@handle]] resolves to /{handle}
+    }
+}