sync embed render methods (with sufficient context)

crates/weaver-renderer/src/atproto.rs

···
 
 pub use client::{ClientContext, DefaultEmbedResolver, EmbedResolver};
 pub use embed_renderer::{
+    // Async fetch-and-render functions (require agent/network)
     fetch_and_render, fetch_and_render_generic, fetch_and_render_post, fetch_and_render_profile,
+    // Pure sync render functions (pre-fetched data, no network)
+    render_generic_record, render_post_view, render_profile_data_view, render_record,
 };
 pub use error::{AtProtoPreprocessError, ClientRenderError};
 pub use markdown_writer::MarkdownWriter;

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

···
         let uri = AtUri::new("at://did:plc:xyz123/sh.weaver.notebook.entry/entry123").unwrap();
         assert_eq!(
             at_uri_to_web_url(&uri),
-            "https://alpha.weaver.sh/record/at://did:plc:xyz123/sh.weaver.notebook.entry/entry123"
+            "https://alpha.weaver.sh/did:plc:xyz123/e/entry123"
         );
     }
 

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

···
         .unwrap_or(false)
     {
         // blog.pckt.document wraps site.standard.document in a "document" field
-        let pckt_doc = jacquard::from_data::<weaver_api::blog_pckt::document::Document>(&output.value)
-            .map_err(|e| AtProtoPreprocessError::FetchFailed(format!("Parse error: {:?}", e)))?;
+        let pckt_doc =
+            jacquard::from_data::<weaver_api::blog_pckt::document::Document>(&output.value)
+                .map_err(|e| {
+                    AtProtoPreprocessError::FetchFailed(format!("Parse error: {:?}", e))
+                })?;
         pckt_doc.document
     } else {
         // Direct site.standard.document
···
 
     // Get author DID and handle from URI authority
     use jacquard::types::string::{Did, Handle};
-    let (author_did, author_handle): (Did<'static>, Option<Handle<'static>>) =
-        match uri.authority() {
-            jacquard::types::ident::AtIdentifier::Did(d) => {
-                let did = d.clone().into_static();
-                let handle = agent
-                    .resolve_did_doc_owned(d)
-                    .await
-                    .ok()
-                    .and_then(|doc| doc.handles().first().cloned());
-                (did, handle)
-            }
-            jacquard::types::ident::AtIdentifier::Handle(h) => {
-                let handle = Some(h.clone().into_static());
-                let did = agent
-                    .resolve_handle(h)
-                    .await
-                    .map(|d| d.into_static())
-                    .map_err(|e| {
-                        AtProtoPreprocessError::FetchFailed(format!(
-                            "Handle resolution failed: {:?}",
-                            e
-                        ))
-                    })?;
-                (did, handle)
-            }
-        };
+    let (author_did, author_handle): (Did<'static>, Option<Handle<'static>>) = match uri.authority()
+    {
+        jacquard::types::ident::AtIdentifier::Did(d) => {
+            let did = d.clone().into_static();
+            let handle = agent
+                .resolve_did_doc_owned(d)
+                .await
+                .ok()
+                .and_then(|doc| doc.handles().first().cloned());
+            (did, handle)
+        }
+        jacquard::types::ident::AtIdentifier::Handle(h) => {
+            let handle = Some(h.clone().into_static());
+            let did = agent
+                .resolve_handle(h)
+                .await
+                .map(|d| d.into_static())
+                .map_err(|e| {
+                    AtProtoPreprocessError::FetchFailed(format!(
+                        "Handle resolution failed: {:?}",
+                        e
+                    ))
+                })?;
+            (did, handle)
+        }
+    };
 
     let ctx = PcktRenderContext::new(author_did);
 
···
     let toggle_id = format!("pckt-toggle-{}", rkey);
 
     // Document path for URL (use path field if present, otherwise rkey)
-    let doc_path = doc
-        .path
-        .as_ref()
-        .map(|p| p.as_ref())
-        .unwrap_or(rkey);
+    let doc_path = doc.path.as_ref().map(|p| p.as_ref()).unwrap_or(rkey);
 
     let mut html = String::new();
     html.push_str("<div class=\"atproto-embed atproto-entry\" contenteditable=\"false\">");
···
     }
 }
 
