and now using the preliminary atproto-aware renderer.

Cargo.lock

···
  "jacquard-axum",
  "markdown-weaver",
  "mini-moka",
+ "n0-future",
  "time",
  "weaver-api",
  "weaver-common",

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

···
     }
 }
 
+impl EmbedResolver for () {
+    async fn resolve_profile(&self, uri: &AtUri<'_>) -> Result<String, ClientRenderError> {
+        Ok("".to_string())
+    }
+
+    async fn resolve_post(&self, uri: &AtUri<'_>) -> Result<String, ClientRenderError> {
+        Ok("".to_string())
+    }
+
+    async fn resolve_markdown(&self, url: &str, depth: usize) -> Result<String, ClientRenderError> {
+        Ok("".to_string())
+    }
+}
+
 const MAX_EMBED_DEPTH: usize = 3;
 
 pub struct ClientContext<'a, R = ()> {
···
     title: MdCowStr<'a>,
 }
 
-impl<'a> ClientContext<'a, ()> {
-    pub fn new(entry: Entry<'a>, creator_did: Did<'a>) -> Self {
+impl<'a, R: EmbedResolver> ClientContext<'a, R> {
+    pub fn new(entry: Entry<'a>, creator_did: Did<'a>) -> ClientContext<'a, ()> {
         let blob_map = Self::build_blob_map(&entry);
         let title = MdCowStr::Boxed(entry.title.as_ref().into());
 
-        Self {
+        ClientContext {
             entry,
             creator_did,
             blob_map,
···
     }
 
     /// Add an embed resolver for fetching embed content
-    pub fn with_embed_resolver<R: EmbedResolver>(self, resolver: Arc<R>) -> ClientContext<'a, R> {
+    pub fn with_embed_resolver(self, resolver: Arc<R>) -> ClientContext<'a, R> {
         ClientContext {
             entry: self.entry,
             creator_did: self.creator_did,
···
     }
 }
 
-impl<'a, R> ClientContext<'a, R> {
+impl<'a, R: EmbedResolver> ClientContext<'a, R> {
     /// Create a child context with incremented embed depth (for recursive embeds)
     fn with_depth(&self, depth: usize) -> Self
     where
···
             .created_at(Datetime::now())
             .build();
 
-        let ctx = ClientContext::new(entry, Did::new("did:plc:test").unwrap());
+        let ctx = ClientContext::<()>::new(entry, Did::new("did:plc:test").unwrap());
         assert_eq!(ctx.title.as_ref(), "Test");
     }
 

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

···
 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 markdown_weaver_escape::{StrWrite, escape_href, escape_html, escape_html_body_text};
 use std::collections::HashMap;
 
 /// Synchronous callback for injecting embed content
···
     fn get_embed_content(&self, tag: &Tag<'_>) -> Option<String>;
 }
 
+impl EmbedContentProvider for () {
+    fn get_embed_content(&self, _tag: &Tag<'_>) -> Option<String> {
+        None
+    }
+}
+
 /// Simple writer that outputs HTML from markdown events
 ///
 /// This writer is designed for client-side rendering where embeds may have
···
     Body,
 }
 
-impl<W: StrWrite> ClientWriter<W, ()> {
+impl<W: StrWrite, E: EmbedContentProvider> ClientWriter<W, E> {
     pub fn new(writer: W) -> Self {
         Self {
             writer,
···
     }
 
     /// Add an embed content provider
-    pub fn with_embed_provider<E: EmbedContentProvider>(self, provider: E) -> ClientWriter<W, E> {
+    pub fn with_embed_provider(self, provider: E) -> ClientWriter<W, E> {
         ClientWriter {
             writer: self.writer,
             end_newline: self.end_newline,
···
                     self.write("\n<p>")
                 }
             }
-            Tag::Heading { level, id, classes, attrs } => {
+            Tag::Heading {
+                level,
+                id,
+                classes,
+                attrs,
+            } => {
                 if !self.end_newline {
                     self.write("\n")?;
                 }
···
             Tag::Emphasis => self.write("<em>"),
             Tag::Strong => self.write("<strong>"),
             Tag::Strikethrough => self.write("<del>"),
-            Tag::Link { link_type: LinkType::Email, dest_url, title, .. } => {
+            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("\">")
             }
-            Tag::Link { dest_url, title, .. } => {
+            Tag::Link {
+                dest_url, title, ..
+            } => {
                 self.write("<a href=\"")?;
                 escape_href(&mut self.writer, &dest_url)?;
                 if !title.is_empty() {
···
                 }
                 self.write("\">")
             }
-            Tag::Image { dest_url, title, attrs, .. } => {
+            Tag::Image {
+                dest_url,
+                title,
+                attrs,
+                ..
+            } => {
                 self.write("<img src=\"")?;
                 escape_href(&mut self.writer, &dest_url)?;
                 self.write("\" alt=\"")?;
···
                 }
                 self.write(" />")
             }
-            Tag::Embed { embed_type, dest_url, title, id, attrs } => {
-                self.write_embed(embed_type, dest_url, title, id, attrs)
-            }
+            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(())
···
             }
         }
     }
+}
 
+impl<W: StrWrite, E: EmbedContentProvider> ClientWriter<W, E> {
     fn write_embed(
         &mut self,
         embed_type: EmbedType,
···
     ) -> Result<(), W::Error> {
         // Try to get content from attributes first
         let content_from_attrs = if let Some(ref attrs) = attrs {
-            attrs.attrs.iter()
+            attrs
+                .attrs
+                .iter()
                 .find(|(k, _)| k.as_ref() == "content")
                 .map(|(_, v)| v.as_ref().to_string())
         } else {
···
             }
             self.write("></iframe>")?;
         }
-
         Ok(())
     }
 }

crates/weaver-server/Cargo.toml

···
 markdown-weaver = { workspace = true }
 weaver-renderer = { path = "../weaver-renderer" }
 mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d" }
+n0-future = { workspace = true }
 #dioxus-primitives = { git = "https://github.com/DioxusLabs/components", version = "0.0.1", default-features = false }
 axum = {version = "0.8.6", optional = true}
 

crates/weaver-server/src/components/entry.rs

···
     fullstack::{get_server_url, reqwest},
     prelude::*,
 };
-use jacquard::smol_str::ToSmolStr;
+use jacquard::{prelude::IdentityResolver, smol_str::ToSmolStr};
 #[allow(unused_imports)]
 use jacquard::{
     smol_str::SmolStr,
···
 
 #[component]
 pub fn Entry(ident: AtIdentifier<'static>, book_title: SmolStr, title: SmolStr) -> Element {
+    let ident_clone = ident.clone();
     let entry = use_resource(use_reactive!(|(ident, book_title, title)| async move {
         let fetcher = use_context::<fetch::CachedFetcher>();
         let entry = fetcher
···
     match &*entry.read_unchecked() {
         Some(Some(entry_data)) => {
             rsx! { EntryMarkdownDirect {
-                content: entry_data.1.clone()
+                content: entry_data.1.clone(),
+                ident: ident_clone
             } }
-        },
+        }
         Some(None) => {
             rsx! { div { class: "error", "Entry not found" } }
         }
-        None => rsx! { p { "Loading..." } }
+        None => rsx! { p { "Loading..." } },
     }
 }
 
···
     #[props(default)] id: String,
     #[props(default = "entry".to_string())] class: String,
     content: entry::Entry<'static>,
+    ident: AtIdentifier<'static>,
 ) -> Element {
-    let parser = markdown_weaver::Parser::new(&content.content);
+    use n0_future::stream::StreamExt;
+    use weaver_renderer::{
+        atproto::{ClientContext, ClientWriter},
+        ContextIterator, NotebookProcessor,
+    };
 
-    let mut html_buf = String::new();
-    markdown_weaver::html::push_html(&mut html_buf, parser);
+    let processed = use_resource(use_reactive!(|(content, ident)| async move {
+        // Create client context for link/image/embed handling
+        let fetcher = use_context::<fetch::CachedFetcher>();
+        let did = match ident {
+            AtIdentifier::Did(d) => d,
+            AtIdentifier::Handle(h) => fetcher.client.resolve_handle(&h).await.ok()?,
+        };
+        let ctx = ClientContext::<()>::new(content.clone(), did);
+        let parser = markdown_weaver::Parser::new(&content.content);
+        let iter = ContextIterator::default(parser);
+        let processor = NotebookProcessor::new(ctx, iter);
 
-    rsx! {
-        div {
-            id: "{id}",
-            class: "{class}",
-            dangerous_inner_html: "{html_buf}"
-        }
+        // Collect events from the processor stream
+        let events: Vec<_> = StreamExt::collect(processor).await;
+
+        // Render to HTML
+        let mut html_buf = String::new();
+        let _ = ClientWriter::<_, ()>::new(&mut html_buf).run(events.into_iter());
+        Some(html_buf)
+    }));
+
+    match &*processed.read_unchecked() {
+        Some(Some(html_buf)) => rsx! {
+            div {
+                id: "{id}",
+                class: "{class}",
+                dangerous_inner_html: "{html_buf}"
+            }
+        },
+        _ => rsx! {
+            div {
+                id: "{id}",
+                class: "{class}",
+                "Loading..."
+            }
+        },
     }
 }