some font stuff, bug fixes in the notebook iterator

Cargo.lock

···
  "miette 7.6.0",
  "n0-future",
  "tokio",
+ "tracing",
+ "tracing-subscriber",
  "weaver-api",
  "weaver-common",
  "weaver-renderer",
···
  "thiserror 2.0.17",
  "tokio",
  "tokio-util",
+ "tracing",
  "unicode-normalization",
  "url",
  "weaver-api",

crates/weaver-cli/Cargo.toml

···
 tokio = { version = "1.45.0", features = ["full"] }
 dirs = "6.0.0"
 kdl = "4.6"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] }

crates/weaver-cli/src/main.rs

···
 }
 
 async fn publish_notebook(source: PathBuf, title: String, store_path: PathBuf) -> Result<()> {
+    // Initialize tracing for debugging
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("debug"))
+        )
+        .init();
+
     println!("Publishing notebook from: {}", source.display());
     println!("Title: {}", title);
 
···
 
     // Walk vault directory
     println!("→ Scanning vault...");
+    tracing::debug!("Scanning directory: {}", source.display());
     let contents = vault_contents(&source, WalkOptions::new())?;
 
     // Convert to Arc first
···
 
     // Process each file
     for file_path in &md_files {
+        let _span = tracing::info_span!("process_file", path = %file_path.display()).entered();
         println!("Processing: {}", file_path.display());
 
         // Read file content
···
         // Extract blobs and entry metadata
         let blobs = file_context.blobs();
         let entry_title = file_context.entry_title();
+
+        if !blobs.is_empty() {
+            tracing::debug!("Uploaded {} image(s)", blobs.len());
+        }
 
         // Build Entry record with blobs
         use jacquard::types::blob::BlobRef;

crates/weaver-renderer/Cargo.toml

···
 unicode-normalization = "0.1.24"
 yaml-rust2 = { version = "0.10.2" }
 bitflags = "2.9.1"
+tracing = "0.1"
 
 dashmap = "6.1.0"
 regex = "1.11.1"

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

···
 
 const MAX_EMBED_DEPTH: usize = 3;
 
+#[derive(Clone)]
 pub struct ClientContext<'a, R = ()> {
     // Entry being rendered
     entry: Entry<'a>,

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

···
             .insert(self.current_path.clone(), frontmatter);
     }
 
+    #[tracing::instrument(skip(self, link), fields(dest = ?link))]
     async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s> {
         use crate::utils::lookup_filename_in_vault;
         use weaver_common::LinkUri;
···
         }
     }
 
+    #[tracing::instrument(skip(self, image), fields(dest = ?image))]
     async fn handle_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
         use crate::utils::is_local_path;
         use jacquard::bytes::Bytes;
···
                             .join(dest_url.as_ref())
                     };
 
+                    tracing::debug!("Reading image file: {}", file_path.display());
                     if let Ok(image_data) = fs::read(&file_path).await {
+                        tracing::debug!("Read {} bytes from {}", image_data.len(), file_path.display());
                         // Derive blob name from filename
                         let filename = file_path
                             .file_stem()
···
                         );
 
                         // Upload blob (dereference Arc)
+                        tracing::debug!("Uploading image blob: {} ({} bytes)", file_path.display(), bytes.len());
                         if let Ok(blob) = (*self.agent).upload_blob(bytes, mime.clone()).await {
                             use jacquard::IntoStatic;
 
···
         }
     }
 
+    #[tracing::instrument(skip(self, embed), fields(dest = ?embed))]
     async fn handle_embed<'s>(&self, embed: Tag<'s>) -> Tag<'s> {
         use crate::utils::lookup_filename_in_vault;
         use weaver_common::LinkUri;
···
 
                         let at_uri = format!("at://{}", did.as_ref());
 