-/// Render a profile from ProfileDataViewInner (weaver, bsky, or tangled)
-fn render_profile_data_view(
+/// Render any AT Protocol record synchronously from pre-fetched data.
+///
+/// This is the pure sync version of `fetch_and_render`. Takes a URI and the
+/// record data, dispatches to the appropriate renderer based on collection type.
+///
+/// # Arguments
+///
+/// * `uri` - The AT URI of the record
+/// * `data` - The record data (either raw record or hydrated view type)
+/// * `fallback_author` - Optional author profile to use when data is a raw record
+///   without embedded author info. Used for entries and other content types.
+/// * `resolved_content` - Optional pre-resolved embeds for rendering markdown with embeds
+///
+/// # Supported collections
+///
+/// **Profiles** (pass hydrated view from appview):
+/// - `app.bsky.actor.profile` - Bluesky profiles (ProfileViewDetailed from getProfile)
+/// - `sh.weaver.actor.profile` - Weaver profiles (ProfileView from weaver appview)
+/// - Tangled profiles also supported via type discriminator
+///
+/// **Posts**:
+/// - `app.bsky.feed.post` - Posts (PostView from getPosts, or raw record for basic)
+///
+/// **Entries** (pass view type for author info, or provide fallback_author):
+/// - `sh.weaver.notebook.entry` - Weaver entries (EntryView or raw Entry)
+/// - `com.whtwnd.blog.entry` - Whitewind entries
+/// - `pub.leaflet.document` - Leaflet documents
+/// - `site.standard.document` / `blog.pckt.document` - pckt documents
+///
+/// **Lists & Feeds**:
+/// - `app.bsky.graph.list` - User lists
+/// - `app.bsky.feed.generator` - Custom feeds
+/// - `app.bsky.graph.starterpack` - Starter packs
+/// - `app.bsky.labeler.service` - Labelers
+///
+/// **Other** - Generic field display for unknown types
+pub fn render_record(
+    uri: &AtUri<'_>,
+    data: &Data<'_>,
+    fallback_author: Option<&weaver_api::sh_weaver::actor::ProfileDataView<'_>>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> Result<String, AtProtoPreprocessError> {
+    let collection = uri.collection().map(|c| c.as_ref());
+
+    match collection {
+        // No collection = just an identity reference, try as profile
+        None => render_profile_from_data(data, uri),
+
+        // Profiles - try multiple profile view types
+        Some("app.bsky.actor.profile") | Some("sh.weaver.actor.profile") => {
+            render_profile_from_data(data, uri)
+        }
+
+        // Posts
+        Some("app.bsky.feed.post") => {
+            // Try PostView first (from getPosts), fall back to raw record
+            if let Ok(post_view) = jacquard::from_data::<PostView>(data) {
+                render_post_view(&post_view, uri)
+            } else {
+                render_basic_post(data, uri)
+            }
+        }
+
+        // Lists
+        Some("app.bsky.graph.list") => render_list_record(data, uri),
+
+        // Custom feeds
+        Some("app.bsky.feed.generator") => render_generator_record(data, uri),
+
+        // Starter packs
+        Some("app.bsky.graph.starterpack") => render_starterpack_record(data, uri),
+
+        // Labelers
+        Some("app.bsky.labeler.service") => render_labeler_record(data, uri),
+
+        // Weaver entries
+        Some("sh.weaver.notebook.entry") => {
+            render_weaver_entry_record(data, uri, fallback_author, resolved_content)
+        }
+
+        // Whitewind entries
+        Some("com.whtwnd.blog.entry") => {
+            render_whitewind_entry_record(data, uri, fallback_author, resolved_content)
+        }
+
+        // Leaflet documents
+        Some("pub.leaflet.document") => {
+            render_leaflet_record(data, uri, fallback_author, resolved_content)
+        }
+
+        // pckt / site.standard documents
+        #[cfg(feature = "pckt")]
+        Some("site.standard.document") | Some("blog.pckt.document") => {
+            render_site_standard_record(data, uri, fallback_author, resolved_content)
+        }
+
+        // Default: generic rendering
+        _ => render_generic_record(data, uri),
+    }
+}
+
+/// Try to render profile data by detecting the view type.
+fn render_profile_from_data(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    // Check type discriminator first for union types
+    if let Some(type_disc) = data.type_discriminator() {
+        match type_disc {
+            "app.bsky.actor.defs#profileViewDetailed" => {
+                if let Ok(profile) =
+                    jacquard::from_data::<weaver_api::app_bsky::actor::ProfileViewDetailed>(data)
+                {
+                    return render_profile_data_view(&ProfileDataViewInner::ProfileViewDetailed(
+                        Box::new(profile),
+                    ));
+                }
+            }
+            "sh.weaver.actor.defs#profileView" => {
+                if let Ok(profile) =
+                    jacquard::from_data::<weaver_api::sh_weaver::actor::ProfileView>(data)
+                {
+                    return render_profile_data_view(&ProfileDataViewInner::ProfileView(Box::new(
+                        profile,
+                    )));
+                }
+            }
+            "sh.weaver.actor.defs#tangledProfileView" => {
+                if let Ok(profile) =
+                    jacquard::from_data::<weaver_api::sh_weaver::actor::TangledProfileView>(data)
+                {
+                    return render_profile_data_view(&ProfileDataViewInner::TangledProfileView(
+                        Box::new(profile),
+                    ));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    // Try each type without discriminator
+    if let Ok(profile) =
+        jacquard::from_data::<weaver_api::app_bsky::actor::ProfileViewDetailed>(data)
+    {
+        return render_profile_data_view(&ProfileDataViewInner::ProfileViewDetailed(Box::new(
+            profile,
+        )));
+    }
+    if let Ok(profile) = jacquard::from_data::<weaver_api::sh_weaver::actor::ProfileView>(data) {
+        return render_profile_data_view(&ProfileDataViewInner::ProfileView(Box::new(profile)));
+    }
+    if let Ok(profile) =
+        jacquard::from_data::<weaver_api::sh_weaver::actor::TangledProfileView>(data)
+    {
+        return render_profile_data_view(&ProfileDataViewInner::TangledProfileView(Box::new(
+            profile,
+        )));
+    }
+
+    // Fall back to generic
+    render_generic_record(data, uri)
+}
+
+/// Render a list record.
+fn render_list_record(data: &Data<'_>, uri: &AtUri<'_>) -> Result<String, AtProtoPreprocessError> {
+    let list = match jacquard::from_data::<weaver_api::app_bsky::graph::list::List>(data) {
+        Ok(l) => l,
+        Err(_) => return render_generic_record(data, uri),
+    };
+
+    let mut html = String::new();
+    html.push_str("<span class=\"atproto-embed atproto-record\" contenteditable=\"false\">");
+    html.push_str("<span class=\"embed-type\">List</span>");
+    html.push_str("<span class=\"embed-author-name\">");
+    html.push_str(&html_escape(list.name.as_ref()));
+    html.push_str("</span>");
+    if let Some(desc) = &list.description {
+        html.push_str("<span class=\"embed-description\">");
+        html.push_str(&html_escape(desc.as_ref()));
+        html.push_str("</span>");
+    }
+    html.push_str("</span>");
+
+    Ok(html)
+}
+
+/// Render a feed generator record.
+fn render_generator_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    let generator =
+        match jacquard::from_data::<weaver_api::app_bsky::feed::generator::Generator>(data) {
+            Ok(g) => g,
+            Err(_) => return render_generic_record(data, uri),
+        };
+
+    let mut html = String::new();
+    html.push_str("<span class=\"atproto-embed atproto-record\" contenteditable=\"false\">");
+    html.push_str("<span class=\"embed-type\">Custom Feed</span>");
+    html.push_str("<span class=\"embed-author-name\">");
+    html.push_str(&html_escape(generator.display_name.as_ref()));
+    html.push_str("</span>");
+    if let Some(desc) = &generator.description {
+        html.push_str("<span class=\"embed-description\">");
+        html.push_str(&html_escape(desc.as_ref()));
+        html.push_str("</span>");
+    }
+    html.push_str("</span>");
+
+    Ok(html)
+}
+
+/// Render a starter pack record.
+fn render_starterpack_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    let sp =
+        match jacquard::from_data::<weaver_api::app_bsky::graph::starterpack::Starterpack>(data) {
+            Ok(s) => s,
+            Err(_) => return render_generic_record(data, uri),
+        };
+
+    let mut html = String::new();
+    html.push_str("<span class=\"atproto-embed atproto-record\" contenteditable=\"false\">");
+    html.push_str("<span class=\"embed-type\">Starter Pack</span>");
+    html.push_str("<span class=\"embed-author-name\">");
+    html.push_str(&html_escape(sp.name.as_ref()));
+    html.push_str("</span>");
+    if let Some(desc) = &sp.description {
+        html.push_str("<span class=\"embed-description\">");
+        html.push_str(&html_escape(desc.as_ref()));
+        html.push_str("</span>");
+    }
+    html.push_str("</span>");
+
+    Ok(html)
+}
+
+/// Render a labeler service record.
+fn render_labeler_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+) -> Result<String, AtProtoPreprocessError> {
+    let labeler = match jacquard::from_data::<weaver_api::app_bsky::labeler::service::Service>(data)
+    {
+        Ok(l) => l,
+        Err(_) => return render_generic_record(data, uri),
+    };
+
+    let mut html = String::new();
+    html.push_str("<span class=\"atproto-embed atproto-record\" contenteditable=\"false\">");
+    html.push_str("<span class=\"embed-type\">Labeler</span>");
+
+    // Labeler policies
+    html.push_str("<span class=\"embed-fields\">");
+    let label_count = labeler.policies.label_values.len();
+    html.push_str("<span class=\"embed-field\">");
+    html.push_str(&label_count.to_string());
+    html.push_str(" label");
+    if label_count != 1 {
+        html.push_str("s");
+    }
+    html.push_str(" defined</span>");
+    html.push_str("</span>");
+
+    html.push_str("</span>");
+
+    Ok(html)
+}
+
+/// Render a weaver notebook entry record.
+///
+/// Accepts either:
+/// - `EntryView` (from appview) - includes author info
+/// - Raw `Entry` record with optional fallback_author
+fn render_weaver_entry_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+    fallback_author: Option<&weaver_api::sh_weaver::actor::ProfileDataView<'_>>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> Result<String, AtProtoPreprocessError> {
+    use crate::atproto::writer::ClientWriter;
+    use crate::default_md_options;
+    use markdown_weaver::Parser;
+    use weaver_api::sh_weaver::notebook::EntryView;
+
+    // Try to parse as EntryView first (has author info), then raw Entry
+    let (title, content, author_handle): (String, String, Option<String>) = if let Ok(view) =
+        jacquard::from_data::<EntryView>(data)
+    {
+        // EntryView has embedded record data, extract content from it
+        let content = view
+            .record
+            .query("content")
+            .single()
+            .and_then(|d| d.as_str())
+            .unwrap_or_default()
+            .to_string();
+        let title = view
+            .record
+            .query("title")
+            .single()
+            .and_then(|d| d.as_str())
+            .unwrap_or_default()
+            .to_string();
+        let handle = view
+            .authors
+            .first()
+            .and_then(|author| extract_handle_from_profile_data_view(&author.record.inner));
+        (title, content, handle.map(|h| h.to_string()))
+    } else if let Ok(entry) =
+        jacquard::from_data::<weaver_api::sh_weaver::notebook::entry::Entry>(data)
+    {
+        let handle = fallback_author.and_then(|p| extract_handle_from_profile_data_view(&p.inner));
+        (
+            entry.title.as_ref().to_string(),
+            entry.content.as_ref().to_string(),
+            handle.map(|h| h.to_string()),
+        )
+    } else {
+        return render_generic_record(data, uri);
+    };
+
+    // Render markdown content to HTML using resolved_content for embeds
+    let parser = Parser::new_ext(&content, default_md_options()).into_offset_iter();
+    let mut content_html = String::new();
+    if let Some(resolved) = resolved_content {
+        ClientWriter::new(parser, &mut content_html, &content)
+            .with_embed_provider(resolved)
+            .run()
+            .map_err(|e| {
+                AtProtoPreprocessError::FetchFailed(format!("Markdown render failed: {:?}", e))
+            })?;
+    } else {
+        ClientWriter::<_, _, ()>::new(parser, &mut content_html, &content)
+            .run()
+            .map_err(|e| {
+                AtProtoPreprocessError::FetchFailed(format!("Markdown render failed: {:?}", e))
+            })?;
+    }
+
+    // Generate unique ID for the toggle checkbox
+    let rkey = uri.rkey().map(|r| r.as_ref()).unwrap_or("unknown");
+    let toggle_id = format!("entry-toggle-{}", rkey);
+
+    // Build the embed HTML - matches fetch_and_render_entry exactly
+    let mut html = String::new();
+    html.push_str("<div class=\"atproto-embed atproto-entry\" contenteditable=\"false\">");
+
+    // Hidden checkbox for expand/collapse (must come before content for CSS sibling selector)
+    html.push_str("<input type=\"checkbox\" class=\"embed-entry-toggle\" id=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\">");
+
+    // Header with title and author
+    html.push_str("<div class=\"embed-entry-header\">");
+
+    // Title
+    html.push_str("<span class=\"embed-entry-title\">");
+    html.push_str(&html_escape(&title));
+    html.push_str("</span>");
+
+    // Author info - just show handle (keep it simple for entry embeds)
+    if let Some(ref handle) = author_handle {
+        if !handle.is_empty() {
+            html.push_str("<span class=\"embed-entry-author\">@");
+            html.push_str(&html_escape(handle));
+            html.push_str("</span>");
+        }
+    }
+
+    html.push_str("</div>"); // end header
+
+    // Scrollable content container
+    html.push_str("<div class=\"embed-entry-content\">");
+    html.push_str(&content_html);
+    html.push_str("</div>");
+
+    // Expand/collapse label (clickable, targets the checkbox)
+    html.push_str("<label class=\"embed-entry-expand\" for=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\"></label>");
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Extract handle from ProfileDataViewInner.
+fn extract_handle_from_profile_data_view<'a>(
+    inner: &'a ProfileDataViewInner<'a>,
+) -> Option<&'a str> {
+    match inner {
+        ProfileDataViewInner::ProfileView(p) => Some(p.handle.as_ref()),
+        ProfileDataViewInner::ProfileViewDetailed(p) => Some(p.handle.as_ref()),
+        ProfileDataViewInner::TangledProfileView(p) => Some(p.handle.as_ref()),
+        ProfileDataViewInner::Unknown(_) => None,
+    }
+}
+
+fn extract_did_from_profile_data_view(
+    inner: &ProfileDataViewInner<'_>,
+) -> Option<jacquard::types::string::Did<'static>> {
+    use jacquard::IntoStatic;
+    match inner {
+        ProfileDataViewInner::ProfileView(p) => Some(p.did.clone().into_static()),
+        ProfileDataViewInner::ProfileViewDetailed(p) => Some(p.did.clone().into_static()),
+        ProfileDataViewInner::TangledProfileView(p) => Some(p.did.clone().into_static()),
+        ProfileDataViewInner::Unknown(_) => None,
+    }
+}
+
+/// Render a whitewind blog entry record.
+///
+/// Whitewind entries don't have a view type, so author info comes from fallback_author.
+fn render_whitewind_entry_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+    fallback_author: Option<&weaver_api::sh_weaver::actor::ProfileDataView<'_>>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> Result<String, AtProtoPreprocessError> {
+    use crate::atproto::writer::ClientWriter;
+    use crate::default_md_options;
+    use markdown_weaver::Parser;
+
+    let entry = match jacquard::from_data::<weaver_api::com_whtwnd::blog::entry::Entry>(data) {
+        Ok(e) => e,
+        Err(_) => return render_generic_record(data, uri),
+    };
+
+    // Render the markdown content to HTML using resolved_content for embeds
+    let content = entry.content.as_ref();
+    let parser = Parser::new_ext(content, default_md_options()).into_offset_iter();
+    let mut content_html = String::new();
+    if let Some(resolved) = resolved_content {
+        ClientWriter::new(parser, &mut content_html, content)
+            .with_embed_provider(resolved)
+            .run()
+            .map_err(|e| {
+                AtProtoPreprocessError::FetchFailed(format!("Markdown render failed: {:?}", e))
+            })?;
+    } else {
+        ClientWriter::<_, _, ()>::new(parser, &mut content_html, content)
+            .run()
+            .map_err(|e| {
+                AtProtoPreprocessError::FetchFailed(format!("Markdown render failed: {:?}", e))
+            })?;
+    }
+
+    // Generate unique ID for the toggle checkbox
+    let rkey = uri.rkey().map(|r| r.as_ref()).unwrap_or("unknown");
+    let toggle_id = format!("entry-toggle-{}", rkey);
+
+    // Build the embed HTML - matches fetch_and_render_whitewind_entry exactly
+    let mut html = String::new();
+    html.push_str("<div class=\"atproto-embed atproto-entry\" contenteditable=\"false\">");
+
+    // Hidden checkbox for expand/collapse (must come before content for CSS sibling selector)
+    html.push_str("<input type=\"checkbox\" class=\"embed-entry-toggle\" id=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\">");
+
+    // Header with title and author
+    html.push_str("<div class=\"embed-entry-header\">");
+
+    // Title
+    html.push_str("<span class=\"embed-entry-title\">");
+    html.push_str(&html_escape(
+        entry.title.as_ref().map(|t| t.as_ref()).unwrap_or(""),
+    ));
+    html.push_str("</span>");
+
+    // Author info - just show handle (keep it simple for entry embeds)
+    if let Some(author) = fallback_author {
+        let handle = extract_handle_from_profile_data_view(&author.inner).unwrap_or("");
+        if !handle.is_empty() {
+            html.push_str("<span class=\"embed-entry-author\">@");
+            html.push_str(&html_escape(handle));
+            html.push_str("</span>");
+        }
+    }
+
+    html.push_str("</div>"); // end header
+
+    // Scrollable content container
+    html.push_str("<div class=\"embed-entry-content\">");
+    html.push_str(&content_html);
+    html.push_str("</div>");
+
+    // Expand/collapse label (clickable, targets the checkbox)
+    html.push_str("<label class=\"embed-entry-expand\" for=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\"></label>");
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Render a leaflet document record.
+///
+/// Uses the sync block renderer to render page content directly. Embedded posts
+/// within the document will be looked up from resolved_content by their AT URI.
+fn render_leaflet_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+    fallback_author: Option<&weaver_api::sh_weaver::actor::ProfileDataView<'_>>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> Result<String, AtProtoPreprocessError> {
+    use crate::leaflet::{LeafletRenderContext, render_linear_document_sync};
+    use weaver_api::pub_leaflet::document::{Document, DocumentPagesItem};
+
+    let doc = match jacquard::from_data::<Document>(data) {
+        Ok(d) => d,
+        Err(_) => return render_generic_record(data, uri),
+    };
+
+    // Get author DID from fallback_author or from document/URI.
+    let author_did = if let Some(author) = fallback_author {
+        extract_did_from_profile_data_view(&author.inner)
+    } else {
+        None
+    }
+    .or_else(|| {
+        // Try to get DID from document author field.
+        match &doc.author {
+            jacquard::types::ident::AtIdentifier::Did(d) => Some(d.clone().into_static()),
+            _ => None,
+        }
+    })
+    .or_else(|| {
+        // Fall back to URI authority if it's a DID.
+        jacquard::types::string::Did::new(uri.authority().as_ref())
+            .ok()
+            .map(|d| d.into_static())
+    });
+
+    let ctx = author_did
+        .map(LeafletRenderContext::new)
+        .unwrap_or_else(|| {
+            LeafletRenderContext::new(jacquard::types::string::Did::raw("did:plc:unknown".into()))
+        });
+
+    // Generate unique toggle ID.
+    let rkey = uri.rkey().map(|r| r.as_ref()).unwrap_or("unknown");
+    let toggle_id = format!("leaflet-toggle-{}", rkey);
+
+    let mut html = String::new();
+    html.push_str("<div class=\"atproto-embed atproto-entry\" contenteditable=\"false\">");
+
+    // Hidden checkbox for expand/collapse.
+    html.push_str("<input type=\"checkbox\" class=\"embed-entry-toggle\" id=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\">");
+
+    // Header with title and author.
+    html.push_str("<div class=\"embed-entry-header\">");
+
+    // Title (no link in sync version since we don't have publication base_path).
+    html.push_str("<span class=\"embed-entry-title\">");
+    html.push_str(&html_escape(doc.title.as_ref()));
+    html.push_str("</span>");
+
+    // Author info.
+    if let Some(author) = fallback_author {
+        let handle = extract_handle_from_profile_data_view(&author.inner).unwrap_or("");
+        if !handle.is_empty() {
+            html.push_str("<span class=\"embed-entry-author\">@");
+            html.push_str(&html_escape(handle));
+            html.push_str("</span>");
+        }
+    }
+
+    html.push_str("</div>"); // end header
+
+    // Scrollable content container.
+    html.push_str("<div class=\"embed-entry-content\">");
+
+    // Render each page using the sync block renderer.
+    for page in &doc.pages {
+        match page {
+            DocumentPagesItem::LinearDocument(linear_doc) => {
+                html.push_str(&render_linear_document_sync(
+                    linear_doc,
+                    &ctx,
+                    resolved_content,
+                ));
+            }
+            DocumentPagesItem::Canvas(_) => {
+                html.push_str(
+                    "<div class=\"embed-video-placeholder\">[Canvas layout not yet supported]</div>",
+                );
+            }
+            DocumentPagesItem::Unknown(_) => {
+                html.push_str("<div class=\"embed-video-placeholder\">[Unknown page type]</div>");
+            }
+        }
+    }
+
+    html.push_str("</div>"); // end content
+
+    // Expand/collapse label.
+    html.push_str("<label class=\"embed-entry-expand\" for=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\"></label>");
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Render a site.standard or blog.pckt document record.
+///
+/// Uses the sync block renderer to render content blocks directly. Embedded posts
+/// within the document will be looked up from resolved_content by their AT URI.
+#[cfg(feature = "pckt")]
+fn render_site_standard_record(
+    data: &Data<'_>,
+    uri: &AtUri<'_>,
+    fallback_author: Option<&weaver_api::sh_weaver::actor::ProfileDataView<'_>>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> Result<String, AtProtoPreprocessError> {
+    use crate::pckt::{PcktRenderContext, render_content_blocks_sync};
+    use weaver_api::site_standard::document::Document as SiteStandardDocument;
+
+    // Extract the document - either directly or from blog.pckt.document wrapper.
+    let doc: SiteStandardDocument<'_> = if data
+        .type_discriminator()
+        .map(|t| t == "blog.pckt.document")
+        .unwrap_or(false)
+    {
+        let pckt_doc = match jacquard::from_data::<weaver_api::blog_pckt::document::Document>(data)
+        {
+            Ok(d) => d,
+            Err(_) => return render_generic_record(data, uri),
+        };
+        pckt_doc.document
+    } else {
+        match jacquard::from_data::<SiteStandardDocument>(data) {
+            Ok(d) => d,
+            Err(_) => return render_generic_record(data, uri),
+        }
+    };
+
+    // Get author DID from fallback_author or from URI authority.
+    let author_did = if let Some(author) = fallback_author {
+        extract_did_from_profile_data_view(&author.inner)
+    } else {
+        None
+    }
+    .or_else(|| {
+        // Fall back to URI authority if it's a DID.
+        jacquard::types::string::Did::new(uri.authority().as_ref())
+            .ok()
+            .map(|d| d.into_static())
+    });
+
+    let ctx = author_did.map(PcktRenderContext::new).unwrap_or_else(|| {
+        PcktRenderContext::new(jacquard::types::string::Did::unchecked(
+            "did:plc:unknown".into(),
+        ))
+    });
+
+    let rkey = uri.rkey().map(|r| r.as_ref()).unwrap_or("unknown");
+    let toggle_id = format!("pckt-toggle-{}", rkey);
+
+    let mut html = String::new();
+    html.push_str("<div class=\"atproto-embed atproto-entry\" contenteditable=\"false\">");
+
+    // Toggle checkbox.
+    html.push_str("<input type=\"checkbox\" class=\"embed-entry-toggle\" id=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\">");
+
+    // Header.
+    html.push_str("<div class=\"embed-entry-header\">");
+    html.push_str("<span class=\"embed-entry-title\">");
+    html.push_str(&html_escape(doc.title.as_ref()));
+    html.push_str("</span>");
+
+    // Author info.
+    if let Some(author) = fallback_author {
+        let handle = extract_handle_from_profile_data_view(&author.inner).unwrap_or("");
+        if !handle.is_empty() {
+            html.push_str("<span class=\"embed-entry-author\">@");
+            html.push_str(&html_escape(handle));
+            html.push_str("</span>");
+        }
+    }
+
+    html.push_str("</div>");
+
+    // Content.
+    html.push_str("<div class=\"embed-entry-content\">");
+    if let Some(content) = &doc.content {
+        // Render actual content blocks using the sync renderer.
+        html.push_str(&render_content_blocks_sync(content, &ctx, resolved_content));
+    } else if let Some(text_content) = &doc.text_content {
+        // Fallback to text_content if no structured blocks.
+        html.push_str("<p>");
+        html.push_str(&html_escape(text_content.as_ref()));
+        html.push_str("</p>");
+    }
+    html.push_str("</div>");
+
+    // Expand label.
+    html.push_str("<label class=\"embed-entry-expand\" for=\"");
+    html.push_str(&toggle_id);
+    html.push_str("\"></label>");
+
+    html.push_str("</div>");
+
+    Ok(html)
+}
+
+/// Render a basic post from record data (no engagement stats or author info).
+///
+/// This is a simpler version than `render_post_view` for cases where you only
+/// have the raw record, not the full PostView from the appview.
+fn render_basic_post(data: &Data<'_>, uri: &AtUri<'_>) -> Result<String, AtProtoPreprocessError> {
+    let mut html = String::new();
+
+    // Try to parse as Post
+    let post = jacquard::from_data::<weaver_api::app_bsky::feed::post::Post>(data)
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(format!("Parse error: {:?}", e)))?;
+
+    // Build link to post on Bluesky
+    let authority = uri.authority();
+    let rkey = uri.rkey().map(|r| r.as_ref()).unwrap_or("");
+    let bsky_link = format!("https://bsky.app/profile/{}/post/{}", authority, rkey);
+
+    html.push_str("<span class=\"atproto-embed atproto-post\" contenteditable=\"false\">");
+
+    // Background link
+    html.push_str("<a class=\"embed-card-link\" href=\"");
+    html.push_str(&html_escape(&bsky_link));
+    html.push_str("\" target=\"_blank\" rel=\"noopener\" aria-label=\"View post on Bluesky\"></a>");
+
+    // Post text
+    html.push_str("<span class=\"embed-content\">");
+    html.push_str(&html_escape(post.text.as_ref()));
+    html.push_str("</span>");
+
+    // Timestamp
+    html.push_str("<span class=\"embed-meta\">");
+    html.push_str("<span class=\"embed-time\">");
+    html.push_str(&html_escape(&post.created_at.to_string()));
+    html.push_str("</span>");
+    html.push_str("</span>");
+
+    html.push_str("</span>");
+
+    Ok(html)
+}
+
+/// Render a profile from ProfileDataViewInner (weaver, bsky, or tangled).
+///
+/// Takes pre-fetched profile data - no network calls.
+pub fn render_profile_data_view(
     inner: &ProfileDataViewInner<'_>,
 ) -> Result<String, AtProtoPreprocessError> {
     let mut html = String::new();
···
     Ok(html)
 }
 
-/// Render a Bluesky post from PostView (rich appview data)
-fn render_post_view<'a>(
+/// Render a Bluesky post from PostView (rich appview data).
+///
+/// Takes pre-fetched PostView from getPosts - no network calls.
+pub fn render_post_view<'a>(
     post: &PostView<'a>,
     uri: &AtUri<'_>,
 ) -> Result<String, AtProtoPreprocessError> {
···
     Ok(html)
 }
 
-/// Render a generic record by probing Data for meaningful fields
-fn render_generic_record(
+/// Render a generic record by probing Data for meaningful fields.
+///
+/// Takes pre-fetched record data - no network calls.
+/// Probes for common fields like name, title, text, description.
+pub fn render_generic_record(
     data: &Data<'_>,
     uri: &AtUri<'_>,
 ) -> Result<String, AtProtoPreprocessError> {

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

···
 
 use jacquard::types::string::AtUri;
 use markdown_weaver::{
-    Alignment, BlockQuoteKind, CodeBlockKind, CowStr, EmbedType, Event, LinkType,
-    ParagraphContext, Tag, WeaverAttributes,
+    Alignment, BlockQuoteKind, CodeBlockKind, CowStr, EmbedType, Event, LinkType, ParagraphContext,
+    Tag, WeaverAttributes,
 };
 use markdown_weaver_escape::{StrWrite, escape_href, escape_html, escape_html_body_text};
 use std::collections::HashMap;
···
     Div,
 }
 
-/// Synchronous callback for injecting embed content
+/// 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>;
+    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<&str>;
 }
 
 impl EmbedContentProvider for () {
-    fn get_embed_content(&self, _tag: &Tag<'_>) -> Option<String> {
+    fn get_embed_content(&self, _tag: &Tag<'_>) -> Option<&str> {
         None
     }
 }
 
 impl EmbedContentProvider for ResolvedContent {
-    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<String> {
+    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<&str> {
         let url = match tag {
             Tag::Embed { dest_url, .. } => Some(dest_url.as_ref()),
-            // WikiLink images with at:// URLs are embeds in disguise
+            // WikiLink images with at:// URLs are embeds in disguise.
             Tag::Image {
                 link_type: LinkType::WikiLink { .. },
                 dest_url,
···
         if let Some(url) = url {
             if url.starts_with("at://") {
                 if let Ok(at_uri) = AtUri::new(url) {
-                    return self.get_embed_content(&at_uri).map(|s| s.to_string());
+                    // Call the inherent method which returns Option<&str>.
+                    return ResolvedContent::get_embed_content(self, &at_uri);
                 }
             }
         }
···
     }
 }
 
+impl EmbedContentProvider for &ResolvedContent {
+    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<&str> {
+        <ResolvedContent as EmbedContentProvider>::get_embed_content(*self, tag)
+    }
+}
+
 /// Simple writer that outputs HTML from markdown events
 ///
 /// This writer is designed for client-side rendering where embeds may have
···
                 if checked {
                     self.write("<input disabled=\"\" type=\"checkbox\" checked=\"\" aria-label=\"Completed task\"/>\n")?;
                 } else {
-                    self.write("<input disabled=\"\" type=\"checkbox\" aria-label=\"Incomplete task\"/>\n")?;
+                    self.write(
+                        "<input disabled=\"\" type=\"checkbox\" aria-label=\"Incomplete task\"/>\n",
+                    )?;
                 }
             }
             WeaverBlock(text) => {
···
                     && (dest_url.starts_with("at://") || dest_url.starts_with("did:"))
                 {
                     tracing::debug!("[ClientWriter] AT embed image detected: {}", dest_url);
-                    if let Some(embed_provider) = &self.embed_provider {
+                    if let Some(ref embed_provider) = self.embed_provider {
                         if let Some(html) = embed_provider.get_embed_content(&tag) {
                             tracing::debug!("[ClientWriter] Got embed content for {}", dest_url);
-                            // Consume events without writing - we're replacing with embed HTML
+                            // Use direct field access to avoid borrow conflict.
+                            self.writer.write_str(html)?;
+                            self.end_newline = html.ends_with('\n');
+                            // Consume events without writing - we've replaced with embed HTML.
                             self.consume_until_end();
-                            return self.write(&html);
+                            return Ok(());
                         } else {
                             tracing::debug!(
                                 "[ClientWriter] No embed content from provider for {}",
···
         }
     }
 
-    fn end_tag(&mut self, tag: markdown_weaver::TagEnd, range: Range<usize>) -> Result<(), W::Error> {
+    fn end_tag(
+        &mut self,
+        tag: markdown_weaver::TagEnd,
+        range: Range<usize>,
+    ) -> Result<(), W::Error> {
         use markdown_weaver::TagEnd;
         match tag {
             TagEnd::HtmlBlock => self.write("</span>\n"),
···
         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
-        };
+        // Try to get content from attributes first.
+        let content_from_attrs: Option<&str> = attrs
+            .as_ref()
+            .and_then(|a| a.attrs.iter().find(|(k, _)| k.as_ref() == "content"))
+            .map(|(_, v)| v.as_ref());
 
-        // If no content in attrs, try provider
-        let content = if let Some(content) = content_from_attrs {
-            Some(content)
+        // Write content if found in attrs, otherwise try provider, otherwise fallback.
+        if let Some(content) = content_from_attrs {
+            self.write(content)?;
+            self.write_newline()?;
         } else if let Some(ref provider) = self.embed_provider {
             let tag = Tag::Embed {
                 embed_type,
···
                 id: id.clone(),
                 attrs: attrs.clone(),
             };
-            provider.get_embed_content(&tag)
+            if let Some(content) = provider.get_embed_content(&tag) {
+                // Use direct field access to avoid borrow conflict:
+                // `provider` borrows self.embed_provider, `content` borrows from provider,
+                // but self.writer is a different field so we can borrow it independently.
+                self.writer.write_str(content)?;
+                self.end_newline = content.ends_with('\n');
+                self.writer.write_str("\n")?;
+                self.end_newline = true;
+            } else {
+                self.write_embed_fallback(&dest_url, &title, &id, attrs.as_ref())?;
+            }
         } else {
-            None
-        };
+            self.write_embed_fallback(&dest_url, &title, &id, attrs.as_ref())?;
+        }
+        Ok(())
+    }
 
-        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("\"")?;
+    fn write_embed_fallback(
+        &mut self,
+        dest_url: &str,
+        title: &str,
+        id: &str,
+        attrs: Option<&markdown_weaver::WeaverAttributes<'_>>,
+    ) -> Result<(), W::Error> {
+        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)?;
+        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("\"")?;
                 }
-                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(())
+        self.write("></iframe>")
     }
 }

crates/weaver-renderer/src/leaflet/block_renderer.rs

···
         .and_then(|s| s.split('/').next())
         .unwrap_or(url)
 }
+
+/// Sync version of render_linear_document that uses pre-resolved embeds.
+pub fn render_linear_document_sync(
+    doc: &LinearDocument<'_>,
+    ctx: &LeafletRenderContext,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> String {
+    let mut html = String::new();
+    html.push_str("<div class=\"leaflet-document\">");
+
+    for block in &doc.blocks {
+        html.push_str(&render_block_sync(block, ctx, resolved_content));
+    }
+
+    html.push_str("</div>");
+    html
+}
+
+/// Sync version of render_block that uses pre-resolved embeds for BskyPost blocks.
+pub fn render_block_sync(
+    block: &Block<'_>,
+    ctx: &LeafletRenderContext,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> String {
+    let mut html = String::new();
+
+    let alignment_class = block
+        .alignment
+        .as_ref()
+        .map(|a| match a.as_ref() {
+            "pub.leaflet.pages.linearDocument#textAlignCenter" => " align-center",
+            "pub.leaflet.pages.linearDocument#textAlignRight" => " align-right",
+            "pub.leaflet.pages.linearDocument#textAlignJustify" => " align-justify",
+            _ => "",
+        })
+        .unwrap_or("");
+
+    match &block.block {
+        BlockBlock::Text(text) => {
+            render_text_block(&mut html, text, alignment_class);
+        }
+        BlockBlock::Header(header) => {
+            render_header_block(&mut html, header, alignment_class);
+        }
+        BlockBlock::Blockquote(quote) => {
+            render_blockquote_block(&mut html, quote);
+        }
+        BlockBlock::Code(code) => {
+            render_code_block(&mut html, code);
+        }
+        BlockBlock::UnorderedList(list) => {
+            render_unordered_list_sync(&mut html, list, ctx, resolved_content);
+        }
+        BlockBlock::Image(image) => {
+            render_image_block(&mut html, image, ctx);
+        }
+        BlockBlock::Website(website) => {
+            render_website_block(&mut html, website, ctx);
+        }
+        BlockBlock::Iframe(iframe) => {
+            render_iframe_block(&mut html, iframe);
+        }
+        BlockBlock::BskyPost(post) => {
+            render_bsky_post_block_sync(&mut html, post, resolved_content);
+        }
+        BlockBlock::Button(button) => {
+            render_button_block(&mut html, button);
+        }
+        BlockBlock::Poll(poll) => {
+            render_poll_block(&mut html, poll);
+        }
+        BlockBlock::HorizontalRule(_) => {
+            html.push_str("<hr />\n");
+        }
+        BlockBlock::Page(page) => {
+            render_page_block(&mut html, page);
+        }
+        BlockBlock::Math(math) => {
+            render_math_block(&mut html, math);
+        }
+        BlockBlock::Unknown(data) => {
+            let _ = write!(
+                html,
+                "<div class=\"embed-unknown\">[Unknown block: {:?}]</div>\n",
+                data.type_discriminator()
+            );
+        }
+    }
+
+    html
+}
+
+fn render_unordered_list_sync(
+    html: &mut String,
+    list: &UnorderedList<'_>,
+    ctx: &LeafletRenderContext,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) {
+    html.push_str("<ul>\n");
+    for item in &list.children {
+        render_list_item_sync(html, item, ctx, resolved_content);
+    }
+    html.push_str("</ul>\n");
+}
+
+fn render_list_item_sync(
+    html: &mut String,
+    item: &ListItem<'_>,
+    ctx: &LeafletRenderContext,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) {
+    html.push_str("<li>");
+
+    match &item.content {
+        ListItemContent::Text(text) => {
+            html.push_str(&render_faceted_text(
+                &text.plaintext,
+                text.facets.as_deref(),
+            ));
+        }
+        ListItemContent::Header(header) => {
+            let level = header.level.unwrap_or(1).clamp(1, 6);
+            let _ = write!(html, "<h{}>", level);
+            html.push_str(&render_faceted_text(
+                &header.plaintext,
+                header.facets.as_deref(),
+            ));
+            let _ = write!(html, "</h{}>", level);
+        }
+        ListItemContent::Image(image) => {
+            render_image_inline(html, image, ctx);
+        }
+        ListItemContent::Unknown(data) => {
+            let _ = write!(html, "[Unknown: {:?}]", data.type_discriminator());
+        }
+    }
+
+    if let Some(children) = &item.children {
+        html.push_str("\n<ul>\n");
+        for child in children {
+            render_list_item_sync(html, child, ctx, resolved_content);
+        }
+        html.push_str("</ul>\n");
+    }
+
+    html.push_str("</li>\n");
+}
+
+fn render_bsky_post_block_sync(
+    html: &mut String,
+    post: &BskyPost<'_>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) {
+    let uri_str = post.post_ref.uri.as_ref();
+
+    // Look up pre-rendered content.
+    if let Some(resolved) = resolved_content {
+        if let Ok(at_uri) = AtUri::new(uri_str) {
+            if let Some(rendered) = resolved.get_embed_content(&at_uri) {
+                html.push_str(rendered);
+                return;
+            }
+        }
+    }
+
+    // Fallback: use bsky embed iframe.
+    // Format: at://did/app.bsky.feed.post/rkey -> https://bsky.app/profile/did/post/rkey
+    if let Some(rest) = uri_str.strip_prefix("at://") {
+        if let Some((did, path)) = rest.split_once('/') {
+            if let Some(rkey) = path.strip_prefix("app.bsky.feed.post/") {
+                html.push_str("<iframe class=\"bsky-embed-iframe\" src=\"https://embed.bsky.app/embed/");
+                let _ = escape_html(&mut *html, did);
+                html.push_str("/post/");
+                let _ = escape_html(&mut *html, rkey);
+                html.push_str("\" frameborder=\"0\" scrolling=\"no\" loading=\"lazy\" style=\"border: none; width: 100%; height: 240px;\"></iframe>\n");
+                return;
+            }
+        }
+    }
+
+    // Last resort: placeholder.
+    html.push_str("<div class=\"embed-video-placeholder\" data-aturi=\"");
+    let _ = escape_html(&mut *html, uri_str);
+    html.push_str("\">[Bluesky Post: ");
+    let _ = escape_html(&mut *html, uri_str);
+    html.push_str("]</div>\n");
+}

crates/weaver-renderer/src/leaflet/mod.rs

···
 mod block_renderer;
 mod markdown_converter;
 
-pub use block_renderer::{render_block, render_linear_document, LeafletRenderContext};
+pub use block_renderer::{
+    render_block, render_block_sync, render_linear_document, render_linear_document_sync,
+    LeafletRenderContext,
+};
 pub use markdown_converter::{convert_block, convert_linear_document, LeafletMarkdownContext};

crates/weaver-renderer/src/pckt/block_renderer.rs

···
         escaped
     }
 }
+
+/// Sync version of render_content_blocks that uses pre-resolved embeds.
+pub fn render_content_blocks_sync(
+    blocks: &[jacquard::types::value::Data<'_>],
+    ctx: &PcktRenderContext,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) -> String {
+    let mut html = String::new();
+    html.push_str("<div class=\"pckt-document\">");
+    for block in blocks {
+        render_block_sync(&mut html, block, ctx, resolved_content);
+    }
+    html.push_str("</div>");
+    html
+}
+
+/// Sync version of render_block that uses pre-resolved embeds for BlueskyEmbed blocks.
+pub fn render_block_sync(
+    html: &mut String,
+    block: &jacquard::types::value::Data<'_>,
+    ctx: &PcktRenderContext,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) {
+    let Some(type_tag) = block.type_discriminator() else {
+        return;
+    };
+
+    match type_tag {
+        "blog.pckt.block.text" => {
+            if let Ok(text) = jacquard::from_data::<Text>(block) {
+                render_text_block(html, &text);
+            }
+        }
+        "blog.pckt.block.heading" => {
+            if let Ok(heading) = jacquard::from_data::<Heading>(block) {
+                render_heading_block(html, &heading);
+            }
+        }
+        "blog.pckt.block.blockquote" => {
+            if let Ok(quote) = jacquard::from_data::<Blockquote>(block) {
+                render_blockquote_block(html, &quote);
+            }
+        }
+        "blog.pckt.block.codeBlock" => {
+            if let Ok(code) = jacquard::from_data::<CodeBlock>(block) {
+                render_code_block(html, &code);
+            }
+        }
+        "blog.pckt.block.bulletList" => {
+            if let Ok(list) = jacquard::from_data::<BulletList>(block) {
+                render_bullet_list(html, &list, ctx);
+            }
+        }
+        "blog.pckt.block.orderedList" => {
+            if let Ok(list) = jacquard::from_data::<OrderedList>(block) {
+                render_ordered_list(html, &list, ctx);
+            }
+        }
+        "blog.pckt.block.image" => {
+            if let Ok(image) = jacquard::from_data::<Image>(block) {
+                render_image_block(html, &image, ctx);
+            }
+        }
+        "blog.pckt.block.website" => {
+            if let Ok(website) = jacquard::from_data::<Website>(block) {
+                render_website_block(html, &website);
+            }
+        }
+        "blog.pckt.block.iframe" => {
+            if let Ok(iframe) = jacquard::from_data::<Iframe>(block) {
+                render_iframe_block(html, &iframe);
+            }
+        }
+        "blog.pckt.block.blueskyEmbed" => {
+            if let Ok(embed) = jacquard::from_data::<BlueskyEmbed>(block) {
+                render_bluesky_embed_sync(html, &embed, resolved_content);
+            }
+        }
+        "blog.pckt.block.horizontalRule" => {
+            if jacquard::from_data::<HorizontalRule>(block).is_ok() {
+                html.push_str("<hr>\n");
+            }
+        }
+        _ => {
+            tracing::debug!("Unknown pckt block type: {}", type_tag);
+        }
+    }
+}
+
+fn render_bluesky_embed_sync(
+    html: &mut String,
+    embed: &BlueskyEmbed<'_>,
+    resolved_content: Option<&weaver_common::ResolvedContent>,
+) {
+    let uri_str = embed.post_ref.uri.as_ref();
+
+    // Look up pre-rendered content.
+    if let Some(resolved) = resolved_content {
+        if let Ok(at_uri) = AtUri::new(uri_str) {
+            if let Some(rendered) = resolved.get_embed_content(&at_uri) {
+                html.push_str(rendered);
+                return;
+            }
+        }
+    }
+
+    // Fallback: use bsky embed iframe.
+    // Format: at://did/app.bsky.feed.post/rkey -> https://embed.bsky.app/embed/did/post/rkey
+    if let Some(rest) = uri_str.strip_prefix("at://") {
+        if let Some((did, path)) = rest.split_once('/') {
+            if let Some(rkey) = path.strip_prefix("app.bsky.feed.post/") {
+                html.push_str("<iframe class=\"bsky-embed-iframe\" src=\"https://embed.bsky.app/embed/");
+                let _ = escape_html(&mut *html, did);
+                html.push_str("/post/");
+                let _ = escape_html(&mut *html, rkey);
+                html.push_str("\" frameborder=\"0\" scrolling=\"no\" loading=\"lazy\" style=\"border: none; width: 100%; height: 240px;\"></iframe>\n");
+                return;
+            }
+        }
+    }
+
+    // Last resort: placeholder link.
+    html.push_str("<div class=\"bsky-embed-placeholder\">");
+    html.push_str("<a href=\"https://bsky.app/profile/");
+
+    if let Some(rest) = uri_str.strip_prefix("at://") {
+        if let Some((did, path)) = rest.split_once('/') {
+            let _ = escape_html(&mut *html, did);
+            html.push_str("/post/");
+            if let Some(rkey) = path.strip_prefix("app.bsky.feed.post/") {
+                let _ = escape_html(&mut *html, rkey);
+            }
+        }
+    }
+
+    html.push_str("\" target=\"_blank\" rel=\"noopener\">View post on Bluesky</a></div>\n");
+}

crates/weaver-renderer/src/pckt/mod.rs

···
 mod block_renderer;
 
-pub use block_renderer::{render_block, render_content_blocks, PcktRenderContext};
+pub use block_renderer::{
+    render_block, render_block_sync, render_content_blocks, render_content_blocks_sync,
+    PcktRenderContext,
+};

docs/graph-data.json

···
       "node_type": "goal",
       "title": "Build jacquard - better AT Protocol library for Rust",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T09:30:53.847514686-05:00",
-      "updated_at": "2026-01-06T09:30:53.847514686-05:00",
+      "updated_at": "2026-01-06T19:33:18.788479749-05:00",
       "metadata_json": "{\"confidence\":95,\"prompt\":\"Frustrated with atrium library - significant boilerplate, poor ergonomics, maintenance concerns. Wanted something better, figured others did too. Built jacquard with zero-copy patterns, better type system, built-in OAuth, cleaner APIs. Developed largely for weaver but designed to benefit the broader Rust/ATProto ecosystem.\"}"
     },
     {
···
       "node_type": "goal",
       "title": "Create weaver-editor-browser crate - web_sys DOM layer without Dioxus",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T10:39:48.632511769-05:00",
-      "updated_at": "2026-01-06T10:39:48.632511769-05:00",
+      "updated_at": "2026-01-06T19:33:18.836659545-05:00",
       "metadata_json": "{\"confidence\":90}"
     },
     {
···
       "node_type": "goal",
       "title": "Create weaver-editor-crdt crate - optional Loro integration (+500KB)",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T10:40:09.313344768-05:00",
-      "updated_at": "2026-01-06T10:40:09.313344768-05:00",
+      "updated_at": "2026-01-06T19:33:18.910494639-05:00",
       "metadata_json": "{\"confidence\":90}"
     },
     {
···
       "node_type": "goal",
       "title": "Phase 2: Update weaver-app to use extracted crates",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T10:42:07.645111430-05:00",
-      "updated_at": "2026-01-06T10:42:07.645111430-05:00",
+      "updated_at": "2026-01-06T19:33:18.927342199-05:00",
       "metadata_json": "{\"confidence\":85}"
     },
     {
···
       "node_type": "decision",
       "title": "Where should embed worker live?",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T12:09:01.110078211-05:00",
-      "updated_at": "2026-01-06T12:09:01.110078211-05:00",
+      "updated_at": "2026-01-06T19:33:18.804295632-05:00",
       "metadata_json": "{\"confidence\":85}"
     },
     {
···
       "node_type": "outcome",
       "title": "Embed worker → weaver-embed-worker crate (decided)",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T13:29:10.289780508-05:00",
-      "updated_at": "2026-01-06T13:29:10.289780508-05:00",
+      "updated_at": "2026-01-06T19:33:24.777994841-05:00",
       "metadata_json": "{\"confidence\":100}"
     },
     {
···
       "node_type": "goal",
       "title": "Extract worker manager from collab.rs to weaver-editor-crdt - non-Dioxus coordination logic",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T14:34:17.012426477-05:00",
-      "updated_at": "2026-01-06T14:34:17.012426477-05:00",
+      "updated_at": "2026-01-06T19:33:24.794295700-05:00",
       "metadata_json": "{\"confidence\":85}"
     },
     {
···
       "node_type": "goal",
       "title": "Cursor module refactor - make browser cursor functions public and remove app duplicates",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T17:07:07.731289055-05:00",
-      "updated_at": "2026-01-06T17:07:07.731289055-05:00",
+      "updated_at": "2026-01-06T19:31:34.605897852-05:00",
       "metadata_json": "{\"confidence\":85}"
     },
     {
···
       "node_type": "goal",
       "title": "Evaluate and organize collab.rs and component.rs - consider extraction to core/browser/crdt crates and embed worker host migration",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T17:25:55.550260849-05:00",
-      "updated_at": "2026-01-06T17:25:55.550260849-05:00",
+      "updated_at": "2026-01-06T19:31:34.588088316-05:00",
       "metadata_json": "{\"confidence\":95,\"prompt\":\"User asked to review collab.rs and component.rs for cleanup/organization opportunities, potentially move code to weaver-editor-core, weaver-editor-browser, weaver-editor-crdt. Also consider moving embed worker host side to weaver-embed-worker\"}"
     },
     {
···
       "node_type": "action",
       "title": "Migrate embed worker host side to weaver-embed-worker crate",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T17:31:25.829135397-05:00",
-      "updated_at": "2026-01-06T17:31:25.829135397-05:00",
+      "updated_at": "2026-01-06T19:33:18.820200881-05:00",
       "metadata_json": "{\"confidence\":90}"
     },
     {