+                        tracing::debug!("Fetching profile embed: {}", did.as_ref());
                         // Fetch and render the profile
                         let content = match fetch_and_render_profile(&did, &*self.agent).await {
                             Ok(html) => Some(html),
···
                         use crate::atproto::{fetch_and_render_generic, fetch_and_render_post};
                         use markdown_weaver::WeaverAttributes;
 
+                        tracing::debug!("Fetching record embed: {}", uri.as_ref());
                         // Determine if this is a known type
                         let content = if let Some(collection) = uri.collection() {
                             match collection.as_ref() {

crates/weaver-renderer/src/css.rs

···
 
 h1 {{
   font-size: 2rem;
-  color: var(--color-primary);
+  color: var(--color-secondary);
 }}
 h2 {{
   font-size: 1.5rem;
-  color: var(--color-secondary);
+  color: var(--color-primary);
 }}
 h3 {{
   font-size: 1.25rem;
-  color: var(--color-primary);
+  color: var(--color-secondary);
 }}
 h4 {{
   font-size: 1.2rem;
-  color: var(--color-secondary);
+  color: var(--color-tertiary);
 }}
 h5 {{
   font-size: 1.125rem;
-  color: var(--color-primary);
+  color: var(--color-secondary);
 }}
 h6 {{ font-size: 1rem; }}
 

crates/weaver-renderer/src/lib.rs

···
 use markdown_weaver::CowStr;
 use markdown_weaver::Event;
 use markdown_weaver::Tag;
-use n0_future::pin;
-use n0_future::stream::once_future;
 use n0_future::Stream;
 use yaml_rust2::Yaml;
 use yaml_rust2::YamlLoader;
···
     }
 }
 
-#[derive(Debug, Default)]
 #[pin_project::pin_project]
 pub struct NotebookProcessor<'a, I: Iterator<Item = Event<'a>>, CTX> {
     context: CTX,
     iter: ContextIterator<'a, I>,
+    #[pin]
+    pending_future: Option<Pin<Box<dyn std::future::Future<Output = Event<'a>> + 'a>>>,
 }
 
 impl<'a, I: Iterator<Item = Event<'a>>, CTX> NotebookProcessor<'a, I, CTX> {
     pub fn new(ctx: CTX, iter: ContextIterator<'a, I>) -> Self {
-        Self { context: ctx, iter }
+        Self {
+            context: ctx,
+            iter,
+            pending_future: None,
+        }
     }
 }
 
-impl<'a, I: Iterator<Item = Event<'a>>, CTX: NotebookContext> Stream
+impl<'a, I: Iterator<Item = Event<'a>>, CTX: NotebookContext + Clone + 'a> Stream
     for NotebookProcessor<'a, I, CTX>
 {
     type Item = Event<'a>;
···
         self.iter.size_hint()
     }
     fn poll_next(
-        self: Pin<&mut Self>,
+        mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        let this = self.project();
+        // First, poll any pending future to completion
+        if let Some(fut) = self.as_mut().project().pending_future.as_mut().as_pin_mut() {
+            match fut.poll(cx) {
+                Poll::Ready(event) => {
+                    // Clear the future and return the result
+                    self.as_mut().project().pending_future.set(None);
+                    return Poll::Ready(Some(event));
+                }
+                Poll::Pending => {
+                    // Keep the future for next poll
+                    return Poll::Pending;
+                }
+            }
+        }
+
+        let mut this = self.project();
         let iter: &mut ContextIterator<'a, I> = this.iter;
         if let Some((event, ctxt)) = iter.next() {
             match ctxt {
                 EventContext::EmbedLink => match event {
                     Event::Start(ref tag) => match tag {
                         Tag::Embed { .. } => {
-                            let fut = once_future(this.context.handle_embed(tag.clone()));
-                            pin!(fut);
-                            fut.poll_next(cx)
-                                .map(|tag| tag.map(|t| Event::Start(t.into_static())))
+                            let tag_clone = tag.clone();
+                            let ctx_clone = this.context.clone();
+                            let fut = async move {
+                                let processed_tag = ctx_clone.handle_embed(tag_clone).await;
+                                Event::Start(processed_tag.into_static())
+                            };
+
+                            *this.pending_future = Some(Box::pin(fut));
+
+                            if let Some(fut) = this.pending_future.as_mut().as_pin_mut() {
+                                match fut.poll(cx) {
+                                    Poll::Ready(event) => {
+                                        *this.pending_future = None;
+                                        Poll::Ready(Some(event))
+                                    }
+                                    Poll::Pending => Poll::Pending,
+                                }
+                            } else {
+                                unreachable!()
+                            }
                         }
                         _ => Poll::Ready(Some(event)),
                     },
···
                 EventContext::Reference => match event {
                     Event::Start(ref tag) => match tag {
                         Tag::Link { .. } => {
-                            let fut = once_future(this.context.handle_link(tag.clone()));
-                            pin!(fut);
-                            fut.poll_next(cx).map(|tag| tag.map(|t| Event::Start(t)))
+                            let tag_clone = tag.clone();
+                            let ctx_clone = this.context.clone();
+                            let fut = async move {
+                                let processed_tag = ctx_clone.handle_link(tag_clone).await;
+                                Event::Start(processed_tag)
+                            };
+
+                            *this.pending_future = Some(Box::pin(fut));
+
+                            if let Some(fut) = this.pending_future.as_mut().as_pin_mut() {
+                                match fut.poll(cx) {
+                                    Poll::Ready(event) => {
+                                        *this.pending_future = None;
+                                        Poll::Ready(Some(event))
+                                    }
+                                    Poll::Pending => Poll::Pending,
+                                }
+                            } else {
+                                unreachable!()
+                            }
                         }
                         _ => Poll::Ready(Some(event)),
                     },
···
                 EventContext::Link => match event {
                     Event::Start(ref tag) => match tag {
                         Tag::Link { .. } => {
-                            let fut = once_future(this.context.handle_link(tag.clone()));
-                            pin!(fut);
-                            fut.poll_next(cx).map(|tag| tag.map(|t| Event::Start(t)))
+                            let tag_clone = tag.clone();
+                            let ctx_clone = this.context.clone();
+                            let fut = async move {
+                                let processed_tag = ctx_clone.handle_link(tag_clone).await;
+                                Event::Start(processed_tag)
+                            };
+
+                            *this.pending_future = Some(Box::pin(fut));
+
+                            if let Some(fut) = this.pending_future.as_mut().as_pin_mut() {
+                                match fut.poll(cx) {
+                                    Poll::Ready(event) => {
+                                        *this.pending_future = None;
+                                        Poll::Ready(Some(event))
+                                    }
+                                    Poll::Pending => Poll::Pending,
+                                }
+                            } else {
+                                unreachable!()
+                            }
                         }
                         _ => Poll::Ready(Some(event)),
                     },
···
                 EventContext::Image => match event {
                     Event::Start(ref tag) => match tag {
                         Tag::Image { .. } => {
-                            let fut = once_future(this.context.handle_image(tag.clone()));
-                            pin!(fut);
-                            fut.poll_next(cx).map(|tag| tag.map(|t| Event::Start(t)))
+                            // Create future that handles the image and wraps result in Event::Start
+                            let tag_clone = tag.clone();
+                            let ctx_clone = this.context.clone();
+                            let fut = async move {
+                                let processed_tag = ctx_clone.handle_image(tag_clone).await;
+                                Event::Start(processed_tag)
+                            };
+
+                            // Store the future and poll it
+                            *this.pending_future = Some(Box::pin(fut));
+
+                            // Immediately poll the stored future
+                            if let Some(fut) = this.pending_future.as_mut().as_pin_mut() {
+                                match fut.poll(cx) {
+                                    Poll::Ready(event) => {
+                                        *this.pending_future = None;
+                                        Poll::Ready(Some(event))
+                                    }
+                                    Poll::Pending => Poll::Pending,
+                                }
+                            } else {
+                                unreachable!()
+                            }
                         }
                         _ => Poll::Ready(Some(event)),
                     },

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

···
     }
 }
 
-impl<'input, I: Iterator<Item = Event<'input>>, A: AgentSession + IdentityResolver, W: StrWrite>
-    StaticPageWriter<'input, I, A, W>
+impl<
+    'input,
+    I: Iterator<Item = Event<'input>>,
+    A: AgentSession + IdentityResolver + 'input,
+    W: StrWrite,
+> StaticPageWriter<'input, I, A, W>
 {
     pub async fn run(mut self) -> Result<(), W::Error> {
         while let Some(event) = self.context.next().await {

crates/weaver-renderer/src/theme.rs

···
         subtle: CowStr::new_static("#908caa"),
         emphasis: CowStr::new_static("#e0def4"),
         primary: CowStr::new_static("#c4a7e7"),
-        secondary: CowStr::new_static("#3e8fb0"),
-        tertiary: CowStr::new_static("#9ccfd8"),
+        secondary: CowStr::new_static("#9ccfd8"),
+        tertiary: CowStr::new_static("#ebbcba"),
         error: CowStr::new_static("#eb6f92"),
         warning: CowStr::new_static("#f6c177"),
         success: CowStr::new_static("#31748f"),
···
 pub fn default_fonts() -> ThemeFonts<'static> {
     ThemeFonts {
         body: CowStr::new_static(
-            "IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+            "'IBM Plex', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
         ),
         heading: CowStr::new_static(
-            "IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+            "'IBM Plex Sans', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
         ),
         monospace: CowStr::new_static(
             "'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace",

crates/weaver-server/assets/styling/entry.css

···
 .entry-date {
     margin-left: auto;
     font-weight: 400;
-    color: var(--color-muted);
+    color: var(--color-subtle);
 }
 
 .meta-label {
     font-weight: 400;
-    color: var(--color-muted);
+    color: var(--color-subtle);
 }
 
 .author-name {

crates/weaver-server/src/main.rs

···
     rsx! {
         document::Link { rel: "icon", href: FAVICON }
         document::Link { rel: "stylesheet", href: MAIN_CSS }
+        document::Link { rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&family=IBM+Plex+Sans:ital,wght@0,100..700;1,100..700&family=IBM+Plex+Serif:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&display=swap" }
+        document::Link { rel: "preconnect", href: "https://fonts.googleapis.com" }
+        document::Link { rel: "preconnect", href: "https://fonts.gstatic.com" }
         Router::<Route> {}
     }
 }

weaver_notes/Weaver - Long-form writing.md

···
+```
+Or: "Get in kid, we're rebuilding the blogosphere!"
+```
+
 I grew up, like a lot of people on Bluesky, in the era of the internet where most of your online social interactions took place via text. I had a MySpace account, MSN messenger and Google Chat, I first got on Facebook back when they required a school email to sign up, I had a Tumblr, though not a LiveJournal. I was super into reddit for a long time. Big fan of Fanfiction.net and later Archive of Our Own.
 
 > ![[weaver_photo_med.jpg]]*The namesake of what I'm building*
···
 
 >As to why I'm writing it in Rust (and currently zero Typescript) as opposed to Go and Typescript? Well it comes down to familiarity. Rust isn't necessarily anyone's first choice in a vacuum for a web-native programming language, but it works quite well as one, and I can share the vast majority of the protocol code, as well as the markdown rendering engine, between front and back end, with few if any compromises on performance, save a larger bundle size due to the nature of WebAssembly. And ultimately I may end up producing Typescript bindings for Jacquard and Weaver's core tools, if that's something people value, or I end up reconsidering doing web front-end in Rust.
 ### Evolution
-Weaver is therefore very much an evolving thing. It will always have and support the proof-of-concept workflow as a first-class citizen. That's part of the benefit of building this on atproto. If I screw this up, not too hard for someone else to pick up the torch and continue.
+Weaver is therefore very much an evolving thing. It will always have and support the proof-of-concept workflow as a first-class citizen. That's part of the benefit of building this on atproto. If I screw this up, not too hard for someone else to pick up the torch and continue.