bunch of updates to embed rendering, etc.

.gitignore

···
 **/.trash
 **/bug_notes.md
 /opencodetmp
+deploy.sh

Cargo.lock

···
 ]
 
 [[package]]
+name = "pulldown-latex"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5abae0e37a730c3e0c6805cfc30d80754fa03091bf5bad54ae47d033aae6ba8b"
+dependencies = [
+ "bumpalo",
+]
+
+[[package]]
 name = "quick-error"
 version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "n0-future",
  "pin-project",
  "pin-utils",
+ "pulldown-latex",
  "regex",
  "regex-lite",
  "reqwest",

crates/weaver-app/assets/styling/editor.css

···
     min-height: 700px;
     line-height: var(--spacing-line-height);
     font-size: 16px;
-    background: var(--color-surface);
-    border: 1px solid var(--color-border);
+    background: var(--color-base);
+    border: 1px solid var(--color-overlay);
     color: var(--color-text);
 }
 
 .editor-content:focus {
-    background: var(--color-surface);
+    border: 1px solid var(--color-border);
 }
 
 .editor-toolbar {
···
 /* Hidden syntax spans - collapsed when cursor is not near */
 .md-syntax-inline.hidden,
 .md-syntax-block.hidden,
-.image-alt.hidden {
+.image-alt.hidden,
+.math-source.hidden {
     display: none;
+}
+
+/* Math source is hidden by default, shown when syntax is visible */
+.math-source {
+    display: none;
+    color: var(--color-text);
+    font-family: var(--font-mono);
+    white-space: pre-wrap;
+    background: color-mix(in srgb, var(--color-primary) 10%, transparent);
+    padding: 0 2px;
+    border-radius: 2px;
+}
+
+/* When syntax is visible (cursor nearby), show source too */
+.math-source:not(.hidden) {
+    display: inline;
+}
+
+/* Rendered math is always visible */
+.math-rendered {
+    display: inline;
+}
+
+.math-display.math-rendered {
+    display: block;
+    text-align: center;
+    margin: 0.5rem 0;
+}
+
+/* Clickable math - click to edit */
+.math-clickable {
+    cursor: pointer;
+}
+
+/* Math error styling */
+.math-error {
+    border: 1px dashed var(--color-error, #eb6f92);
+    border-radius: 4px;
+    padding: 2px 6px;
+    background: color-mix(in srgb, var(--color-error, #eb6f92) 10%, transparent);
+}
+
+.math-error code {
+    font-family: var(--font-mono);
+    font-size: 0.9em;
 }
 
 /* Hide HTML list markers when markdown syntax is visible (not hidden) */
···
     border-radius: 12px;
     font-size: 12px;
     cursor: pointer;
-    transition: background 0.2s ease, opacity 0.2s ease;
+    transition:
+        background 0.2s ease,
+        opacity 0.2s ease;
     user-select: none;
 }
 
···
 }
 
 @keyframes spin {
-    from { transform: rotate(0deg); }
-    to { transform: rotate(360deg); }
+    from {
+        transform: rotate(0deg);
+    }
+    to {
+        transform: rotate(360deg);
+    }
 }
 
 /* Unsynced state - has pending changes */

crates/weaver-app/src/blobcache.rs

···
 use crate::cache_impl;
+use crate::fetch::Fetcher;
 use dioxus::{CapturedError, Result};
 use jacquard::{
+    IntoStatic,
     bytes::Bytes,
-    client::UnauthenticatedSession,
-    identity::JacquardResolver,
     prelude::*,
     smol_str::SmolStr,
     types::{cid::Cid, collection::Collection, ident::AtIdentifier, nsid::Nsid, string::Rkey},
     xrpc::XrpcExt,
-    IntoStatic,
 };
-use std::{
-    sync::Arc,
-    time::Duration,
-};
+use std::{sync::Arc, time::Duration};
 use weaver_api::com_atproto::repo::get_record::GetRecord;
 use weaver_api::com_atproto::sync::get_blob::GetBlob;
 use weaver_api::sh_weaver::notebook::entry::Entry;
 use weaver_api::sh_weaver::publish::blob::Blob as PublishedBlob;
+use weaver_common::WeaverExt;
 
 #[derive(Clone)]
 pub struct BlobCache {
-    client: Arc<UnauthenticatedSession<JacquardResolver>>,
+    fetcher: Arc<Fetcher>,
     cache: cache_impl::Cache<Cid<'static>, Bytes>,
     map: cache_impl::Cache<SmolStr, Cid<'static>>,
 }
 
 impl BlobCache {
-    pub fn new(client: Arc<UnauthenticatedSession<JacquardResolver>>) -> Self {
-        let cache = cache_impl::new_cache(100, Duration::from_secs(1200));
-        let map = cache_impl::new_cache(500, Duration::from_secs(1200));
+    pub fn new(fetcher: Arc<Fetcher>) -> Self {
+        let cache = cache_impl::new_cache(100, Duration::from_secs(12000));
+        let map = cache_impl::new_cache(500, Duration::from_secs(12000));
 
-        Self { client, cache, map }
+        Self {
+            fetcher,
+            cache,
+            map,
+        }
     }
 
     /// Resolve DID and PDS URL from an identifier
···
     ) -> Result<(jacquard::types::string::Did<'static>, jacquard::url::Url)> {
         match ident {
             AtIdentifier::Did(did) => {
-                let pds = self.client.pds_for_did(did).await?;
+                let pds = self.fetcher.pds_for_did(did).await?;
                 Ok((did.clone().into_static(), pds))
             }
             AtIdentifier::Handle(handle) => {
-                let (did, pds) = self.client.pds_for_handle(handle).await?;
+                let (did, pds) = self.fetcher.pds_for_handle(handle).await?;
                 Ok((did, pds))
             }
         }
···
         cid: &Cid<'_>,
     ) -> Result<Bytes> {
         match self
-            .client
+            .fetcher
             .xrpc(pds_url.clone())
-            .send(
-                &GetBlob::new()
-                    .cid(cid.clone())
-                    .did(did.clone())
-                    .build(),
-            )
+            .send(&GetBlob::new().cid(cid.clone()).did(did.clone()).build())
             .await
         {
             Ok(blob_stream) => Ok(blob_stream.buffer().clone()),
···
         name: Option<SmolStr>,
     ) -> Result<()> {
         let (repo_did, pds_url) = self.resolve_ident(&ident).await?;
-        
+
         if self.get_cid(&cid).is_some() {
             return Ok(());
         }
-        
+
         let blob = self.fetch_blob(&repo_did, pds_url, &cid).await?;
 
         self.cache.insert(cid.clone(), blob);
···
     }
 
     /// Resolve an image from a published entry by name.
-    /// 
+    ///
     /// Looks up the entry record at `{ident}/sh.weaver.notebook.entry/{rkey}`,
     /// finds the image by name in the embeds, and returns the blob bytes.
     pub async fn resolve_from_entry(
···
         name: &str,
     ) -> Result<Bytes> {
         let (repo_did, pds_url) = self.resolve_ident(ident).await?;
-        
+
         // Fetch the entry record
         let resp = self
-            .client
+            .fetcher
             .xrpc(pds_url.clone())
             .send(
                 &GetRecord::new()
···
             .map_err(|e| CapturedError::from_display(format!("Failed to parse entry: {}", e)))?;
 
         // Parse the entry
-        let entry: Entry = jacquard::from_data(&record.value)
-            .map_err(|e| CapturedError::from_display(format!("Failed to deserialize entry: {}", e)))?;
+        let entry: Entry = jacquard::from_data(&record.value).map_err(|e| {
+            CapturedError::from_display(format!("Failed to deserialize entry: {}", e))
+        })?;
 
         // Find the image by name
         let cid = entry
···
             .as_ref()
             .and_then(|e| e.images.as_ref())
             .and_then(|imgs| {
-                imgs.images.iter().find(|img| {
-                    img.name.as_ref().map(|n| n.as_ref()) == Some(name)
-                })
+                imgs.images
+                    .iter()
+                    .find(|img| img.name.as_ref().map(|n| n.as_ref()) == Some(name))
             })
             .map(|img| img.image.blob().cid().clone().into_static())
-            .ok_or_else(|| CapturedError::from_display(format!("Image '{}' not found in entry", name)))?;
+            .ok_or_else(|| {
+                CapturedError::from_display(format!("Image '{}' not found in entry", name))
+            })?;
 
         // Check cache first
         if let Some(bytes) = self.get_cid(&cid) {
···
         let blob = self.fetch_blob(&repo_did, pds_url, &cid).await?;
         self.cache.insert(cid.clone(), blob.clone());
         self.map.insert(name.into(), cid);
-        
+
         Ok(blob)
     }
 
     /// Resolve an image from a draft (unpublished) entry via PublishedBlob record.
-    /// 
+    ///
     /// Looks up the PublishedBlob record at `{ident}/sh.weaver.publish.blob/{blob_rkey}`,
     /// gets the CID from it, and returns the blob bytes.
     pub async fn resolve_from_draft(
···
         blob_rkey: &str,
     ) -> Result<Bytes> {
         let (repo_did, pds_url) = self.resolve_ident(ident).await?;
-        
+
         // Fetch the PublishedBlob record
         let resp = self
-            .client
+            .fetcher
             .xrpc(pds_url.clone())
             .send(
                 &GetRecord::new()
···
                     .build(),
             )
             .await
-            .map_err(|e| CapturedError::from_display(format!("Failed to fetch PublishedBlob: {}", e)))?;
+            .map_err(|e| {
+                CapturedError::from_display(format!("Failed to fetch PublishedBlob: {}", e))
+            })?;
 
-        let record = resp
-            .into_output()
-            .map_err(|e| CapturedError::from_display(format!("Failed to parse PublishedBlob: {}", e)))?;
+        let record = resp.into_output().map_err(|e| {
+            CapturedError::from_display(format!("Failed to parse PublishedBlob: {}", e))
+        })?;
 
         // Parse the PublishedBlob
-        let published: PublishedBlob = jacquard::from_data(&record.value)
-            .map_err(|e| CapturedError::from_display(format!("Failed to deserialize PublishedBlob: {}", e)))?;
+        let published: PublishedBlob = jacquard::from_data(&record.value).map_err(|e| {
+            CapturedError::from_display(format!("Failed to deserialize PublishedBlob: {}", e))
+        })?;
 
         // Get CID from the upload blob ref
         let cid = published.upload.blob().cid().clone().into_static();
···
         // Fetch and cache the blob
         let blob = self.fetch_blob(&repo_did, pds_url, &cid).await?;
         self.cache.insert(cid, blob.clone());
-        
+
         Ok(blob)
     }
 
     /// Resolve an image from a notebook entry by name.
-    /// 
-    /// This is a convenience method that looks up the notebook, finds the entry,
-    /// and resolves the image. Used for `/image/{notebook}/{name}` paths.
+    ///
+    /// Looks up the notebook by title or path, iterates through entries to find
+    /// the image by name, and returns the blob bytes. Used for `/image/{notebook}/{name}` paths.
+    /// Cache key uses `{notebook_key}_{image_name}` to avoid collisions across notebooks.
     pub async fn resolve_from_notebook(
         &self,
-        notebook_title: &str,
+        notebook_key: &str,
         image_name: &str,
     ) -> Result<Bytes> {
-        // For now, just try to get from the name cache
-        // Full notebook resolution would require fetching the notebook record
-        // and iterating through entries to find the image
-        self.get_named(&image_name.into())
-            .ok_or_else(|| CapturedError::from_display(format!(
-                "Image '{}' not found in notebook '{}'", 
-                image_name, notebook_title
-            )))
+        // Try scoped cache key first: {notebook_key}_{image_name}
+        let cache_key: SmolStr = format!("{}_{}", notebook_key, image_name).into();
+        if let Some(bytes) = self.get_named(&cache_key) {
+            return Ok(bytes);
+        }
+
+        // Use Fetcher's notebook lookup (works with title or path)
+        let notebook = self
+            .fetcher
+            .get_notebook_by_key(notebook_key)
+            .await?
+            .ok_or_else(|| {
+                CapturedError::from_display(format!("Notebook '{}' not found", notebook_key))
+            })?;
+
+        let (view, entry_refs) = notebook.as_ref();
+
+        // Get the DID from the notebook URI for blob fetching
+        let notebook_did = jacquard::types::aturi::AtUri::new(view.uri.as_ref())
+            .map_err(|e| CapturedError::from_display(format!("Invalid notebook URI: {}", e)))?
+            .authority()
+            .clone()
+            .into_static();
+        let repo_did = match &notebook_did {
+            AtIdentifier::Did(d) => d.clone(),
+            AtIdentifier::Handle(h) => self
+                .fetcher
+                .resolve_handle(h)
+                .await
+                .map_err(|e| CapturedError::from_display(e))?,
+        };
+        let pds_url = self
+            .fetcher
+            .pds_for_did(&repo_did)
+            .await
+            .map_err(|e| CapturedError::from_display(e))?;
+
+        // Iterate through entries to find the image
+        let client = self.fetcher.get_client();
+        for entry_ref in entry_refs {
+            // Parse the entry URI to get rkey
+            let entry_uri = jacquard::types::aturi::AtUri::new(entry_ref.uri.as_ref())
+                .map_err(|e| CapturedError::from_display(format!("Invalid entry URI: {}", e)))?;
+            let rkey = entry_uri
+                .rkey()
+                .ok_or_else(|| CapturedError::from_display("Entry URI missing rkey"))?;
+
+            // Fetch entry using client's cached method
+            let (_entry_view, entry) = match client
+                .fetch_entry_by_rkey(&notebook_did, rkey.0.as_str())
+                .await
+            {
+                Ok(result) => result,
+                Err(_) => continue,
+            };
+
+            // Check if this entry has the image we're looking for
+            if let Some(embeds) = &entry.embeds {
+                if let Some(images) = &embeds.images {
+                    if let Some(img) = images
+                        .images
+                        .iter()
+                        .find(|i| i.name.as_deref() == Some(image_name))
+                    {
+                        let cid = img.image.blob().cid().clone().into_static();
+
+                        // Check blob cache
+                        if let Some(bytes) = self.get_cid(&cid) {
+                            // Also cache with scoped key for next time
+                            self.map.insert(cache_key, cid);
+                            return Ok(bytes);
+                        }
+
+                        // Fetch and cache the blob
+                        let blob = self.fetch_blob(&repo_did, pds_url, &cid).await?;
+                        self.cache.insert(cid.clone(), blob.clone());
+                        self.map.insert(cache_key, cid);
+                        return Ok(blob);
+                    }
+                }
+            }
+        }
+
+        Err(CapturedError::from_display(format!(
+            "Image '{}' not found in notebook '{}'",
+            image_name, notebook_key
+        )))
+    }
+
+    /// Insert bytes directly into cache (for pre-warming after upload)
+    pub fn insert_bytes(&self, cid: Cid<'static>, bytes: Bytes, name: Option<SmolStr>) {
+        self.cache.insert(cid.clone(), bytes);
+        if let Some(name) = name {
+            self.map.insert(name, cid);
+        }
     }
 
     pub fn get_cid(&self, cid: &Cid<'static>) -> Option<Bytes> {

crates/weaver-app/src/components/editor/component.rs

···
 /// - `initial_content`: Optional initial markdown content (for new entries)
 /// - `entry_uri`: Optional AT-URI of an existing entry to edit
 /// - `target_notebook`: Optional notebook title to add the entry to when publishing
+/// - `entry_index`: Optional index of entries for wikilink validation
 #[component]
 pub fn MarkdownEditor(
     initial_content: Option<String>,
     entry_uri: Option<String>,
     target_notebook: Option<SmolStr>,
+    entry_index: Option<weaver_common::EntryIndex>,
 ) -> Element {
     let fetcher = use_context::<Fetcher>();
 
-    // Determine draft key - use entry URI if editing existing, otherwise generate TID
     let draft_key = use_hook(|| {
         entry_uri.clone().unwrap_or_else(|| {
             format!(
···
         })
     });
 
-    // Parse entry URI once
     let parsed_uri = entry_uri.as_ref().and_then(|s| {
         jacquard::types::string::AtUri::new(s)
             .ok()
             .map(|u| u.into_static())
     });
-
-    // Clone draft_key for render (resource closure moves it)
     let draft_key_for_render = draft_key.clone();
+    let target_notebook_for_render = target_notebook.clone();
 
-    // Resource loads and merges document state
     let load_resource = use_resource(move || {
         let fetcher = fetcher.clone();
         let draft_key = draft_key.clone();
···
         let initial_content = initial_content.clone();
 
         async move {
-            // Try to load merged state from PDS + localStorage
             match load_and_merge_document(&fetcher, &draft_key, entry_uri.as_ref()).await {
                 Ok(Some(state)) => {
                     tracing::debug!("Loaded merged document state");
···
                             let is_own_entry = match entry_authority {
                                 AtIdentifier::Did(did) => did == &current_did,
                                 AtIdentifier::Handle(handle) => {
-                                    // Resolve handle to DID and compare
                                     match fetcher.client.resolve_handle(handle).await {
                                         Ok(resolved_did) => resolved_did == current_did,
                                         Err(_) => false,
···
                                 );
                             }
                         }
-
-                        // Try to load the entry content from PDS
                         match load_entry_for_editing(&fetcher, uri).await {
                             Ok(loaded) => {
                                 // Create LoadedDocState from entry
···
         }
     });
 
-    // Render based on load state
     match &*load_resource.read() {
         Some(LoadResult::Loaded(state)) => {
             rsx! {
···
                     key: "{draft_key_for_render}",
                     draft_key: draft_key_for_render.clone(),
                     loaded_state: state.clone(),
+                    target_notebook: target_notebook_for_render.clone(),
+                    entry_index: entry_index.clone(),
                 }
             }
         }
···
 /// - PDS sync with auto-save
 /// - Keyboard shortcuts (Ctrl+B for bold, Ctrl+I for italic)
 #[component]
-fn MarkdownEditorInner(draft_key: String, loaded_state: LoadedDocState) -> Element {
+fn MarkdownEditorInner(
+    draft_key: String,
+    loaded_state: LoadedDocState,
+    target_notebook: Option<SmolStr>,
+    /// Optional entry index for wikilink validation in the editor
+    entry_index: Option<weaver_common::EntryIndex>,
+) -> Element {
     // Context for authenticated API calls
     let fetcher = use_context::<Fetcher>();
     let auth_state = use_context::<Signal<AuthState>>();
 
-    // Create EditorDocument from loaded state (must be in use_hook for Signals)
     let mut document = use_hook(|| {
         let doc = EditorDocument::from_loaded_state(loaded_state.clone());
-        // Save to localStorage so we have a local backup
         storage::save_to_storage(&doc, &draft_key).ok();
         doc
     });
     let editor_id = "markdown-editor";
-
-    // Cache for incremental paragraph rendering
     let mut render_cache = use_signal(|| render::RenderCache::default());
-
-    // Image resolver for mapping /image/{name} to data URLs or CDN URLs
     let mut image_resolver = use_signal(EditorImageResolver::default);
+    let resolved_content = use_signal(weaver_common::ResolvedContent::default);
 
-    // Render paragraphs with incremental caching
-    // Reads document.last_edit signal - creates dependency on content changes only
     let doc_for_memo = document.clone();
+    let doc_for_refs = document.clone();
     let paragraphs = use_memo(move || {
-        let edit = doc_for_memo.last_edit(); // Signal read - reactive dependency
+        let edit = doc_for_memo.last_edit();
         let cache = render_cache.peek();
         let resolver = image_resolver();
+        let resolved = resolved_content();
 
-        let (paras, new_cache) = render::render_paragraphs_incremental(
+        let (paras, new_cache, refs) = render::render_paragraphs_incremental(
             doc_for_memo.loro_text(),
             Some(&cache),
             edit.as_ref(),
             Some(&resolver),
+            entry_index.as_ref(),
+            &resolved,
         );
-
-        // Update cache for next render (write-only via spawn to avoid reactive loop)
+        let mut doc_for_spawn = doc_for_refs.clone();
         dioxus::prelude::spawn(async move {
             render_cache.set(new_cache);
+            doc_for_spawn.set_collected_refs(refs);
         });
 
         paras
     });
 
-    // Flatten offset maps from all paragraphs
+    // Background fetch for AT embeds
+    let mut resolved_content_for_fetch = resolved_content.clone();
+    let doc_for_embeds = document.clone();
+    let fetcher_for_embeds = fetcher.clone();
+    use_effect(move || {
+        let refs = doc_for_embeds.collected_refs.read();
+        let current_resolved = resolved_content_for_fetch.peek();
+        let fetcher = fetcher_for_embeds.clone();
+
+        // Find AT embeds that need fetching
+        let to_fetch: Vec<String> = refs
+            .iter()
+            .filter_map(|r| match r {
+                weaver_common::ExtractedRef::AtEmbed { uri, .. } => {
+                    // Skip if already resolved
+                    if let Ok(at_uri) = jacquard::types::string::AtUri::new(uri) {
+                        if current_resolved.get_embed_content(&at_uri).is_none() {
+                            return Some(uri.clone());
+                        }
+                    }
+                    None
+                }
+                _ => None,
+            })
+            .collect();
+
+        if to_fetch.is_empty() {
+            return;
+        }
+
+        // Spawn background fetches
+        dioxus::prelude::spawn(async move {
+            for uri_str in to_fetch {
+                let Ok(at_uri) = jacquard::types::string::AtUri::new(&uri_str) else {
+                    continue;
+                };
+
+                match weaver_renderer::atproto::fetch_and_render(&at_uri, &fetcher)
+                    .await
+                {
+                    Ok(html) => {
+                        resolved_content_for_fetch.with_mut(|rc| {
+                            rc.add_embed(at_uri.into_static(), html, None);
+                        });
+                    }
+                    Err(e) => {
+                        tracing::warn!("failed to fetch embed {}: {}", uri_str, e);
+                    }
+                }
+            }
+        });
+    });
+
+    let mut new_tag = use_signal(String::new);
+
     let offset_map = use_memo(move || {
         paragraphs()
             .iter()
             .flat_map(|p| p.offset_map.iter().cloned())
             .collect::<Vec<_>>()
     });
-
-    // Flatten syntax spans from all paragraphs
     let syntax_spans = use_memo(move || {
         paragraphs()
             .iter()
             .flat_map(|p| p.syntax_spans.iter().cloned())
             .collect::<Vec<_>>()
     });
-
-    // Cache paragraphs for change detection AND for event handlers to access
     let mut cached_paragraphs = use_signal(|| Vec::<ParagraphRender>::new());
 
-    // Update DOM when paragraphs change (incremental rendering)
     #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
     let mut doc_for_dom = document.clone();
     #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
···
     #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
     let mut interval_holder: Signal<Option<gloo_timers::callback::Interval>> = use_signal(|| None);
 
-    // Auto-save with periodic check (no reactive dependency to avoid loops)
     #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
     let doc_for_autosave = document.clone();
     #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
···
                     None => true,
                     Some(last) => &current_frontiers != last,
                 }
-            }; // drop last_frontiers borrow here
+            };
 
             if needs_save {
                 doc.sync_loro_cursor();
···
             // Get target range from the event if available
             let paras = cached_paras.peek().clone();
             let target_range = get_target_range_from_event(&evt, editor_id, &paras);
-
-            // Get data from the event
             let data = get_data_from_event(&evt);
-
-            // Build context and handle
             let ctx = BeforeInputContext {
                 input_type: input_type.clone(),
                 data,
···
         closure.forget();
     });
 
-    // Local state for adding new tags
-    let mut new_tag = use_signal(String::new);
-
     rsx! {
         Stylesheet { href: asset!("/assets/styling/editor.css") }
         div { class: "markdown-editor-container",
···
                         PublishButton {
                             document: document.clone(),
                             draft_key: draft_key.to_string(),
+                            target_notebook: target_notebook.as_ref().map(|s| s.to_string()),
                         }
                     }
                 }
···
 
                     onclick: {
                         let mut doc = document.clone();
-                        move |_evt| {
+                        move |evt| {
                             tracing::debug!("onclick fired");
                             let paras = cached_paragraphs();
+
+                            // Check if click target is a math-clickable element
+                            #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+                            {
+                                use dioxus::web::WebEventExt;
+                                use wasm_bindgen::JsCast;
+
+                                let web_evt = evt.as_web_event();
+                                if let Some(target) = web_evt.target() {
+                                    if let Some(element) = target.dyn_ref::<web_sys::Element>() {
+                                        // Check element or ancestors for math-clickable
+                                        if let Ok(Some(math_el)) = element.closest(".math-clickable") {
+                                            if let Some(char_target) = math_el.get_attribute("data-char-target") {
+                                                if let Ok(offset) = char_target.parse::<usize>() {
+                                                    tracing::debug!("math-clickable clicked, moving cursor to {}", offset);
+                                                    doc.cursor.write().offset = offset;
+                                                    *doc.selection.write() = None;
+                                                    // Update visibility FIRST so math-source is visible
+                                                    let spans = syntax_spans();
+                                                    update_syntax_visibility(offset, None, &spans, &paras);
+                                                    // Then set DOM selection
+                                                    let map = offset_map();
+                                                    let _ = crate::components::editor::cursor::restore_cursor_position(
+                                                        offset,
+                                                        &map,
+                                                        editor_id,
+                                                        None,
+                                                    );
+                                                    return;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
                             sync_cursor_from_dom(&mut doc, editor_id, &paras);
                             let spans = syntax_spans();
                             let cursor_offset = doc.cursor.read().offset;
···
                         }
                     },
                     }
-
-                    // Debug panel snug below editor
                     div { class: "editor-debug",
                         div { "Cursor: {document.cursor.read().offset}, Chars: {document.len_chars()}" },
                         ReportButton {
···
                     }
                 }
 
-            // Toolbar in grid column 2, row 3
             EditorToolbar {
                 on_format: {
                     let mut doc = document.clone();
···
                             spawn(async move {
                                 let client = fetcher.get_client();
 
+                                // Clone data for cache pre-warming
+                                let data_for_cache = data.clone();
+
                                 // Upload blob and create temporary PublishedBlob record
                                 match client.publish_blob(data, &name_for_upload, None).await {
                                     Ok((strong_ref, published_blob)) => {
···
                                             }
                                         };
 
-                                        // Build Image using the builder API
+                                        let cid = published_blob.upload.blob().cid().clone().into_static();
+
                                         let name_for_resolver = name_for_upload.clone();
                                         let image = Image::new()
                                             .alt(alt_for_upload.to_cowstr())
                                             .image(published_blob.upload)
                                             .name(name_for_upload.to_cowstr())
                                             .build();
-
-                                        // Add to document
                                         doc_for_spawn.add_image(&image, Some(&strong_ref.uri));
 
                                         // Promote from pending to uploaded in resolver
···
                                         });
 
                                         tracing::info!(name = %name_for_resolver, "Image uploaded to PDS");
+
+                                        // Pre-warm server cache with blob bytes
+                                        #[cfg(feature = "fullstack-server")]
+                                        {
+                                            use jacquard::smol_str::ToSmolStr;
+                                            if let Err(e) = crate::data::cache_blob_bytes(
+                                                cid.to_smolstr(),
+                                                Some(name_for_resolver.into()),
+                                                None,
+                                                data_for_cache.into(),
+                                            ).await {
+                                                tracing::warn!(error = %e, "Failed to pre-warm blob cache");
+                                            }
+                                        }
                                     }
                                     Err(e) => {
                                         tracing::error!(error = %e, "Failed to upload image");
···
                                 }
                             });
                         } else {
-                            tracing::info!(name = %name, "Image added with data URL (not authenticated)");
+                            tracing::debug!(name = %name, "Image added with data URL (not authenticated)");
                         }
                     }
                 },

crates/weaver-app/src/components/editor/cursor.rs

···
 ///
 /// Walks all text nodes in the container, accumulating their UTF-16 lengths
 /// until we find the node containing the target offset.
+/// Skips text nodes inside contenteditable="false" elements (like embeds).
 ///
 /// Returns (text_node, offset_within_node).
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
···
         .document()
         .ok_or("no document")?;
 
-    // Create tree walker to find text nodes
-    // SHOW_TEXT = 4 (from DOM spec)
-    let walker = document.create_tree_walker_with_what_to_show(container, 4)?;
+    // Use SHOW_ALL to see element boundaries for tracking non-editable regions
+    let walker = document.create_tree_walker_with_what_to_show(container, 0xFFFFFFFF)?;
 
     let mut accumulated_utf16 = 0;
     let mut last_node: Option<web_sys::Node> = None;
+    let mut skip_until_exit: Option<web_sys::Element> = None;
 
     while let Some(node) = walker.next_node()? {
+        // Check if we've exited the non-editable subtree
+        if let Some(ref skip_elem) = skip_until_exit {
+            if !skip_elem.contains(Some(&node)) {
+                skip_until_exit = None;
+            }
+        }
+
+        // Check if entering a non-editable element
+        if skip_until_exit.is_none() {
+            if let Some(element) = node.dyn_ref::<web_sys::Element>() {
+                if element.get_attribute("contenteditable").as_deref() == Some("false") {
+                    skip_until_exit = Some(element.clone());
+                    continue;
+                }
+            }
+        }
+
+        // Skip everything inside non-editable regions
+        if skip_until_exit.is_some() {
+            continue;
+        }
+
+        // Only process text nodes
+        if node.node_type() != web_sys::Node::TEXT_NODE {
+            continue;
+        }
+
         last_node = Some(node.clone());
 
         if let Some(text) = node.text_content() {

crates/weaver-app/src/components/editor/document.rs

···
     /// Pending snap direction for cursor restoration after edits.
     /// Set by input handlers, consumed by cursor restoration.
     pub pending_snap: Signal<Option<super::offset_map::SnapDirection>>,
+
+    /// Collected refs (wikilinks, AT embeds) from the most recent render.
+    /// Updated by the render pipeline, read by publish for populating records.
+    pub collected_refs: Signal<Vec<weaver_common::ExtractedRef>>,
 }
 
 /// Cursor state including position and affinity.
···
             composition_ended_at: Signal::new(None),
             last_edit: Signal::new(None),
             pending_snap: Signal::new(None),
+            collected_refs: Signal::new(Vec::new()),
         }
     }
 
···
         self.last_edit.read().clone()
     }
 
+    // --- Collected refs accessors ---
+
+    /// Update collected refs from the render pipeline.
+    pub fn set_collected_refs(&mut self, refs: Vec<weaver_common::ExtractedRef>) {
+        self.collected_refs.set(refs);
+    }
+
+    /// Get AT URIs from collected embeds for populating entry.embeds.records.
+    ///
+    /// Filters for AtEmbed refs and parses to AtUri. Invalid URIs are skipped.
+    pub fn at_embed_uris(&self) -> Vec<AtUri<'static>> {
+        self.collected_refs
+            .read()
+            .iter()
+            .filter_map(|r| match r {
+                weaver_common::ExtractedRef::AtEmbed { uri, .. } => {
+                    AtUri::new(uri).ok().map(|u| u.into_static())
+                }
+                _ => None,
+            })
+            .collect()
+    }
+
     // --- Edit sync methods ---
 
     /// Get the edit root StrongRef if set.
···
             composition_ended_at: Signal::new(None),
             last_edit: Signal::new(None),
             pending_snap: Signal::new(None),
+            collected_refs: Signal::new(Vec::new()),
         }
     }
 
···
             composition_ended_at: Signal::new(None),
             last_edit: Signal::new(None),
             pending_snap: Signal::new(None),
+            collected_refs: Signal::new(Vec::new()),
         }
     }
 }

crates/weaver-app/src/components/editor/dom_sync.rs

···
     })?;
 
     // Calculate UTF-16 offset from start of container to the position
+    // Skip text nodes inside contenteditable="false" elements (like embeds)
     let mut utf16_offset_in_container = 0;
 
-    if let Ok(walker) = dom_document.create_tree_walker_with_what_to_show(&container, 4) {
-        while let Ok(Some(text_node)) = walker.next_node() {
-            if &text_node == node {
-                utf16_offset_in_container += offset_in_text_node;
-                break;
+    // Use SHOW_ALL (0xFFFFFFFF) to see element boundaries for tracking non-editable regions
+    if let Ok(walker) = dom_document.create_tree_walker_with_what_to_show(&container, 0xFFFFFFFF) {
+        // Track the non-editable element we're inside (if any)
+        let mut skip_until_exit: Option<web_sys::Element> = None;
+
+        while let Ok(Some(dom_node)) = walker.next_node() {
+            // Check if we've exited the non-editable subtree
+            if let Some(ref skip_elem) = skip_until_exit {
+                if !skip_elem.contains(Some(&dom_node)) {
+                    skip_until_exit = None;
+                }
             }
 
-            if let Some(text) = text_node.text_content() {
-                utf16_offset_in_container += text.encode_utf16().count();
+            // Check if entering a non-editable element
+            if skip_until_exit.is_none() {
+                if let Some(element) = dom_node.dyn_ref::<web_sys::Element>() {
+                    if element.get_attribute("contenteditable").as_deref() == Some("false") {
+                        skip_until_exit = Some(element.clone());
+                        continue;
+                    }
+                }
+            }
+
+            // Skip everything inside non-editable regions
+            if skip_until_exit.is_some() {
+                continue;
+            }
+
+            // Only process text nodes
+            if dom_node.node_type() == web_sys::Node::TEXT_NODE {
+                if &dom_node == node {
+                    utf16_offset_in_container += offset_in_text_node;
+                    break;
+                }
+
+                if let Some(text) = dom_node.text_content() {
+                    utf16_offset_in_container += text.encode_utf16().count();
+                }
             }
         }
     }
···
 ) -> bool {
     false
 }
+

crates/weaver-app/src/components/editor/publish.rs

···
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
 use weaver_api::com_atproto::repo::{create_record::CreateRecord, put_record::PutRecord};
 use weaver_api::sh_weaver::embed::images::Images;
+use weaver_api::sh_weaver::embed::records::{RecordEmbed, Records};
 use weaver_api::sh_weaver::notebook::entry::{Entry, EntryEmbeds};
 use weaver_common::{WeaverError, WeaverExt};
 
···
             let did = &caps[1];
             let name = &caps[3];
             format!("/image/{}/{}/{}", did, entry_rkey, name)
+        })
+        .into_owned()
+}
+
+/// Rewrite draft paths for notebook entries.
+///
+/// Converts `/image/{did}/draft/{blob_rkey}/{name}` to `/image/{notebook}/{name}`
+fn rewrite_draft_paths_for_notebook(content: &str, notebook_key: &str) -> String {
+    DRAFT_IMAGE_PATH_REGEX
+        .replace_all(content, |caps: &regex_lite::Captures| {
+            let name = &caps[3];
+            format!("/image/{}/{}", notebook_key, name)
         })
         .into_owned()
 }
···
     // Resolve DID and PDS
     let (did, pds_url) = match ident {
         AtIdentifier::Did(d) => {
-            let pds = fetcher
-                .client
-                .pds_for_did(d)
-                .await
-                .map_err(|e| WeaverError::InvalidNotebook(format!("Failed to resolve DID: {}", e)))?;
+            let pds = fetcher.client.pds_for_did(d).await.map_err(|e| {
+                WeaverError::InvalidNotebook(format!("Failed to resolve DID: {}", e))
+            })?;
             (d.clone(), pds)
         }
         AtIdentifier::Handle(h) => {
-            let (did, pds) = fetcher
-                .client
-                .pds_for_handle(h)
-                .await
-                .map_err(|e| WeaverError::InvalidNotebook(format!("Failed to resolve handle: {}", e)))?;
+            let (did, pds) = fetcher.client.pds_for_handle(h).await.map_err(|e| {
+                WeaverError::InvalidNotebook(format!("Failed to resolve handle: {}", e))
+            })?;
             (did, pds)
         }
     };
···
     // Build StrongRef from URI and CID
     let entry_ref = StrongRef::new()
         .uri(uri.clone().into_static())
-        .cid(record.cid.ok_or_else(|| {
-            WeaverError::InvalidNotebook("Entry response missing CID".into())
-        })?.into_static())
+        .cid(
+            record
+                .cid
+                .ok_or_else(|| WeaverError::InvalidNotebook("Entry response missing CID".into()))?
+                .into_static(),
+        )
         .build();
 
     Ok(LoadedEntry {
···
     // Get images from the document
     let editor_images = doc.images();
 
-    // Build embeds if we have images
-    let entry_embeds = if editor_images.is_empty() {
+    // Resolve AT embed URIs to StrongRefs
+    let at_embed_uris = doc.at_embed_uris();
+    let mut record_embeds: Vec<RecordEmbed<'static>> = Vec::new();
+    for uri in at_embed_uris {
+        match fetcher.confirm_record_ref(&uri).await {
+            Ok(strong_ref) => {
+                record_embeds.push(RecordEmbed::new().record(strong_ref).build());
+            }
+            Err(e) => {
+                tracing::warn!("Failed to resolve embed {}: {}", uri, e);
+            }
+        }
+    }
+
+    // Build embeds if we have images or records
+    let entry_embeds = if editor_images.is_empty() && record_embeds.is_empty() {
         None
     } else {
-        // Extract Image types from EditorImage wrappers
-        let images: Vec<_> = editor_images.iter().map(|ei| ei.image.clone()).collect();
+        let images = if editor_images.is_empty() {
+            None
+        } else {
+            Some(Images {
+                images: editor_images.iter().map(|ei| ei.image.clone()).collect(),
+                extra_data: None,
+            })
+        };
+
+        let records = if record_embeds.is_empty() {
+            None
+        } else {
+            Some(Records::new().records(record_embeds).build())
+        };
 
         Some(EntryEmbeds {
-            images: Some(Images {
-                images,
-                extra_data: None,
-            }),
+            images,
+            records,
             ..Default::default()
         })
     };
···
     let client = fetcher.get_client();
     let result = if let Some(notebook) = notebook_title {
         // Publish to a notebook via upsert_entry
-        // TODO: Need to handle path rewriting for notebook case
-        // For now, use content as-is (notebook entries use different path scheme anyway)
+        // Rewrite draft image paths to notebook paths: /image/{notebook}/{name}
+        let content = rewrite_draft_paths_for_notebook(&doc.content(), notebook);
+
         let entry = Entry::new()
-            .content(doc.content())
+            .content(content)
             .title(doc.title())
             .path(path)
             .created_at(Datetime::now())
···
             .maybe_embeds(entry_embeds)
             .build();
 
-        let (entry_ref, was_created) = client.upsert_entry(notebook, &doc.title(), entry).await?;
+        // Pass existing rkey if re-publishing (to allow title changes without creating new entry)
+        let doc_entry_ref = doc.entry_ref();
+        let existing_rkey = doc_entry_ref.as_ref().and_then(|r| r.uri.rkey());
+        let (entry_ref, was_created) = client
+            .upsert_entry(
+                notebook,
+                &doc.title(),
+                entry,
+                existing_rkey.map(|r| r.0.as_str()),
+            )
+            .await?;
         let uri = entry_ref.uri.clone();
 
         // Set entry_ref so subsequent publishes update this record
···
     pub document: EditorDocument,
     /// Storage key for the draft
     pub draft_key: String,
+    /// Pre-selected notebook (from URL param)
+    #[props(optional)]
+    pub target_notebook: Option<String>,
 }
 
 /// Publish button component with notebook selection.
···
     let auth_state = use_context::<Signal<AuthState>>();
 
     let mut show_dialog = use_signal(|| false);
-    let mut notebook_title = use_signal(|| String::from("Default"));
-    let mut use_notebook = use_signal(|| true);
+    let mut notebook_title = use_signal(|| {
+        props.target_notebook.clone().unwrap_or_else(|| String::from("Default"))
+    });
+    let mut use_notebook = use_signal(|| props.target_notebook.is_some());
     let mut is_publishing = use_signal(|| false);
     let mut error_message: Signal<Option<String>> = use_signal(|| None);
     let mut success_uri: Signal<Option<AtUri<'static>>> = use_signal(|| None);
···
             error_message.set(None);
 
             let mut doc_snapshot = doc_snapshot;
-            match publish_entry(&fetcher, &mut doc_snapshot, notebook.as_deref(), &draft_key).await {
+            match publish_entry(&fetcher, &mut doc_snapshot, notebook.as_deref(), &draft_key).await
+            {
                 Ok(result) => {
                     success_uri.set(Some(result.uri().clone()));
                 }
···
                     h2 { "Publish Entry" }
 
                     if let Some(uri) = success_uri() {
-                        div { class: "publish-success",
-                            p { "Entry published successfully!" }
-                            a {
-                                href: "{uri}",
-                                target: "_blank",
-                                "View entry →"
-                            }
-                            button {
-                                class: "publish-done",
-                                onclick: close_dialog,
-                                "Done"
+                        {
+                            // Construct web URL from AT-URI
+                            let did = uri.authority();
+                            let web_url = if use_notebook() {
+                                // Notebook entry: /{did}/{notebook}/{entry_path}
+                                format!("/{}/{}/{}", did, notebook_title(), doc.path())
+                            } else {
+                                // Standalone entry: /{did}/e/{rkey}
+                                let rkey = uri.rkey().map(|r| r.0.as_str()).unwrap_or("");
+                                format!("/{}/e/{}", did, rkey)
+                            };
+
+                            rsx! {
+                                div { class: "publish-success",
+                                    p { "Entry published successfully!" }
+                                    a {
+                                        href: "{web_url}",
+                                        target: "_blank",
+                                        "View entry → "
+                                    }
+                                    button {
+                                        class: "publish-done",
+                                        onclick: close_dialog,
+                                        "Done"
+                                    }
+                                }
                             }
                         }
                     } else {

crates/weaver-app/src/components/editor/render.rs

···
 use loro::LoroText;
 use markdown_weaver::Parser;
 use std::ops::Range;
+use weaver_common::{EntryIndex, ResolvedContent};
 
 /// Cache for incremental paragraph rendering.
 /// Stores previously rendered paragraphs to avoid re-rendering unchanged content.
···
 ///
 /// Uses cached paragraph renders when possible, only re-rendering changed paragraphs.
 /// For "safe" edits (no boundary changes), skips boundary rediscovery entirely.
+///
+/// # Parameters
+/// - `entry_index`: Optional index for wikilink validation (adds link-valid/link-broken classes)
+/// - `resolved_content`: Pre-resolved embed content for sync rendering
+///
+/// # Returns
+/// (paragraphs, cache, collected_refs) - collected_refs contains wikilinks and AT embeds found during render
 pub fn render_paragraphs_incremental(
     text: &LoroText,
     cache: Option<&RenderCache>,
     edit: Option<&EditInfo>,
     image_resolver: Option<&EditorImageResolver>,
-) -> (Vec<ParagraphRender>, RenderCache) {
+    entry_index: Option<&EntryIndex>,
+    resolved_content: &ResolvedContent,
+) -> (
+    Vec<ParagraphRender>,
+    RenderCache,
+    Vec<weaver_common::ExtractedRef>,
+) {
     let source = text.to_string();
 
     // Handle empty document
···
             next_syn_id: 0,
         };
 
-        return (vec![para], new_cache);
+        return (vec![para], new_cache, vec![]);
     }
 
     // Determine if we can use fast path (skip boundary discovery)
···
         .run()
         {
             Ok(result) => result.paragraph_ranges,
-            Err(_) => return (Vec::new(), RenderCache::default()),
+            Err(_) => return (Vec::new(), RenderCache::default(), vec![]),
         }
     };
 
···
     // Render paragraphs, reusing cache where possible
     let mut paragraphs = Vec::with_capacity(paragraph_ranges.len());
     let mut new_cached = Vec::with_capacity(paragraph_ranges.len());
+    let mut all_refs: Vec<weaver_common::ExtractedRef> = Vec::new();
     let mut node_id_offset = cache.map(|c| c.next_node_id).unwrap_or(0);
     let mut syn_id_offset = cache.map(|c| c.next_syn_id).unwrap_or(0);
 
···
             // Use provided resolver or empty default
             let resolver = image_resolver.cloned().unwrap_or_default();
 
-            let (mut offset_map, mut syntax_spans) =
-                match EditorWriter::<_, _, ()>::new_with_offsets(
+            // Build writer with optional entry index for wikilink validation
+            // Pass paragraph's document-level offsets so all embedded char/byte positions are absolute
+            let mut writer =
+                EditorWriter::<_, _, &ResolvedContent, &EditorImageResolver>::new_with_all_offsets(
                     &para_source,
                     &para_text,
                     parser,
                     &mut output,
                     node_id_offset,
                     syn_id_offset,
+                    char_range.start,
+                    byte_range.start,
                 )
                 .with_image_resolver(&resolver)
-                .run()
-                {
-                    Ok(result) => {
-                        // Update node ID offset
-                        let max_node_id = result
-                            .offset_maps
-                            .iter()
-                            .filter_map(|m| {
-                                m.node_id
-                                    .strip_prefix("n")
-                                    .and_then(|s| s.parse::<usize>().ok())
-                            })
-                            .max()
-                            .unwrap_or(node_id_offset);
-                        node_id_offset = max_node_id + 1;
+                .with_embed_provider(resolved_content);
 
-                        // Update syn ID offset
-                        let max_syn_id = result
-                            .syntax_spans
-                            .iter()
-                            .filter_map(|s| {
-                                s.syn_id
-                                    .strip_prefix("s")
-                                    .and_then(|id| id.parse::<usize>().ok())
-                            })
-                            .max()
-                            .unwrap_or(syn_id_offset.saturating_sub(1));
-                        syn_id_offset = max_syn_id + 1;
+            if let Some(idx) = entry_index {
+                writer = writer.with_entry_index(idx);
+            }
 
-                        (result.offset_maps, result.syntax_spans)
-                    }
-                    Err(_) => (Vec::new(), Vec::new()),
-                };
+            let (mut offset_map, mut syntax_spans) = match writer.run() {
+                Ok(result) => {
+                    // Update node ID offset
+                    let max_node_id = result
+                        .offset_maps
+                        .iter()
+                        .filter_map(|m| {
+                            m.node_id
+                                .strip_prefix("n")
+                                .and_then(|s| s.parse::<usize>().ok())
+                        })
+                        .max()
+                        .unwrap_or(node_id_offset);
+                    node_id_offset = max_node_id + 1;
+
+                    // Update syn ID offset
+                    let max_syn_id = result
+                        .syntax_spans
+                        .iter()
+                        .filter_map(|s| {
+                            s.syn_id
+                                .strip_prefix("s")
+                                .and_then(|id| id.parse::<usize>().ok())
+                        })
+                        .max()
+                        .unwrap_or(syn_id_offset.saturating_sub(1));
+                    syn_id_offset = max_syn_id + 1;
 
-            // Adjust offsets to document coordinates
-            let para_char_start = char_range.start;
-            let para_byte_start = byte_range.start;
-            for mapping in &mut offset_map {
-                mapping.byte_range.start += para_byte_start;
-                mapping.byte_range.end += para_byte_start;
-                mapping.char_range.start += para_char_start;
-                mapping.char_range.end += para_char_start;
-            }
-            for span in &mut syntax_spans {
-                span.adjust_positions(para_char_start as isize);
-            }
+                    // Collect refs from this paragraph
+                    all_refs.extend(result.collected_refs);
+
+                    (result.offset_maps, result.syntax_spans)
+                }
+                Err(_) => (Vec::new(), Vec::new()),
+            };
 
+            // Offsets are already document-absolute since we pass char_range.start/byte_range.start
+            // to the writer constructor
             (output, offset_map, syntax_spans)
         };
 
···
         next_syn_id: syn_id_offset,
     };
 
-    (paragraphs_with_gaps, new_cache)
+    (paragraphs_with_gaps, new_cache, all_refs)
 }

crates/weaver-app/src/components/editor/tests.rs

···
 use super::render::render_paragraphs_incremental;
 use loro::LoroDoc;
 use serde::Serialize;
+use weaver_common::ResolvedContent;
 
 /// Serializable version of ParagraphRender for snapshot testing.
 #[derive(Debug, Serialize)]
···
     let doc = LoroDoc::new();
     let text = doc.get_text("content");
     text.insert(0, input).unwrap();
-    let (paragraphs, _cache) = render_paragraphs_incremental(&text, None, None, None);
+    let (paragraphs, _cache, _refs) =
+        render_paragraphs_incremental(&text, None, None, None, None, &ResolvedContent::default());
     paragraphs.iter().map(TestParagraph::from).collect()
 }
 
···
 
     // Initial state: "#" is a valid empty heading
     text.insert(0, "#").unwrap();
-    let (paras1, cache1) = render_paragraphs_incremental(&text, None, None, None);
+    let (paras1, cache1, _refs1) =
+        render_paragraphs_incremental(&text, None, None, None, None, &ResolvedContent::default());
 
     eprintln!("State 1 ('#'): {}", paras1[0].html);
     assert!(paras1[0].html.contains("<h1"), "# alone should be heading");
···
 
     // Transition: add "t" to make "#t" - no longer a heading
     text.insert(1, "t").unwrap();
-    let (paras2, _cache2) = render_paragraphs_incremental(&text, Some(&cache1), None, None);
+    let (paras2, _cache2, _refs2) = render_paragraphs_incremental(
+        &text,
+        Some(&cache1),
+        None,
+        None,
+        None,
+        &ResolvedContent::default(),
+    );
 
     eprintln!("State 2 ('#t'): {}", paras2[0].html);
     assert!(
···
     let doc = LoroDoc::new();
     let text = doc.get_text("content");
     text.insert(0, input).unwrap();
-    let (paragraphs, _cache) = render_paragraphs_incremental(&text, None, None, None);
+    let (paragraphs, _cache, _refs) =
+        render_paragraphs_incremental(&text, None, None, None, None, &ResolvedContent::default());
 
     // With standard \n\n break, we expect 2 paragraphs (no gap element)
     // Paragraph ranges include some trailing whitespace from markdown parsing
···
     let doc = LoroDoc::new();
     let text = doc.get_text("content");
     text.insert(0, input).unwrap();
-    let (paragraphs, _cache) = render_paragraphs_incremental(&text, None, None, None);
+    let (paragraphs, _cache, _refs) =
+        render_paragraphs_incremental(&text, None, None, None, None, &ResolvedContent::default());
 
     // With extra newlines, we expect 3 elements: para, gap, para
     assert_eq!(
···
     let text = doc.get_text("content");
     text.insert(0, input).unwrap();
 
-    let (paras1, cache1) = render_paragraphs_incremental(&text, None, None, None);
+    let (paras1, cache1, _refs1) =
+        render_paragraphs_incremental(&text, None, None, None, None, &ResolvedContent::default());
     assert!(!cache1.paragraphs.is_empty(), "Cache should be populated");
 
     // Second render with same content should reuse cache
-    let (paras2, _cache2) = render_paragraphs_incremental(&text, Some(&cache1), None, None);
+    let (paras2, _cache2, _refs2) = render_paragraphs_incremental(
+        &text,
+        Some(&cache1),
+        None,
+        None,
+        None,
+        &ResolvedContent::default(),
+    );
 
     // Should produce identical output
     assert_eq!(paras1.len(), paras2.len());

crates/weaver-app/src/components/editor/writer.rs

···
 };
 use std::collections::HashMap;
 use std::ops::Range;
+use weaver_common::{EntryIndex, ResolvedContent};
 
 /// Result of rendering with the EditorWriter.
 #[derive(Debug, Clone)]
···
 
     /// Syntax spans that can be conditionally hidden
     pub syntax_spans: Vec<SyntaxSpanInfo>,
+
+    /// Refs (wikilinks, AT embeds) collected during this render pass
+    pub collected_refs: Vec<weaver_common::ExtractedRef>,
 }
 
 /// Classification of markdown syntax characters
···
     }
 }
 
+impl EmbedContentProvider for &ResolvedContent {
+    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<String> {
+        if let Tag::Embed { dest_url, .. } = tag {
+            let url = dest_url.as_ref();
+            if url.starts_with("at://") {
+                if let Ok(at_uri) = jacquard::types::string::AtUri::new(url) {
+                    return ResolvedContent::get_embed_content(self, &at_uri)
+                        .map(|s| s.to_string());
+                }
+            }
+        }
+        None
+    }
+}
+
 /// Resolves image URLs to CDN URLs based on stored images.
 ///
 /// The markdown may reference images by name (e.g., "photo.jpg" or "/notebook/image.png").
···
 
     embed_provider: Option<E>,
     image_resolver: Option<R>,
+    entry_index: Option<&'a EntryIndex>,
 
     code_buffer: Option<(Option<String>, String)>, // (lang, content)
     code_buffer_byte_range: Option<Range<usize>>,  // byte range of buffered code content
···
     /// Stack of pending inline formats: (syn_id of opening span, char start of region)
     /// Used to set formatted_range when closing paired inline markers
     pending_inline_formats: Vec<(String, usize)>,
+
+    /// Collected refs (wikilinks, AT embeds, AT links) during this render pass
+    ref_collector: weaver_common::RefCollector,
 
     _phantom: std::marker::PhantomData<&'a ()>,
 }
···
         node_id_offset: usize,
         syn_id_offset: usize,
     ) -> Self {
+        Self::new_with_all_offsets(
+            source,
+            source_text,
+            events,
+            writer,
+            node_id_offset,
+            syn_id_offset,
+            0,
+            0,
+        )
+    }
+
+    pub fn new_with_all_offsets(
+        source: &'a str,
+        source_text: &'a LoroText,
+        events: I,
+        writer: W,
+        node_id_offset: usize,
+        syn_id_offset: usize,
+        char_offset_base: usize,
+        byte_offset_base: usize,
+    ) -> Self {
         Self {
             source,
             source_text,
             events,
             writer,
-            last_byte_offset: 0,
-            last_char_offset: 0,
+            last_byte_offset: byte_offset_base,
+            last_char_offset: char_offset_base,
             end_newline: true,
             in_non_writing_block: false,
             table_state: TableState::Head,
···
             numbers: HashMap::new(),
             embed_provider: None,
             image_resolver: None,
+            entry_index: None,
             code_buffer: None,
             code_buffer_byte_range: None,
             code_buffer_char_range: None,
···
             syntax_spans: Vec::new(),
             next_syn_id: syn_id_offset,
             pending_inline_formats: Vec::new(),
+            ref_collector: weaver_common::RefCollector::new(),
             _phantom: std::marker::PhantomData,
         }
     }
···
             numbers: HashMap::new(),
             embed_provider: None,
             image_resolver: None,
+            entry_index: None,
             code_buffer: None,
             code_buffer_byte_range: None,
             code_buffer_char_range: None,
···
             syntax_spans: Vec::new(),
             next_syn_id: 0,
             pending_inline_formats: Vec::new(),
+            ref_collector: weaver_common::RefCollector::new(),
             paragraph_ranges: Vec::new(),
             current_paragraph_start: None,
             list_depth: 0,
···
             numbers: self.numbers,
             embed_provider: Some(provider),
             image_resolver: self.image_resolver,
+            entry_index: self.entry_index,
             code_buffer: self.code_buffer,
             code_buffer_byte_range: self.code_buffer_byte_range,
             code_buffer_char_range: self.code_buffer_char_range,
···
             syntax_spans: self.syntax_spans,
             next_syn_id: self.next_syn_id,
             pending_inline_formats: self.pending_inline_formats,
+            ref_collector: self.ref_collector,
             _phantom: std::marker::PhantomData,
         }
     }
···
             numbers: self.numbers,
             embed_provider: self.embed_provider,
             image_resolver: Some(resolver),
+            entry_index: self.entry_index,
             code_buffer: self.code_buffer,
             code_buffer_byte_range: self.code_buffer_byte_range,
             code_buffer_char_range: self.code_buffer_char_range,
···
             syntax_spans: self.syntax_spans,
             next_syn_id: self.next_syn_id,
             pending_inline_formats: self.pending_inline_formats,
+            ref_collector: self.ref_collector,
             _phantom: std::marker::PhantomData,
         }
     }
+
+    /// Add an entry index for wikilink resolution feedback
+    pub fn with_entry_index(mut self, index: &'a EntryIndex) -> Self {
+        self.entry_index = Some(index);
+        self
+    }
+
     #[inline]
     fn write_newline(&mut self) -> Result<(), W::Error> {
         self.end_newline = true;
···
             offset_maps: self.offset_maps,
             paragraph_ranges: self.paragraph_ranges,
             syntax_spans: self.syntax_spans,
+            collected_refs: self.ref_collector.take(),
         })
     }
 
···
                     let backtick_char_end = char_start + 1;
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">`</span>",
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">`</span>",
                         syn_id, char_start, backtick_char_end
                     )?;
                     self.syntax_spans.push(SyntaxSpanInfo {
···
                     let backtick_char_end = backtick_char_start + 1;
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">`</span>",
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">`</span>",
                         syn_id, backtick_char_start, backtick_char_end
                     )?;
 
···
                 }
             }
             InlineMath(text) => {
-                let format_start = self.last_char_offset;
+                // Math rendering follows embed pattern: syntax spans hide when cursor outside,
+                // rendered content always visible
                 let raw_text = &self.source[range.clone()];
+                let syn_id = self.gen_syn_id();
+                let opening_char_start = self.last_char_offset;
 
-                // Track opening span index so we can set formatted_range later
-                let opening_span_idx = if raw_text.starts_with('$') {
-                    let syn_id = self.gen_syn_id();
-                    let char_start = self.last_char_offset;
-                    let char_end = char_start + 1;
+                // Calculate char positions
+                let text_char_len = text.chars().count();
+                let opening_char_end = opening_char_start + 1; // "$"
+                let content_char_start = opening_char_end;
+                let content_char_end = content_char_start + text_char_len;
+                let closing_char_start = content_char_end;
+                let closing_char_end = closing_char_start + 1; // "$"
+                let formatted_range = opening_char_start..closing_char_end;
+
+                // 1. Emit opening $ syntax span
+                if raw_text.starts_with('$') {
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$</span>",
-                        syn_id, char_start, char_end
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">$</span>",
+                        syn_id, opening_char_start, opening_char_end
                     )?;
                     self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
+                        syn_id: syn_id.clone(),
+                        char_range: opening_char_start..opening_char_end,
                         syntax_type: SyntaxType::Inline,
-                        formatted_range: None, // Set after we know the full range
+                        formatted_range: Some(formatted_range.clone()),
                     });
-                    self.last_char_offset += 1;
-                    Some(self.syntax_spans.len() - 1)
-                } else {
-                    None
-                };
+                    self.record_mapping(
+                        range.start..range.start + 1,
+                        opening_char_start..opening_char_end,
+                    );
+                }
 
-                self.write(r#"<span class="math math-inline">"#)?;
-                let text_char_len = text.chars().count();
+                // 2. Emit raw LaTeX content (hidden with syntax when cursor outside)
+                write!(
+                    &mut self.writer,
+                    "<span class=\"math-source\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
+                    syn_id, content_char_start, content_char_end
+                )?;
                 escape_html(&mut self.writer, &text)?;
-                self.last_char_offset += text_char_len;
                 self.write("</span>")?;
+                self.syntax_spans.push(SyntaxSpanInfo {
+                    syn_id: syn_id.clone(),
+                    char_range: content_char_start..content_char_end,
+                    syntax_type: SyntaxType::Inline,
+                    formatted_range: Some(formatted_range.clone()),
+                });
+                self.record_mapping(
+                    range.start + 1..range.end - 1,
+                    content_char_start..content_char_end,
+                );
 
-                // Emit closing $ and track it
+                // 3. Emit closing $ syntax span
                 if raw_text.ends_with('$') {
-                    let syn_id = self.gen_syn_id();
-                    let char_start = self.last_char_offset;
-                    let char_end = char_start + 1;
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$</span>",
-                        syn_id, char_start, char_end
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">$</span>",
+                        syn_id, closing_char_start, closing_char_end
                     )?;
-
-                    // Now we know the full formatted range
-                    let formatted_range = format_start..char_end;
-
                     self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
+                        syn_id: syn_id.clone(),
+                        char_range: closing_char_start..closing_char_end,
                         syntax_type: SyntaxType::Inline,
                         formatted_range: Some(formatted_range.clone()),
                     });
+                    self.record_mapping(
+                        range.end - 1..range.end,
+                        closing_char_start..closing_char_end,
+                    );
+                }
 
-                    // Update opening span with formatted_range
-                    if let Some(idx) = opening_span_idx {
-                        self.syntax_spans[idx].formatted_range = Some(formatted_range);
+                // 4. Emit rendered MathML (always visible, not tied to syn_id)
+                // Include data-char-target so clicking moves cursor into the math region
+                // contenteditable="false" so DOM walker skips this for offset counting
+                match weaver_renderer::math::render_math(&text, false) {
+                    weaver_renderer::math::MathResult::Success(mathml) => {
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"math math-inline math-rendered math-clickable\" contenteditable=\"false\" data-char-target=\"{}\">{}</span>",
+                            content_char_start,
+                            mathml
+                        )?;
                     }
+                    weaver_renderer::math::MathResult::Error { html, .. } => {
+                        // Show error indicator (also always visible)
+                        self.write(&html)?;
+                    }
+                }
 
-                    self.last_char_offset += 1;
-                }
+                self.last_char_offset = closing_char_end;
             }
             DisplayMath(text) => {
+                // Math rendering follows embed pattern: syntax spans hide when cursor outside,
+                // rendered content always visible
                 let raw_text = &self.source[range.clone()];
+                let syn_id = self.gen_syn_id();
+                let opening_char_start = self.last_char_offset;
 
-                // Emit opening $$ and track it
+                // Calculate char positions
+                let text_char_len = text.chars().count();
+                let opening_char_end = opening_char_start + 2; // "$$"
+                let content_char_start = opening_char_end;
+                let content_char_end = content_char_start + text_char_len;
+                let closing_char_start = content_char_end;
+                let closing_char_end = closing_char_start + 2; // "$$"
+                let formatted_range = opening_char_start..closing_char_end;
+
+                // 1. Emit opening $$ syntax span
+                // Use Block syntax type so visibility is based on "cursor in same paragraph"
                 if raw_text.starts_with("$$") {
-                    let syn_id = self.gen_syn_id();
-                    let char_start = self.last_char_offset;
-                    let char_end = char_start + 2;
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$$</span>",
-                        syn_id, char_start, char_end
+                        "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">$$</span>",
+                        syn_id, opening_char_start, opening_char_end
                     )?;
                     self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type: SyntaxType::Inline,
-                        formatted_range: None,
+                        syn_id: syn_id.clone(),
+                        char_range: opening_char_start..opening_char_end,
+                        syntax_type: SyntaxType::Block,
+                        formatted_range: Some(formatted_range.clone()),
                     });
-                    self.last_char_offset += 2;
+                    self.record_mapping(
+                        range.start..range.start + 2,
+                        opening_char_start..opening_char_end,
+                    );
                 }
 
-                self.write(r#"<span class="math math-display">"#)?;
-                let text_char_len = text.chars().count();
+                // 2. Emit raw LaTeX content (hidden with syntax when cursor outside)
+                write!(
+                    &mut self.writer,
+                    "<span class=\"math-source\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
+                    syn_id, content_char_start, content_char_end
+                )?;
                 escape_html(&mut self.writer, &text)?;
-                self.last_char_offset += text_char_len;
                 self.write("</span>")?;
+                self.syntax_spans.push(SyntaxSpanInfo {
+                    syn_id: syn_id.clone(),
+                    char_range: content_char_start..content_char_end,
+                    syntax_type: SyntaxType::Block,
+                    formatted_range: Some(formatted_range.clone()),
+                });
+                self.record_mapping(
+                    range.start + 2..range.end - 2,
+                    content_char_start..content_char_end,
+                );
 
-                // Emit closing $$ and track it
+                // 3. Emit closing $$ syntax span
                 if raw_text.ends_with("$$") {
-                    let syn_id = self.gen_syn_id();
-                    let char_start = self.last_char_offset;
-                    let char_end = char_start + 2;
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$$</span>",
-                        syn_id, char_start, char_end
+                        "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">$$</span>",
+                        syn_id, closing_char_start, closing_char_end
                     )?;
                     self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type: SyntaxType::Inline,
-                        formatted_range: None,
+                        syn_id: syn_id.clone(),
+                        char_range: closing_char_start..closing_char_end,
+                        syntax_type: SyntaxType::Block,
+                        formatted_range: Some(formatted_range.clone()),
                     });
-                    self.last_char_offset += 2;
+                    self.record_mapping(
+                        range.end - 2..range.end,
+                        closing_char_start..closing_char_end,
+                    );
+                }
+
+                // 4. Emit rendered MathML (always visible, not tied to syn_id)
+                // Include data-char-target so clicking moves cursor into the math region
+                // contenteditable="false" so DOM walker skips this for offset counting
+                match weaver_renderer::math::render_math(&text, true) {
+                    weaver_renderer::math::MathResult::Success(mathml) => {
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"math math-display math-rendered math-clickable\" contenteditable=\"false\" data-char-target=\"{}\">{}</span>",
+                            content_char_start,
+                            mathml
+                        )?;
+                    }
+                    weaver_renderer::math::MathResult::Error { html, .. } => {
+                        // Show error indicator (also always visible)
+                        self.write(&html)?;
+                    }
                 }
+
+                self.last_char_offset = closing_char_end;
             }
             Html(html) | InlineHtml(html) => {
                 // Track offset mapping for raw HTML
···
 
                         write!(
                             &mut self.writer,
-                            "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                             syn_id, char_start, char_end
                         )?;
                         escape_html(&mut self.writer, trimmed)?;
···
 
                         write!(
                             &mut self.writer,
-                            "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                             syn_id, char_start, char_end
                         )?;
                         escape_html(&mut self.writer, syntax)?;
···
         }
 
         // Emit the opening tag
+        tracing::debug!(?tag, "start_tag");
         match tag {
             Tag::HtmlBlock => Ok(()),
             Tag::Paragraph => {
···
 
                                 write!(
                                     &mut self.writer,
-                                    "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                    "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                                     syn_id, char_start, char_end
                                 )?;
                                 escape_html(&mut self.writer, syntax)?;
···
                             let syn_id = self.gen_syn_id();
                             write!(
                                 &mut self.writer,
-                                "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                                 syn_id, char_start, char_end
                             )?;
                             escape_html(&mut self.writer, syntax)?;
···
                                 let syn_id = self.gen_syn_id();
                                 write!(
                                     &mut self.writer,
-                                    "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                    "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                                     syn_id, char_start, char_end
                                 )?;
                                 escape_html(&mut self.writer, syntax)?;
···
                 self.write("\">")
             }
             Tag::Link {
-                dest_url, title, ..
+                link_type,
+                dest_url,
+                title,
+                ..
             } => {
-                self.write("<a href=\"")?;
+                // Collect refs for later resolution
+                let url = dest_url.as_ref();
+                if matches!(link_type, LinkType::WikiLink { .. }) {
+                    let (target, fragment) = weaver_common::EntryIndex::parse_wikilink(url);
+                    self.ref_collector.add_wikilink(target, fragment, None);
+                } else if url.starts_with("at://") {
+                    self.ref_collector.add_at_link(url);
+                }
+
+                // Determine link validity class for wikilinks
+                let validity_class = if matches!(link_type, LinkType::WikiLink { .. }) {
+                    if let Some(index) = &self.entry_index {
+                        if index.resolve(dest_url.as_ref()).is_some() {
+                            " link-valid"
+                        } else {
+                            " link-broken"
+                        }
+                    } else {
+                        ""
+                    }
+                } else {
+                    ""
+                };
+
+                self.write("<a class=\"link")?;
+                self.write(validity_class)?;
+                self.write("\" href=\"")?;
                 escape_href(&mut self.writer, &dest_url)?;
                 if !title.is_empty() {
                     self.write("\" title=\"")?;
···
                 self.write("\">")
             }
             Tag::Image {
+                link_type,
                 dest_url,
                 title,
+                id,
                 attrs,
-                ..
             } => {
+                // Check if this is actually an AT embed disguised as a wikilink image
+                // (markdown-weaver parses ![[at://...]] as Image with WikiLink link_type)
+                let url = dest_url.as_ref();
+                if matches!(link_type, LinkType::WikiLink { .. })
+                    && (url.starts_with("at://") || url.starts_with("did:"))
+                {
+                    return self.write_embed(
+                        range,
+                        EmbedType::Other, // AT embeds - disambiguated via NSID later
+                        dest_url,
+                        title,
+                        id,
+                        attrs,
+                    );
+                }
+
                 // Image rendering: all syntax elements share one syn_id for visibility toggling
                 // Structure: ![  alt text  ](url)  <img>  cursor-landing
                 let raw_text = &self.source[range.clone()];
···
                 if raw_text.starts_with("![") {
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">![</span>",
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">![</span>",
                         syn_id, opening_char_start, opening_char_end
                     )?;
 
···
                 if !closing_syntax.is_empty() {
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                         syn_id, closing_char_start, closing_char_end
                     )?;
                     escape_html(&mut self.writer, closing_syntax)?;
···
 
                             write!(
                                 &mut self.writer,
-                                "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">",
                                 syn_id, char_start, char_end
                             )?;
                             escape_html(&mut self.writer, fence)?;
···
 
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">]]</span>",
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">]]</span>",
                         syn_id, char_start, char_end
                     )?;
 
···
         id: CowStr<'_>,
         attrs: Option<markdown_weaver::WeaverAttributes<'_>>,
     ) -> Result<(), W::Error> {
-        // Track opening span index for formatted_range
-        let opening_span_idx: Option<usize>;
-        let opening_char_start: usize;
+        // Embed rendering: all syntax elements share one syn_id for visibility toggling
+        // Structure: ![[  url-as-link  ]]  <embed-content>
+        let raw_text = &self.source[range.clone()];
+        let syn_id = self.gen_syn_id();
+        let opening_char_start = self.last_char_offset;
+
+        // Extract the URL from raw text (between ![[ and ]])
+        let url_text = if raw_text.starts_with("![[") && raw_text.ends_with("]]") {
+            &raw_text[3..raw_text.len() - 2]
+        } else {
+            dest_url.as_ref()
+        };
 
-        // Emit opening ![[
-        if range.start < range.end {
-            let raw_text = &self.source[range.clone()];
-            if raw_text.starts_with("![[") {
-                let syn_id = self.gen_syn_id();
-                let char_start = self.last_char_offset;
-                let char_end = char_start + 3; // "![["
+        // Calculate char positions
+        let url_char_len = url_text.chars().count();
+        let opening_char_end = opening_char_start + 3; // "![["
+        let url_char_start = opening_char_end;
+        let url_char_end = url_char_start + url_char_len;
+        let closing_char_start = url_char_end;
+        let closing_char_end = closing_char_start + 2; // "]]"
+        let formatted_range = opening_char_start..closing_char_end;
 
-                write!(
-                    &mut self.writer,
-                    "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">![[</span>",
-                    syn_id, char_start, char_end
-                )?;
+        // 1. Emit opening ![[ syntax span
+        if raw_text.starts_with("![[") {
+            write!(
+                &mut self.writer,
+                "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">![[</span>",
+                syn_id, opening_char_start, opening_char_end
+            )?;
 
-                opening_span_idx = Some(self.syntax_spans.len());
-                opening_char_start = char_start;
-                self.syntax_spans.push(SyntaxSpanInfo {
-                    syn_id,
-                    char_range: char_start..char_end,
-                    syntax_type: SyntaxType::Inline,
-                    formatted_range: None,
-                });
+            self.syntax_spans.push(SyntaxSpanInfo {
+                syn_id: syn_id.clone(),
+                char_range: opening_char_start..opening_char_end,
+                syntax_type: SyntaxType::Inline,
+                formatted_range: Some(formatted_range.clone()),
+            });
 
-                self.last_char_offset = char_end;
-                self.last_byte_offset = range.start + 3;
-            } else {
-                opening_span_idx = None;
-                opening_char_start = self.last_char_offset;
-            }
+            self.record_mapping(
+                range.start..range.start + 3,
+                opening_char_start..opening_char_end,
+            );
+        }
+
+        // 2. Emit URL as a clickable link (same syn_id, shown/hidden with syntax)
+        let url = dest_url.as_ref();
+        let link_href = if url.starts_with("at://") {
+            format!("https://alpha.weaver.sh/record/{}", url)
         } else {
-            opening_span_idx = None;
-            opening_char_start = self.last_char_offset;
+            url.to_string()
+        };
+
+        write!(
+            &mut self.writer,
+            "<a class=\"image-alt embed-url\" href=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" target=\"_blank\">",
+            link_href, syn_id, url_char_start, url_char_end
+        )?;
+        escape_html(&mut self.writer, url_text)?;
+        self.write("</a>")?;
+
+        self.syntax_spans.push(SyntaxSpanInfo {
+            syn_id: syn_id.clone(),
+            char_range: url_char_start..url_char_end,
+            syntax_type: SyntaxType::Inline,
+            formatted_range: Some(formatted_range.clone()),
+        });
+
+        self.record_mapping(
+            range.start + 3..range.end - 2,
+            url_char_start..url_char_end,
+        );
+
+        // 3. Emit closing ]] syntax span
+        if raw_text.ends_with("]]") {
+            write!(
+                &mut self.writer,
+                "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\" spellcheck=\"false\">]]</span>",
+                syn_id, closing_char_start, closing_char_end
+            )?;
+
+            self.syntax_spans.push(SyntaxSpanInfo {
+                syn_id: syn_id.clone(),
+                char_range: closing_char_start..closing_char_end,
+                syntax_type: SyntaxType::Inline,
+                formatted_range: Some(formatted_range.clone()),
+            });
+
+            self.record_mapping(
+                range.end - 2..range.end,
+                closing_char_start..closing_char_end,
+            );
         }
 
+        // Collect AT URI for later resolution
+        if url.starts_with("at://") || url.starts_with("did:") {
+            self.ref_collector.add_at_embed(url, if title.is_empty() { None } else { Some(title.as_ref()) });
+        }
+
+        // 4. Emit the actual embed content
         // Try to get content from attributes first
         let content_from_attrs = if let Some(ref attrs) = attrs {
             attrs
···
         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>")?;
+            // Fallback: render as placeholder div (iframe doesn't make sense for at:// URIs)
+            self.write("<div class=\"atproto-embed atproto-embed-placeholder\">")?;
+            self.write("<span class=\"embed-loading\">Loading embed...</span>")?;
+            self.write("</div>")?;
         }
 
-        // Emit closing ]]
-        if range.start < range.end {
-            let raw_text = &self.source[range.clone()];
-            if raw_text.ends_with("]]") {
-                let syn_id = self.gen_syn_id();
-                let char_start = self.last_char_offset;
-                let char_end = char_start + 2; // "]]"
+        // Consume the text events for the URL (they're still in the iterator)
+        // Use consume_until_end() since we already wrote the URL from source
+        self.consume_until_end();
 
-                write!(
-                    &mut self.writer,
-                    "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">]]</span>",
-                    syn_id, char_start, char_end
-                )?;
-
-                // Set formatted_range on both opening and closing spans
-                let formatted_range = opening_char_start..char_end;
-                self.syntax_spans.push(SyntaxSpanInfo {
-                    syn_id,
-                    char_range: char_start..char_end,
-                    syntax_type: SyntaxType::Inline,
-                    formatted_range: Some(formatted_range.clone()),
-                });
-
-                // Update opening span's formatted_range
-                if let Some(idx) = opening_span_idx {
-                    if let Some(span) = self.syntax_spans.get_mut(idx) {
-                        span.formatted_range = Some(formatted_range);
-                    }
-                }
-
-                self.last_char_offset = char_end;
-                self.last_byte_offset = range.end;
-            }
-        }
+        // Update offsets
+        self.last_char_offset = closing_char_end;
+        self.last_byte_offset = range.end;
 
         Ok(())
     }

crates/weaver-app/src/data.rs

···
     let cid = Cid::new_owned(cid.as_bytes())?;
     cache.cache(ident, cid, name).await
 }
+
+/// Cache blob bytes directly (for pre-warming after upload).
+/// If `notebook` is provided, uses scoped cache key `{notebook}_{name}`.
+#[cfg(feature = "fullstack-server")]
+#[put("/cache-bytes/{cid}?name&notebook", cache: Extension<Arc<BlobCache>>)]
+pub async fn cache_blob_bytes(
+    cid: SmolStr,
+    name: Option<SmolStr>,
+    notebook: Option<SmolStr>,
+    body: jacquard::bytes::Bytes,
+) -> Result<()> {
+    let cid = Cid::new_owned(cid.as_bytes())?;
+    let cache_key = match (&notebook, &name) {
+        (Some(nb), Some(n)) => Some(SmolStr::new(format!("{}_{}", nb, n))),
+        (None, Some(n)) => Some(n.clone()),
+        _ => None,
+    };
+    cache.insert_bytes(cid, body, cache_key);
+    Ok(())
+}

crates/weaver-app/src/fetch.rs

···
     }
 }
 
-//#[cfg(not(feature = "server"))]
 #[derive(Clone)]
 pub struct Fetcher {
     pub client: Arc<Client>,
···
         (AtIdentifier<'static>, SmolStr),
         Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
     >,
+    /// Maps notebook title OR path to ident (book_cache accepts either as key)
+    #[cfg(feature = "server")]
+    notebook_key_cache: cache_impl::Cache<SmolStr, AtIdentifier<'static>>,
     #[cfg(feature = "server")]
     entry_cache: cache_impl::Cache<
         (AtIdentifier<'static>, SmolStr),
···
         cache_impl::Cache<(AtIdentifier<'static>, SmolStr), Arc<StandaloneEntryData>>,
 }
 
-//#[cfg(not(feature = "server"))]
 impl Fetcher {
     pub fn new(client: OAuthClient<JacquardResolver, AuthStore>) -> Self {
         Self {
             client: Arc::new(Client::new(client)),
             #[cfg(feature = "server")]
             book_cache: cache_impl::new_cache(100, std::time::Duration::from_secs(30)),
+            #[cfg(feature = "server")]
+            notebook_key_cache: cache_impl::new_cache(500, std::time::Duration::from_secs(30)),
             #[cfg(feature = "server")]
             entry_cache: cache_impl::new_cache(100, std::time::Duration::from_secs(30)),
             #[cfg(feature = "server")]
···
         {
             let stored = Arc::new((notebook, entries));
             #[cfg(feature = "server")]
-            cache_impl::insert(&self.book_cache, (ident, title), stored.clone());
+            {
+                // Cache by title
+                cache_impl::insert(&self.notebook_key_cache, title.clone(), ident.clone());
+                cache_impl::insert(&self.book_cache, (ident.clone(), title), stored.clone());
+                // Also cache by path if available
+                if let Some(path) = stored.0.path.as_ref() {
+                    let path: SmolStr = path.as_ref().into();
+                    cache_impl::insert(&self.notebook_key_cache, path.clone(), ident.clone());
+                    cache_impl::insert(&self.book_cache, (ident, path), stored.clone());
+                }
+            }
             Ok(Some(stored))
         } else {
             Err(dioxus::CapturedError::from_display("Notebook not found"))
         }
     }
 
+    /// Get notebook by title or path (for image resolution without knowing owner).
+    /// Checks notebook_key_cache first, falls back to UFOS discovery.
+    #[cfg(feature = "server")]
+    pub async fn get_notebook_by_key(
+        &self,
+        key: &str,
+    ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+        let key: SmolStr = key.into();
+
+        // Check cache first (key could be title or path)
+        if let Some(ident) = cache_impl::get(&self.notebook_key_cache, &key) {
+            return self.get_notebook(ident, key).await;
+        }
+
+        // Fallback: query UFOS and populate caches
+        let notebooks = self.fetch_notebooks_from_ufos().await?;
+        Ok(notebooks.into_iter().find(|arc| {
+            let (view, _) = arc.as_ref();
+            view.title.as_deref() == Some(key.as_str())
+                || view.path.as_deref() == Some(key.as_str())
+        }))
+    }
+
     pub async fn get_entry(
         &self,
         ident: AtIdentifier<'static>,
···
 
                     let result = Arc::new((notebook, entries));
                     #[cfg(feature = "server")]
-                    cache_impl::insert(&self.book_cache, (ident, title), result.clone());
+                    {
+                        // Cache by title
+                        cache_impl::insert(&self.notebook_key_cache, title.clone(), ident.clone());
+                        cache_impl::insert(
+                            &self.book_cache,
+                            (ident.clone(), title),
+                            result.clone(),
+                        );
+                        // Also cache by path if available
+                        if let Some(path) = result.0.path.as_ref() {
+                            let path: SmolStr = path.as_ref().into();
+                            cache_impl::insert(
+                                &self.notebook_key_cache,
+                                path.clone(),
+                                ident.clone(),
+                            );
+                            cache_impl::insert(&self.book_cache, (ident, path), result.clone());
+                        }
+                    }
                     notebooks.push(result);
                 }
                 Err(_) => continue, // Skip notebooks that fail to load
···
 
                         let result = Arc::new((notebook, entries));
                         #[cfg(feature = "server")]
-                        cache_impl::insert(&self.book_cache, (ident, title), result.clone());
+                        {
+                            // Cache by title
+                            cache_impl::insert(
+                                &self.notebook_key_cache,
+                                title.clone(),
+                                ident.clone(),
+                            );
+                            cache_impl::insert(
+                                &self.book_cache,
+                                (ident.clone(), title),
+                                result.clone(),
+                            );
+                            // Also cache by path if available
+                            if let Some(path) = result.0.path.as_ref() {
+                                let path: SmolStr = path.as_ref().into();
+                                cache_impl::insert(
+                                    &self.notebook_key_cache,
+                                    path.clone(),
+                                    ident.clone(),
+                                );
+                                cache_impl::insert(&self.book_cache, (ident, path), result.clone());
+                            }
+                        }
                         notebooks.push(result);
                     }
                     Err(_) => continue, // Skip notebooks that fail to load

crates/weaver-app/src/main.rs

···
 
         #[cfg(feature = "fullstack-server")]
         let router = {
-            use jacquard::client::UnauthenticatedSession;
             let fetcher = Arc::new(fetch::Fetcher::new(OAuthClient::new(
                 AuthStore::new(),
                 ClientData::new_public(CONFIG.oauth.clone()),
             )));
-            let blob_cache = Arc::new(BlobCache::new(Arc::new(
-                UnauthenticatedSession::new_public(),
-            )));
+            let blob_cache = Arc::new(BlobCache::new(fetcher.clone()));
             axum::Router::new()
                 .route("/favicon.ico", get(favicon))
                 // Server side render the application, serve static assets, and register server functions
···
 }
 
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
-#[get("/{_notebook}/image/{name}", blob_cache: Extension<Arc<crate::blobcache::BlobCache>>)]
-pub async fn image_named(_notebook: SmolStr, name: SmolStr) -> Result<axum::response::Response> {
+#[get("/{notebook}/image/{name}", blob_cache: Extension<Arc<crate::blobcache::BlobCache>>)]
+pub async fn image_named(notebook: SmolStr, name: SmolStr) -> Result<axum::response::Response> {
     if let Some(bytes) = blob_cache.get_named(&name) {
-        Ok(build_image_response(bytes))
-    } else {
-        Ok(image_not_found())
+        return Ok(build_image_response(bytes));
+    }
+
+    // Try to resolve from notebook
+    match blob_cache.resolve_from_notebook(&notebook, &name).await {
+        Ok(bytes) => Ok(build_image_response(bytes)),
+        Err(_) => Ok(image_not_found()),
     }
 }
 

crates/weaver-app/src/views/drafts.rs

···
     rkey: ReadSignal<SmolStr>,
 ) -> Element {
     use crate::components::editor::MarkdownEditor;
+    use crate::data::use_notebook_entries;
     use crate::views::editor::EditorCss;
+    use weaver_common::EntryIndex;
 
     // Construct AT-URI for the entry
     let entry_uri =
         use_memo(move || format!("at://{}/sh.weaver.notebook.entry/{}", ident(), rkey()));
 
+    // Fetch notebook entries for wikilink validation
+    let (_entries_resource, entries_memo) = use_notebook_entries(ident, book_title);
+
+    // Build entry index from notebook entries
+    let entry_index = use_memo(move || {
+        entries_memo().map(|entries| {
+            let mut index = EntryIndex::new();
+            let ident_str = ident().to_string();
+            let book = book_title();
+            for book_entry in &entries {
+                // EntryView has optional title/path
+                let title = book_entry.entry.title.as_ref().map(|t| t.as_str()).unwrap_or("");
+                let path = book_entry.entry.path.as_ref().map(|p| p.as_str()).unwrap_or("");
+                if !title.is_empty() || !path.is_empty() {
+                    // Build canonical URL: /{ident}/{book}/{path}
+                    let canonical_url = format!("/{}/{}/{}", ident_str, book, path);
+                    index.add_entry(title, path, canonical_url);
+                }
+            }
+            index
+        })
+    });
+
     rsx! {
         EditorCss {}
         div { class: "editor-page",
-            MarkdownEditor { entry_uri: Some(entry_uri()), target_notebook: Some(book_title()) }
+            MarkdownEditor {
+                entry_uri: Some(entry_uri()),
+                target_notebook: Some(book_title()),
+                entry_index: entry_index(),
+            }
         }
     }
 }

crates/weaver-cli/src/main.rs

···
         use jacquard::http_client::HttpClient;
         use weaver_common::WeaverExt;
         let (entry_ref, was_created) = agent
-            .upsert_entry(&title, entry_title.as_ref(), entry)
+            .upsert_entry(&title, entry_title.as_ref(), entry, None)
             .await?;
 
         if was_created {

crates/weaver-common/src/agent.rs

···
         }
     }
 
-    /// Find or create an entry within a notebook by title
+    /// Find or create an entry within a notebook
     ///
     /// Multi-step workflow:
     /// 1. Find the notebook by title
-    /// 2. Check notebook's entry_list for entry with matching title
+    /// 2. If existing_rkey is provided, match by rkey; otherwise match by title
     /// 3. If found: update the entry with new content
     /// 4. If not found: create new entry and append to notebook's entry_list
     ///
+    /// The `existing_rkey` parameter allows updating an entry even if its title changed,
+    /// and enables pre-generating rkeys for path rewriting before publish.
+    ///
     /// Returns (entry_ref, was_created)
     fn upsert_entry(
         &self,
         notebook_title: &str,
         entry_title: &str,
         entry: entry::Entry<'_>,
+        existing_rkey: Option<&str>,
     ) -> impl Future<Output = Result<(StrongRef<'static>, bool), WeaverError>>
     where
         Self: Sized,
···
 
             // Find or create notebook
             let (notebook_uri, entry_refs) = self.upsert_notebook(notebook_title, &did).await?;
+
+            // If we have an existing rkey, try to find and update that specific entry
+            if let Some(rkey) = existing_rkey {
+                // Check if this entry exists in the notebook by comparing rkeys
+                for entry_ref in &entry_refs {
+                    let ref_rkey = entry_ref.uri.rkey().map(|r| r.0.as_str());
+                    if ref_rkey == Some(rkey) {
+                        // Found it - update
+                        let output = self
+                            .update_record::<entry::Entry>(&entry_ref.uri, |e| {
+                                e.content = entry.content.clone();
+                                e.title = entry.title.clone();
+                                e.path = entry.path.clone();
+                                e.embeds = entry.embeds.clone();
+                                e.tags = entry.tags.clone();
+                            })
+                            .await?;
+                        let updated_ref = StrongRef::new()
+                            .uri(output.uri.into_static())
+                            .cid(output.cid.into_static())
+                            .build();
+                        return Ok((updated_ref, false));
+                    }
+                }
+
+                // Entry with this rkey not in notebook - create with specific rkey
+                let response = self
+                    .create_record(entry, Some(RecordKey::any(rkey)?))
+                    .await?;
+                let new_ref = StrongRef::new()
+                    .uri(response.uri.clone().into_static())
+                    .cid(response.cid.clone().into_static())
+                    .build();
+
+                use weaver_api::sh_weaver::notebook::book::Book;
+                let notebook_entry_ref = StrongRef::new()
+                    .uri(response.uri.into_static())
+                    .cid(response.cid.into_static())
+                    .build();
+
+                self.update_record::<Book>(&notebook_uri, |book| {
+                    book.entry_list.push(notebook_entry_ref);
+                })
+                .await?;
+
+                return Ok((new_ref, true));
+            }
+
+            // No existing rkey - use title-based matching (original behavior)
 
             // Fast path: if notebook is empty, skip search and create directly
             if entry_refs.is_empty() {

crates/weaver-common/src/lib.rs

···
 pub mod agent;
 pub mod constellation;
 pub mod error;
+pub mod resolve;
 pub mod worker_rt;
 
 // Re-export jacquard for convenience
 pub use agent::WeaverExt;
 pub use error::WeaverError;
+pub use resolve::{EntryIndex, ExtractedRef, RefCollector, ResolvedContent, ResolvedEntry};
+#[cfg(any(test, feature = "standalone-collection"))]
+pub use resolve::collect_refs_from_markdown;
 pub use jacquard;
 use jacquard::CowStr;
 use jacquard::client::{Agent, AgentSession};

crates/weaver-common/src/resolve.rs

···
+//! Wikilink and embed resolution types for rendering without network calls
+//!
+//! This module provides pre-resolution infrastructure so that markdown rendering
+//! can happen synchronously without network calls in the hot path.
+
+use std::collections::HashMap;
+
+use jacquard::CowStr;
+use jacquard::smol_str::SmolStr;
+use jacquard::types::string::AtUri;
+use weaver_api::com_atproto::repo::strong_ref::StrongRef;
+
+/// Pre-resolved data for rendering without network calls.
+///
+/// Populated during an async collection phase, then passed to the sync render phase.
+#[derive(Debug, Clone, Default)]
+pub struct ResolvedContent {
+    /// Wikilink target (lowercase) → resolved entry info
+    pub entry_links: HashMap<SmolStr, ResolvedEntry>,
+    /// AT URI → rendered HTML content
+    pub embed_content: HashMap<AtUri<'static>, CowStr<'static>>,
+    /// AT URI → StrongRef for populating records array
+    pub embed_refs: Vec<StrongRef<'static>>,
+}
+
+/// A resolved entry reference from a wikilink
+#[derive(Debug, Clone)]
+pub struct ResolvedEntry {
+    /// The canonical URL path (e.g., "/handle/notebook/entry_path")
+    pub canonical_path: CowStr<'static>,
+    /// The original entry title for display
+    pub display_title: CowStr<'static>,
+}
+
+impl ResolvedContent {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Look up a wikilink target, returns the resolved entry if found
+    pub fn resolve_wikilink(&self, target: &str) -> Option<&ResolvedEntry> {
+        // Strip fragment if present
+        let (target, _fragment) = target.split_once('#').unwrap_or((target, ""));
+        let key = SmolStr::new(target.to_lowercase());
+        self.entry_links.get(&key)
+    }
+
+    /// Get pre-rendered embed content for an AT URI
+    pub fn get_embed_content(&self, uri: &AtUri<'_>) -> Option<&str> {
+        // Need to look up by equivalent URI, not exact reference
+        self.embed_content
+            .iter()
+            .find(|(k, _)| k.as_str() == uri.as_str())
+            .map(|(_, v)| v.as_ref())
+    }
+
+    /// Add a resolved entry link
+    pub fn add_entry(
+        &mut self,
+        target: &str,
+        canonical_path: impl Into<CowStr<'static>>,
+        display_title: impl Into<CowStr<'static>>,
+    ) {
+        self.entry_links.insert(
+            SmolStr::new(target.to_lowercase()),
+            ResolvedEntry {
+                canonical_path: canonical_path.into(),
+                display_title: display_title.into(),
+            },
+        );
+    }
+
+    /// Add resolved embed content
+    pub fn add_embed(
+        &mut self,
+        uri: AtUri<'static>,
+        html: impl Into<CowStr<'static>>,
+        strong_ref: Option<StrongRef<'static>>,
+    ) {
+        self.embed_content.insert(uri, html.into());
+        if let Some(sr) = strong_ref {
+            self.embed_refs.push(sr);
+        }
+    }
+}
+
+/// Index of entries within a notebook for wikilink resolution.
+///
+/// Supports case-insensitive matching against entry title OR path slug.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct EntryIndex {
+    /// lowercase title → (canonical_path, original_title)
+    by_title: HashMap<SmolStr, (CowStr<'static>, CowStr<'static>)>,
+    /// lowercase path slug → (canonical_path, original_title)
+    by_path: HashMap<SmolStr, (CowStr<'static>, CowStr<'static>)>,
+}
+
+impl EntryIndex {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add an entry to the index
+    pub fn add_entry(
+        &mut self,
+        title: &str,
+        path: &str,
+        canonical_url: impl Into<CowStr<'static>>,
+    ) {
+        let canonical: CowStr<'static> = canonical_url.into();
+        let title_cow: CowStr<'static> = CowStr::from(title.to_string());
+
+        self.by_title.insert(
+            SmolStr::new(title.to_lowercase()),
+            (canonical.clone(), title_cow.clone()),
+        );
+        self.by_path
+            .insert(SmolStr::new(path.to_lowercase()), (canonical, title_cow));
+    }
+
+    /// Resolve a wikilink target to (canonical_path, display_title, fragment)
+    ///
+    /// Matches case-insensitively against title first, then path slug.
+    /// Fragment (if present) is returned with the input's lifetime.
+    pub fn resolve<'a, 'b>(
+        &'a self,
+        wikilink: &'b str,
+    ) -> Option<(&'a str, &'a str, Option<&'b str>)> {
+        let (target, fragment) = match wikilink.split_once('#') {
+            Some((t, f)) => (t, Some(f)),
+            None => (wikilink, None),
+        };
+        let key = SmolStr::new(target.to_lowercase());
+
+        // Try title match first
+        if let Some((path, title)) = self.by_title.get(&key) {
+            return Some((path.as_ref(), title.as_ref(), fragment));
+        }
+
+        // Try path match
+        if let Some((path, title)) = self.by_path.get(&key) {
+            return Some((path.as_ref(), title.as_ref(), fragment));
+        }
+
+        None
+    }
+
+    /// Parse a wikilink into (target, fragment)
+    pub fn parse_wikilink(wikilink: &str) -> (&str, Option<&str>) {
+        match wikilink.split_once('#') {
+            Some((t, f)) => (t, Some(f)),
+            None => (wikilink, None),
+        }
+    }
+
+    /// Check if the index contains any entries
+    pub fn is_empty(&self) -> bool {
+        self.by_title.is_empty()
+    }
+
+    /// Get the number of entries
+    pub fn len(&self) -> usize {
+        self.by_title.len()
+    }
+}
+
+/// Reference extracted from markdown that needs resolution
+#[derive(Debug, Clone, PartialEq)]
+pub enum ExtractedRef {
+    /// Wikilink like [[Entry Name]] or [[Entry Name#header]]
+    Wikilink {
+        target: String,
+        fragment: Option<String>,
+        display_text: Option<String>,
+    },
+    /// AT Protocol embed like ![[at://did/collection/rkey]] or ![alt](at://...)
+    AtEmbed {
+        uri: String,
+        alt_text: Option<String>,
+    },
+    /// AT Protocol link like [text](at://...)
+    AtLink { uri: String },
+}
+
+/// Collector for refs encountered during rendering.
+///
+/// Pass this to renderers to collect refs as a side effect of the render pass.
+/// This avoids a separate parsing pass just for collection.
+#[derive(Debug, Clone, Default)]
+pub struct RefCollector {
+    pub refs: Vec<ExtractedRef>,
+}
+
+impl RefCollector {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Record a wikilink reference
+    pub fn add_wikilink(
+        &mut self,
+        target: &str,
+        fragment: Option<&str>,
+        display_text: Option<&str>,
+    ) {
+        self.refs.push(ExtractedRef::Wikilink {
+            target: target.to_string(),
+            fragment: fragment.map(|s| s.to_string()),
+            display_text: display_text.map(|s| s.to_string()),
+        });
+    }
+
+    /// Record an AT Protocol embed reference
+    pub fn add_at_embed(&mut self, uri: &str, alt_text: Option<&str>) {
+        self.refs.push(ExtractedRef::AtEmbed {
+            uri: uri.to_string(),
+            alt_text: alt_text.map(|s| s.to_string()),
+        });
+    }
+
+    /// Record an AT Protocol link reference
+    pub fn add_at_link(&mut self, uri: &str) {
+        self.refs.push(ExtractedRef::AtLink {
+            uri: uri.to_string(),
+        });
+    }
+
+    /// Get wikilinks that need resolution
+    pub fn wikilinks(&self) -> impl Iterator<Item = &str> {
+        self.refs.iter().filter_map(|r| match r {
+            ExtractedRef::Wikilink { target, .. } => Some(target.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Get AT URIs that need fetching
+    pub fn at_uris(&self) -> impl Iterator<Item = &str> {
+        self.refs.iter().filter_map(|r| match r {
+            ExtractedRef::AtEmbed { uri, .. } | ExtractedRef::AtLink { uri } => Some(uri.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Take ownership of collected refs
+    pub fn take(self) -> Vec<ExtractedRef> {
+        self.refs
+    }
+}
+
+/// Extract all references from markdown that need resolution.
+///
+/// **Note:** This does a separate parsing pass. For production use, prefer
+/// passing a `RefCollector` to the renderer to collect during the render pass.
+/// This function is primarily useful for testing or quick analysis.
+#[cfg(any(test, feature = "standalone-collection"))]
+pub fn collect_refs_from_markdown(markdown: &str) -> Vec<ExtractedRef> {
+    use markdown_weaver::{Event, LinkType, Options, Parser, Tag};
+
+    let mut collector = RefCollector::new();
+    let options = Options::all();
+    let parser = Parser::new_ext(markdown, options);
+
+    for event in parser {
+        match event {
+            Event::Start(Tag::Link {
+                link_type,
+                dest_url,
+                ..
+            }) => {
+                let url = dest_url.as_ref();
+
+                if matches!(link_type, LinkType::WikiLink { .. }) {
+                    let (target, fragment) = match url.split_once('#') {
+                        Some((t, f)) => (t, Some(f)),
+                        None => (url, None),
+                    };
+                    collector.add_wikilink(target, fragment, None);
+                } else if url.starts_with("at://") {
+                    collector.add_at_link(url);
+                }
+            }
+            Event::Start(Tag::Embed {
+                dest_url, title, ..
+            }) => {
+                let url = dest_url.as_ref();
+
+                if url.starts_with("at://") || url.starts_with("did:") {
+                    let alt = if title.is_empty() {
+                        None
+                    } else {
+                        Some(title.as_ref())
+                    };
+                    collector.add_at_embed(url, alt);
+                } else if !url.starts_with("http://") && !url.starts_with("https://") {
+                    let (target, fragment) = match url.split_once('#') {
+                        Some((t, f)) => (t, Some(f)),
+                        None => (url, None),
+                    };
+                    collector.add_wikilink(target, fragment, None);
+                }
+            }
+            Event::Start(Tag::Image {
+                dest_url, title, ..
+            }) => {
+                let url = dest_url.as_ref();
+
+                if url.starts_with("at://") {
+                    let alt = if title.is_empty() {
+                        None
+                    } else {
+                        Some(title.as_ref())
+                    };
+                    collector.add_at_embed(url, alt);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    collector.take()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use jacquard::IntoStatic;
+
+    #[test]
+    fn test_entry_index_resolve_by_title() {
+        let mut index = EntryIndex::new();
+        index.add_entry(
+            "My First Note",
+            "my_first_note",
+            "/alice/notebook/my_first_note",
+        );
+
+        let result = index.resolve("My First Note");
+        assert!(result.is_some());
+        let (path, title, fragment) = result.unwrap();
+        assert_eq!(path, "/alice/notebook/my_first_note");
+        assert_eq!(title, "My First Note");
+        assert_eq!(fragment, None);
+    }
+
+    #[test]
+    fn test_entry_index_resolve_case_insensitive() {
+        let mut index = EntryIndex::new();
+        index.add_entry(
+            "My First Note",
+            "my_first_note",
+            "/alice/notebook/my_first_note",
+        );
+
+        let result = index.resolve("my first note");
+        assert!(result.is_some());
+    }
+
+    #[test]
+    fn test_entry_index_resolve_by_path() {
+        let mut index = EntryIndex::new();
+        index.add_entry(
+            "My First Note",
+            "my_first_note",
+            "/alice/notebook/my_first_note",
+        );
+
+        let result = index.resolve("my_first_note");
+        assert!(result.is_some());
+    }
+
+    #[test]
+    fn test_entry_index_resolve_with_fragment() {
+        let mut index = EntryIndex::new();
+        index.add_entry("My Note", "my_note", "/alice/notebook/my_note");
+
+        let result = index.resolve("My Note#section");
+        assert!(result.is_some());
+        let (path, title, fragment) = result.unwrap();
+        assert_eq!(path, "/alice/notebook/my_note");
+        assert_eq!(title, "My Note");
+        assert_eq!(fragment, Some("section"));
+    }
+
+    #[test]
+    fn test_collect_refs_wikilink() {
+        let markdown = "Check out [[My Note]] for more info.";
+        let refs = collect_refs_from_markdown(markdown);
+
+        assert_eq!(refs.len(), 1);
+        assert!(matches!(
+            &refs[0],
+            ExtractedRef::Wikilink { target, .. } if target == "My Note"
+        ));
+    }
+
+    #[test]
+    fn test_collect_refs_at_link() {
+        let markdown = "See [this post](at://did:plc:xyz/app.bsky.feed.post/abc)";
+        let refs = collect_refs_from_markdown(markdown);
+
+        assert_eq!(refs.len(), 1);
+        assert!(matches!(
+            &refs[0],
+            ExtractedRef::AtLink { uri } if uri == "at://did:plc:xyz/app.bsky.feed.post/abc"
+        ));
+    }
+
+    #[test]
+    fn test_collect_refs_at_embed() {
+        let markdown = "![[at://did:plc:xyz/app.bsky.feed.post/abc]]";
+        let refs = collect_refs_from_markdown(markdown);
+
+        assert_eq!(refs.len(), 1);
+        assert!(matches!(
+            &refs[0],
+            ExtractedRef::AtEmbed { uri, .. } if uri == "at://did:plc:xyz/app.bsky.feed.post/abc"
+        ));
+    }
+
+    #[test]
+    fn test_resolved_content_wikilink_lookup() {
+        let mut content = ResolvedContent::new();
+        content.add_entry("My Note", "/alice/notebook/my_note", "My Note");
+
+        let result = content.resolve_wikilink("my note");
+        assert!(result.is_some());
+        assert_eq!(
+            result.unwrap().canonical_path.as_ref(),
+            "/alice/notebook/my_note"
+        );
+    }
+
+    #[test]
+    fn test_resolved_content_embed_lookup() {
+        let mut content = ResolvedContent::new();
+        let uri = AtUri::new("at://did:plc:xyz/app.bsky.feed.post/abc").unwrap();
+        content.add_embed(uri.into_static(), "<div>post content</div>", None);
+
+        let lookup_uri = AtUri::new("at://did:plc:xyz/app.bsky.feed.post/abc").unwrap();
+        let result = content.get_embed_content(&lookup_uri);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "<div>post content</div>");
+    }
+}

crates/weaver-renderer/Cargo.toml

···
 pin-utils = "0.1.0"
 pin-project = "1.1.10"
 smol_str = { version = "0.3", features = ["serde"] }
+pulldown-latex = "0.6"
 mime-sniffer = "0.1.3"
 reqwest = { version = "0.12.7", default-features = false, features = [
     "json",

crates/weaver-renderer/src/atproto.rs

···
 
 pub use client::{ClientContext, DefaultEmbedResolver, EmbedResolver};
 pub use embed_renderer::{
-    fetch_and_render_generic, fetch_and_render_post, fetch_and_render_profile,
+    fetch_and_render, fetch_and_render_generic, fetch_and_render_post, fetch_and_render_profile,
 };
 pub use error::{AtProtoPreprocessError, ClientRenderError};
 pub use markdown_writer::MarkdownWriter;

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

···
     prelude::IdentityResolver,
     types::string::{AtUri, Cid, Did},
 };
-use markdown_weaver::{CowStr as MdCowStr, Tag, WeaverAttributes};
+use markdown_weaver::{CowStr as MdCowStr, LinkType, Tag, WeaverAttributes};
 use std::collections::HashMap;
 use std::sync::Arc;
 use weaver_api::sh_weaver::notebook::entry::Entry;
+use weaver_common::{EntryIndex, ResolvedContent};
 
 /// Trait for resolving embed content on the client side
 ///
···
 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)
+        fetch_and_render_profile(uri.authority(), &*self.agent)
             .await
             .map_err(|e| ClientRenderError::EntryFetch {
                 uri: uri.as_ref().to_string(),
···
     embed_resolver: Option<Arc<R>>,
     embed_depth: usize,
 
+    // Pre-resolved content for sync rendering
+    entry_index: Option<EntryIndex>,
+    resolved_content: Option<ResolvedContent>,
+
     // Shared state
     frontmatter: Frontmatter,
     title: MdCowStr<'a>,
···
             blob_map,
             embed_resolver: None,
             embed_depth: 0,
+            entry_index: None,
+            resolved_content: None,
             frontmatter: Frontmatter::default(),
             title,
         }
···
             blob_map: self.blob_map,
             embed_resolver: Some(resolver),
             embed_depth: self.embed_depth,
+            entry_index: self.entry_index,
+            resolved_content: self.resolved_content,
             frontmatter: self.frontmatter,
             title: self.title,
         }
     }
+
+    /// Add an entry index for wikilink resolution
+    pub fn with_entry_index(mut self, index: EntryIndex) -> Self {
+        self.entry_index = Some(index);
+        self
+    }
+
+    /// Add pre-resolved content for sync rendering
+    pub fn with_resolved_content(mut self, content: ResolvedContent) -> Self {
+        self.resolved_content = Some(content);
+        self
+    }
 }
 
 impl<'a, R: EmbedResolver> ClientContext<'a, R> {
···
             blob_map: self.blob_map.clone(),
             embed_resolver: self.embed_resolver.clone(),
             embed_depth: depth,
+            entry_index: self.entry_index.clone(),
+            resolved_content: self.resolved_content.clone(),
             frontmatter: self.frontmatter.clone(),
             title: self.title.clone(),
         }
     }
 
+    /// Build an embed tag with resolved content attached
+    fn build_embed_with_content<'s>(
+        &self,
+        embed_type: markdown_weaver::EmbedType,
+        url: String,
+        title: MdCowStr<'s>,
+        id: MdCowStr<'s>,
+        content: String,
+        is_at_uri: bool,
+    ) -> Tag<'s> {
+        let mut attrs = WeaverAttributes {
+            classes: vec![],
+            attrs: vec![],
+        };
+
+        attrs.attrs.push(("content".into(), content.into()));
+
+        // Add metadata for client-side enhancement
+        if is_at_uri {
+            attrs
+                .attrs
+                .push(("data-embed-uri".into(), url.clone().into()));
+
+            if let Ok(at_uri) = AtUri::new(&url) {
+                if at_uri.collection().is_none() {
+                    attrs
+                        .attrs
+                        .push(("data-embed-type".into(), "profile".into()));
+                } else {
+                    attrs.attrs.push(("data-embed-type".into(), "post".into()));
+                }
+            }
+        }
+
+        Tag::Embed {
+            embed_type,
+            dest_url: MdCowStr::Boxed(url.into_boxed_str()),
+            title,
+            id,
+            attrs: Some(attrs),
+        }
+    }
+
     fn build_blob_map<'b>(entry: &Entry<'b>) -> HashMap<BlobName<'static>, Cid<'static>> {
         use jacquard::IntoStatic;
 
···
                 title,
                 id,
             } => {
+                // Handle WikiLinks via EntryIndex
+                if matches!(link_type, LinkType::WikiLink { .. }) {
+                    if let Some(index) = &self.entry_index {
+                        let url = dest_url.as_ref();
+                        if let Some((path, _title, fragment)) = index.resolve(url) {
+                            // Build resolved URL with optional fragment
+                            let resolved_url = match fragment {
+                                Some(frag) => format!("{}#{}", path, frag),
+                                None => path.to_string(),
+                            };
+
+                            return Tag::Link {
+                                link_type: *link_type,
+                                dest_url: MdCowStr::Boxed(resolved_url.into_boxed_str()),
+                                title: title.clone(),
+                                id: id.clone(),
+                            };
+                        }
+                    }
+                    // Unresolved wikilink - render as broken link
+                    return Tag::Link {
+                        link_type: *link_type,
+                        dest_url: MdCowStr::Boxed(format!("#{}", dest_url).into_boxed_str()),
+                        title: title.clone(),
+                        id: id.clone(),
+                    };
+                }
+
                 let url = dest_url.as_ref();
 
                 // Try to parse as AT URI
···
     }
 
     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;
-                };
+        let Tag::Embed {
+            embed_type,
+            dest_url,
+            title,
+            id,
+            attrs,
+        } = &embed
+        else {
+            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![],
-                    });
+        // 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;
+            }
+        }
 
-                    new_attrs.attrs.push(("content".into(), content.into()));
+        // Own the URL to avoid borrow issues
+        let url: String = dest_url.to_string();
 
-                    // Add metadata for client-side enhancement
-                    if dest_url.starts_with("at://") {
-                        new_attrs
-                            .attrs
-                            .push(("data-embed-uri".into(), dest_url.clone()));
+        // Check recursion depth
+        if self.embed_depth >= MAX_EMBED_DEPTH {
+            return embed;
+        }
 
-                        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()));
+        // First check for pre-resolved AT URI content
+        if url.starts_with("at://") {
+            if let Ok(at_uri) = AtUri::new(&url) {
+                if let Some(resolved) = &self.resolved_content {
+                    if let Some(content) = resolved.get_embed_content(&at_uri) {
+                        return self.build_embed_with_content(
+                            *embed_type,
+                            url.clone(),
+                            title.clone(),
+                            id.clone(),
+                            content.to_string(),
+                            true,
+                        );
                     }
+                }
+            }
+        }
 
-                    Tag::Embed {
+        // Check for wikilink-style embed (![[Entry Name]]) via entry index
+        if !url.starts_with("at://") && !url.starts_with("http://") && !url.starts_with("https://")
+        {
+            if let Some(index) = &self.entry_index {
+                if let Some((path, _title, fragment)) = index.resolve(&url) {
+                    // Entry embed - link to the entry
+                    let resolved_url = match fragment {
+                        Some(frag) => format!("{}#{}", path, frag),
+                        None => path.to_string(),
+                    };
+                    return Tag::Embed {
                         embed_type: *embed_type,
-                        dest_url: dest_url.clone(),
+                        dest_url: MdCowStr::Boxed(resolved_url.into_boxed_str()),
                         title: title.clone(),
                         id: id.clone(),
-                        attrs: Some(new_attrs),
-                    }
+                        attrs: attrs.clone(),
+                    };
+                }
+            }
+            // Unresolved entry embed - pass through
+            return embed;
+        }
+
+        // Fallback to async resolver if available
+        let Some(resolver) = &self.embed_resolver else {
+            return embed;
+        };
+
+        // Try to fetch content based on URL type
+        let content_result = if url.starts_with("at://") {
+            // AT Protocol embed
+            if let Ok(at_uri) = AtUri::new(&url) {
+                if at_uri.collection().is_none() && at_uri.rkey().is_none() {
+                    // Profile embed
+                    resolver.resolve_profile(&at_uri).await
                 } else {
-                    // Fetch failed, return original
-                    embed
+                    // Post/record embed
+                    resolver.resolve_post(&at_uri).await
                 }
+            } else {
+                return embed;
             }
-            _ => embed,
+        } else if url.starts_with("http://") || url.starts_with("https://") {
+            // Markdown embed
+            resolver.resolve_markdown(&url, self.embed_depth + 1).await
+        } else {
+            return embed;
+        };
+
+        // If we got content, attach it
+        if let Ok(content) = content_result {
+            let is_at = url.starts_with("at://");
+            self.build_embed_with_content(
+                *embed_type,
+                url,
+                title.clone(),
+                id.clone(),
+                content,
+                is_at,
+            )
+        } else {
+            embed
         }
     }
 
···
     #[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");
+        assert_eq!(
+            at_uri_to_web_url(&uri),
+            "https://alpha.weaver.sh/did:plc:xyz123"
+        );
     }
 
     #[test]
···
         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"
+            "https://alpha.weaver.sh/record/at://did:plc:xyz123/sh.weaver.notebook.entry/entry123"
         );
     }
 
···
         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"
+            "https://alpha.weaver.sh/record/at://did:plc:xyz123/com.example.unknown/rkey"
         );
     }
 }

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

···
 //!
 //! This module provides functions to fetch records from PDSs and render them
 //! as HTML strings suitable for embedding in markdown content.
+//!
+//! # Reusable render functions
+//!
+//! The `render_*` functions can be used standalone for rendering different embed types:
+//! - `render_external_link` - Link cards with title, description, thumbnail
+//! - `render_images` - Image galleries
+//! - `render_quoted_record` - Quoted posts/records
+//! - `render_author_block` - Author avatar + name + handle
 
+use super::error::AtProtoPreprocessError;
 use jacquard::{
-    client::{Agent, AgentSession, AgentSessionExt, ClientError},
-    prelude::IdentityResolver,
-    types::string::{AtUri, Did, Nsid},
-    xrpc::{self, Response, XrpcClient},
-    http_client::HttpClient,
-    Data,
+    Data, IntoStatic,
+    client::AgentSessionExt,
+    types::{ident::AtIdentifier, string::AtUri},
 };
-use weaver_api::com_atproto::repo::get_record::{GetRecord, GetRecordResponse, GetRecordOutput};
-use super::error::AtProtoPreprocessError;
+use weaver_api::app_bsky::{
+    actor::ProfileViewBasic,
+    embed::{
+        external::ViewExternal,
+        images::ViewImage,
+        record::{ViewRecord, ViewUnionRecord},
+    },
+    feed::{PostView, PostViewEmbed, get_posts::GetPosts},
+};
+use weaver_api::sh_weaver::actor::ProfileDataViewInner;
+use weaver_common::agent::WeaverExt;
 
-/// Get a record without type validation, returning untyped Data
+/// Fetch and render a profile record as HTML
 ///
-/// 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;
+/// Resolves handle to DID if needed, then fetches profile data from
+/// weaver or bsky appview, returning a rich profile view.
+pub async fn fetch_and_render_profile<A>(
+    ident: &AtIdentifier<'_>,
+    agent: &A,
+) -> Result<String, AtProtoPreprocessError>
+where
+    A: AgentSessionExt,
+{
+    use jacquard::types::string::Did;
 
-    // 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)
+    // Resolve to DID if we have a handle
+    let did = match ident {
+        AtIdentifier::Did(d) => d.clone(),
+        AtIdentifier::Handle(h) => {
+            let did_str = agent
+                .resolve_handle(h)
+                .await
+                .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
+            Did::new(&did_str)
+                .map_err(|e| AtProtoPreprocessError::InvalidUri(e.to_string()))?
+                .into_static()
         }
-        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)
+    // Use WeaverExt to get hydrated profile (tries weaver profile first, falls back to bsky)
+    let (_uri, profile_view) = agent
+        .hydrate_profile_view(&did)
         .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)
+    // Render based on which profile type we got
+    render_profile_data_view(&profile_view.inner)
 }
 
-/// Fetch and render a Bluesky post as HTML
-pub async fn fetch_and_render_post<A: AgentSession + IdentityResolver>(
+/// Fetch and render a Bluesky post as HTML using the appview for rich data
+pub async fn fetch_and_render_post<A>(
     uri: &AtUri<'_>,
-    agent: &Agent<A>,
-) -> Result<String, AtProtoPreprocessError> {
-    use weaver_api::app_bsky::feed::post::Post;
+    agent: &A,
+) -> Result<String, AtProtoPreprocessError>
+where
+    A: AgentSessionExt,
+{
+    // Use GetPosts for richer data (author info, engagement counts)
+    let response = agent
+        .send(GetPosts::new().uris(vec![uri.clone()]).build())
+        .await
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
 
-    // Fetch using typed collection
-    let record_uri = Post::uri(uri.as_ref())
-        .map_err(|e| AtProtoPreprocessError::InvalidUri(e.to_string()))?;
+    let output = response
+        .into_output()
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
 
-    let output = agent.fetch_record(&record_uri).await
-        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
+    let post_view = output
+        .posts
+        .into_iter()
+        .next()
+        .ok_or_else(|| AtProtoPreprocessError::FetchFailed("Post not found".to_string()))?;
 
-    // Render post to HTML
-    render_post(&output.value, uri)
+    render_post_view(&post_view, 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>(
+pub async fn fetch_and_render_generic<A>(
     uri: &AtUri<'_>,
-    agent: &Agent<A>,
-) -> Result<String, AtProtoPreprocessError> {
-    // Use untyped fetch
-    let response = get_record_untyped(uri, agent).await
+    agent: &A,
+) -> Result<String, AtProtoPreprocessError>
+where
+    A: AgentSessionExt,
+{
+    // Fetch via slingshot (edge-cached, untyped)
+    let output = agent
+        .fetch_record_slingshot(uri)
+        .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> {
+/// Fetch and render a notebook entry with full markdown rendering
+///
+/// Renders the entry content as HTML in a scrollable container with title and author info.
+pub async fn fetch_and_render_entry<A>(
+    uri: &AtUri<'_>,
+    agent: &A,
+) -> Result<String, AtProtoPreprocessError>
+where
+    A: AgentSessionExt,
+{
+    use weaver_common::agent::WeaverExt;
+    use markdown_weaver::Parser;
+    use crate::atproto::writer::ClientWriter;
+    use crate::default_md_options;
+
+    // Get rkey from URI
+    let rkey = uri
+        .rkey()
+        .ok_or_else(|| AtProtoPreprocessError::FetchFailed("Entry URI missing rkey".to_string()))?;
+
+    // Fetch entry with author info
+    let (entry_view, entry) = agent
+        .fetch_entry_by_rkey(&uri.authority(), rkey.as_ref())
+        .await
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(e.to_string()))?;
+
+    // Render the markdown content to HTML
+    let parser = Parser::new_ext(entry.content.as_ref(), default_md_options());
+    let mut content_html = String::new();
+    ClientWriter::<_, _, ()>::new(parser, &mut content_html)
+        .run()
+        .map_err(|e| AtProtoPreprocessError::FetchFailed(format!("Markdown render failed: {}", e)))?;
+
+    // Generate unique ID for the toggle checkbox
+    let toggle_id = format!("entry-toggle-{}", rkey.as_ref());
+
+    // Build the embed HTML
     let mut html = String::new();
+    html.push_str("<div class=\"atproto-embed atproto-entry\" contenteditable=\"false\">");
 
-    html.push_str("<div class=\"atproto-embed atproto-profile\">");
+    // 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()));
+    html.push_str("</span>");
 
-    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>");
+    // Author info - just show handle (keep it simple for entry embeds)
+    if let Some(author) = entry_view.authors.first() {
+        let handle = match &author.record.inner {
+            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref(),
+            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref(),
+            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref(),
+            ProfileDataViewInner::Unknown(_) => "",
+        };
+        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 class=\"profile-did\">");
-    html.push_str(&html_escape(did.as_ref()));
+    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>");
 
-    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>");
+    Ok(html)
+}
+
+/// Fetch and render any AT URI, dispatching to the appropriate renderer based on collection.
+///
+/// Uses typed fetchers for known collections (posts, profiles) and falls back to
+/// generic rendering for unknown types.
+pub async fn fetch_and_render<A>(
+    uri: &AtUri<'_>,
+    agent: &A,
+) -> Result<String, AtProtoPreprocessError>
+where
+    A: AgentSessionExt,
+{
+    let collection = uri.collection().map(|c| c.as_ref());
+
+    match collection {
+        Some("app.bsky.feed.post") => fetch_and_render_post(uri, agent).await,
+        Some("app.bsky.actor.profile") => {
+            // Extract DID from URI authority
+            fetch_and_render_profile(uri.authority(), agent).await
+        }
+        Some("sh.weaver.notebook.entry") => fetch_and_render_entry(uri, agent).await,
+        None => fetch_and_render_profile(uri.authority(), agent).await,
+        _ => fetch_and_render_generic(uri, agent).await,
     }
+}
 
-    html.push_str("</div>");
+/// Render a profile from ProfileDataViewInner (weaver, bsky, or tangled)
+fn render_profile_data_view(inner: &ProfileDataViewInner<'_>) -> Result<String, AtProtoPreprocessError> {
+    let mut html = String::new();
+
+    match inner {
+        ProfileDataViewInner::ProfileView(profile) => {
+            // Weaver profile - link to bsky for now
+            let profile_url = format!("https://bsky.app/profile/{}", profile.handle.as_ref());
+            html.push_str("<span class=\"atproto-embed atproto-profile\" contenteditable=\"false\">");
+
+            // Background link covers whole card
+            html.push_str("<a class=\"embed-card-link\" href=\"");
+            html.push_str(&html_escape(&profile_url));
+            html.push_str("\" target=\"_blank\" rel=\"noopener\" aria-label=\"View profile\"></a>");
+
+            html.push_str("<span class=\"embed-author\">");
+            if let Some(avatar) = &profile.avatar {
+                html.push_str("<img class=\"embed-avatar\" src=\"");
+                html.push_str(&html_escape(avatar.as_ref()));
+                html.push_str("\" alt=\"\" />");
+            }
+            html.push_str("<span class=\"embed-author-info\">");
+            if let Some(display_name) = &profile.display_name {
+                html.push_str("<span class=\"embed-author-name\">");
+                html.push_str(&html_escape(display_name.as_ref()));
+                html.push_str("</span>");
+            }
+            html.push_str("<span class=\"embed-author-handle\">@");
+            html.push_str(&html_escape(profile.handle.as_ref()));
+            html.push_str("</span>");
+            html.push_str("</span>");
+            html.push_str("</span>");
+
+            if let Some(description) = &profile.description {
+                html.push_str("<span class=\"embed-description\">");
+                html.push_str(&html_escape(description.as_ref()));
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+        }
+        ProfileDataViewInner::ProfileViewDetailed(profile) => {
+            // Bsky profile
+            let profile_url = format!("https://bsky.app/profile/{}", profile.handle.as_ref());
+            html.push_str("<span class=\"atproto-embed atproto-profile\" contenteditable=\"false\">");
+
+            // Background link covers whole card
+            html.push_str("<a class=\"embed-card-link\" href=\"");
+            html.push_str(&html_escape(&profile_url));
+            html.push_str("\" target=\"_blank\" rel=\"noopener\" aria-label=\"View profile\"></a>");
+
+            html.push_str("<span class=\"embed-author\">");
+            if let Some(avatar) = &profile.avatar {
+                html.push_str("<img class=\"embed-avatar\" src=\"");
+                html.push_str(&html_escape(avatar.as_ref()));
+                html.push_str("\" alt=\"\" />");
+            }
+            html.push_str("<span class=\"embed-author-info\">");
+            if let Some(display_name) = &profile.display_name {
+                html.push_str("<span class=\"embed-author-name\">");
+                html.push_str(&html_escape(display_name.as_ref()));
+                html.push_str("</span>");
+            }
+            html.push_str("<span class=\"embed-author-handle\">@");
+            html.push_str(&html_escape(profile.handle.as_ref()));
+            html.push_str("</span>");
+            html.push_str("</span>");
+            html.push_str("</span>");
+
+            if let Some(description) = &profile.description {
+                html.push_str("<span class=\"embed-description\">");
+                html.push_str(&html_escape(description.as_ref()));
+                html.push_str("</span>");
+            }
+
+            // Stats for bsky profiles
+            if profile.followers_count.is_some() || profile.follows_count.is_some() {
+                html.push_str("<span class=\"embed-meta\">");
+                html.push_str("<span class=\"embed-stats\">");
+                if let Some(followers) = profile.followers_count {
+                    html.push_str("<span class=\"embed-stat\">");
+                    html.push_str(&followers.to_string());
+                    html.push_str(" followers</span>");
+                }
+                if let Some(follows) = profile.follows_count {
+                    html.push_str("<span class=\"embed-stat\">");
+                    html.push_str(&follows.to_string());
+                    html.push_str(" following</span>");
+                }
+                html.push_str("</span>");
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+        }
+        ProfileDataViewInner::TangledProfileView(profile) => {
+            // Tangled profile - link to tangled
+            let profile_url = format!("https://tangled.sh/@{}", profile.handle.as_ref());
+            html.push_str("<span class=\"atproto-embed atproto-profile\" contenteditable=\"false\">");
+
+            // Background link covers whole card
+            html.push_str("<a class=\"embed-card-link\" href=\"");
+            html.push_str(&html_escape(&profile_url));
+            html.push_str("\" target=\"_blank\" rel=\"noopener\" aria-label=\"View profile\"></a>");
+
+            html.push_str("<span class=\"embed-author\">");
+            html.push_str("<span class=\"embed-author-info\">");
+            html.push_str("<span class=\"embed-author-handle\">@");
+            html.push_str(&html_escape(profile.handle.as_ref()));
+            html.push_str("</span>");
+            html.push_str("</span>");
+            html.push_str("</span>");
+
+            if let Some(description) = &profile.description {
+                html.push_str("<span class=\"embed-description\">");
+                html.push_str(&html_escape(description.as_ref()));
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+        }
+        ProfileDataViewInner::Unknown(data) => {
+            // Unknown - no link, just render
+            html.push_str("<span class=\"atproto-embed atproto-profile\" contenteditable=\"false\">");
+            html.push_str(&render_generic_data(data));
+            html.push_str("</span>");
+        }
+    }
 
     Ok(html)
 }
 
-/// Render a Bluesky post as HTML
-fn render_post<'a>(
-    post: &weaver_api::app_bsky::feed::post::Post<'a>,
-    _uri: &AtUri<'_>,
+/// Render a Bluesky post from PostView (rich appview data)
+fn render_post_view<'a>(
+    post: &PostView<'a>,
+    uri: &AtUri<'_>,
 ) -> Result<String, AtProtoPreprocessError> {
     let mut html = String::new();
 
-    html.push_str("<div class=\"atproto-embed atproto-post\">");
+    // Build link to post on Bluesky
+    let bsky_link = format!(
+        "https://bsky.app/profile/{}/post/{}",
+        post.author.handle.as_ref(),
+        uri.rkey().map(|r| r.as_ref()).unwrap_or("")
+    );
 
-    html.push_str("<div class=\"post-text\">");
-    html.push_str(&html_escape(post.text.as_ref()));
-    html.push_str("</div>");
+    html.push_str("<span class=\"atproto-embed atproto-post\" contenteditable=\"false\">");
 
-    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>");
+    // Background link covers whole card, other links sit on top
+    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>");
 
-    html.push_str("</div>");
+    // Author header
+    html.push_str(&render_author_block(&post.author, true));
+
+    // Post text (parse record as typed Post)
+    if let Ok(post_record) =
+        jacquard::from_data::<weaver_api::app_bsky::feed::post::Post>(&post.record)
+    {
+        html.push_str("<span class=\"embed-content\">");
+        html.push_str(&html_escape(post_record.text.as_ref()));
+        html.push_str("</span>");
+    }
+
+    // Embedded content (images, links, quotes, etc.)
+    if let Some(embed) = &post.embed {
+        html.push_str(&render_post_embed(embed));
+    }
+
+    // Engagement stats and timestamp
+    html.push_str("<span class=\"embed-meta\">");
+
+    // Stats row
+    html.push_str("<span class=\"embed-stats\">");
+    if let Some(replies) = post.reply_count {
+        html.push_str("<span class=\"embed-stat\">");
+        html.push_str(&replies.to_string());
+        html.push_str(" replies</span>");
+    }
+    if let Some(reposts) = post.repost_count {
+        html.push_str("<span class=\"embed-stat\">");
+        html.push_str(&reposts.to_string());
+        html.push_str(" reposts</span>");
+    }
+    if let Some(likes) = post.like_count {
+        html.push_str("<span class=\"embed-stat\">");
+        html.push_str(&likes.to_string());
+        html.push_str(" likes</span>");
+    }
+    html.push_str("</span>");
+
+    // Timestamp
+    html.push_str("<span class=\"embed-time\">");
+    html.push_str(&html_escape(&post.indexed_at.to_string()));
+    html.push_str("</span>");
+
+    html.push_str("</span>");
+    html.push_str("</span>");
 
     Ok(html)
 }
···
 ) -> Result<String, AtProtoPreprocessError> {
     let mut html = String::new();
 
-    html.push_str("<div class=\"atproto-embed atproto-record\">");
+    html.push_str("<span class=\"atproto-embed atproto-record\" contenteditable=\"false\">");
+
+    // Show record type as header
+    if let Some(collection) = uri.collection() {
+        // Extract just the record name (e.g., "entry" from "sh.weaver.notebook.entry")
+        let type_name = collection.as_ref().rsplit('.').next().unwrap_or(collection.as_ref());
+        html.push_str("<span class=\"embed-author-handle\">");
+        html.push_str(&html_escape(type_name));
+        html.push_str("</span>");
+    }
+
+    // Priority fields to show first (in order)
+    let priority_fields = ["name", "displayName", "title", "text", "description", "content"];
+    let mut shown_fields = Vec::new();
+
+    if let Some(obj) = data.as_object() {
+        for field_name in priority_fields {
+            if let Some(value) = obj.get(field_name) {
+                if let Some(s) = value.as_str() {
+                    let class = match field_name {
+                        "name" | "displayName" | "title" => "embed-author-name",
+                        "text" | "content" => "embed-content",
+                        "description" => "embed-description",
+                        _ => "embed-field-value",
+                    };
+                    html.push_str("<span class=\"");
+                    html.push_str(class);
+                    html.push_str("\">");
+                    // Truncate long content for embed display
+                    let display_text = if s.len() > 300 {
+                        format!("{}...", &s[..300])
+                    } else {
+                        s.to_string()
+                    };
+                    html.push_str(&html_escape(&display_text));
+                    html.push_str("</span>");
+                    shown_fields.push(field_name);
+                }
+            }
+        }
+
+        // Show remaining fields as a simple list
+        html.push_str("<span class=\"embed-fields\">");
+        for (key, value) in obj.iter() {
+            let key_str: &str = key.as_ref();
+
+            // Skip already shown, internal fields, and complex nested objects
+            if shown_fields.contains(&key_str)
+                || key_str.starts_with('$')
+                || key_str == "facets"
+                || key_str == "labels"
+                || key_str == "embeds"
+            {
+                continue;
+            }
+
+            if let Some(formatted) = format_field_value(key_str, value) {
+                html.push_str("<span class=\"embed-field\">");
+                html.push_str("<span class=\"embed-field-name\">");
+                html.push_str(&html_escape(&format_field_name(key_str)));
+                html.push_str(":</span> ");
+                html.push_str(&formatted);
+                html.push_str("</span>");
+            }
+        }
+        html.push_str("</span>");
+    }
+
+    html.push_str("</span>");
+
+    Ok(html)
+}
+
+// =============================================================================
+// Reusable render functions for embed components
+// =============================================================================
+
+/// Render an author block (avatar + name + handle)
+///
+/// Used for posts, profiles, and any record with an author.
+/// When `link_to_profile` is true, avatar, display name, and handle all link to the profile.
+pub fn render_author_block(author: &ProfileViewBasic<'_>, link_to_profile: bool) -> String {
+    render_author_block_inner(
+        author.avatar.as_ref().map(|u| u.as_ref()),
+        author.display_name.as_ref().map(|s| s.as_ref()),
+        author.handle.as_ref(),
+        link_to_profile,
+    )
+}
+
+/// Render author block from ProfileView (has same fields as ProfileViewBasic)
+pub fn render_author_block_full(author: &weaver_api::app_bsky::actor::ProfileView<'_>, link_to_profile: bool) -> String {
+    render_author_block_inner(
+        author.avatar.as_ref().map(|u| u.as_ref()),
+        author.display_name.as_ref().map(|s| s.as_ref()),
+        author.handle.as_ref(),
+        link_to_profile,
+    )
+}
+
+fn render_author_block_inner(
+    avatar: Option<&str>,
+    display_name: Option<&str>,
+    handle: &str,
+    link_to_profile: bool,
+) -> String {
+    let mut html = String::new();
+    let profile_url = format!("https://bsky.app/profile/{}", handle);
+
+    html.push_str("<span class=\"embed-author\">");
+
+    if let Some(avatar_url) = avatar {
+        if link_to_profile {
+            html.push_str("<a class=\"embed-avatar-link\" href=\"");
+            html.push_str(&html_escape(&profile_url));
+            html.push_str("\" target=\"_blank\" rel=\"noopener\">");
+            html.push_str("<img class=\"embed-avatar\" src=\"");
+            html.push_str(&html_escape(avatar_url));
+            html.push_str("\" alt=\"\" />");
+            html.push_str("</a>");
+        } else {
+            html.push_str("<img class=\"embed-avatar\" src=\"");
+            html.push_str(&html_escape(avatar_url));
+            html.push_str("\" alt=\"\" />");
+        }
+    }
+
+    html.push_str("<span class=\"embed-author-info\">");
+
+    if let Some(name) = display_name {
+        if link_to_profile {
+            html.push_str("<a class=\"embed-author-name\" href=\"");
+            html.push_str(&html_escape(&profile_url));
+            html.push_str("\" target=\"_blank\" rel=\"noopener\">");
+            html.push_str(&html_escape(name));
+            html.push_str("</a>");
+        } else {
+            html.push_str("<span class=\"embed-author-name\">");
+            html.push_str(&html_escape(name));
+            html.push_str("</span>");
+        }
+    }
+
+    if link_to_profile {
+        html.push_str("<a class=\"embed-author-handle\" href=\"");
+        html.push_str(&html_escape(&profile_url));
+        html.push_str("\" target=\"_blank\" rel=\"noopener\">@");
+        html.push_str(&html_escape(handle));
+        html.push_str("</a>");
+    } else {
+        html.push_str("<span class=\"embed-author-handle\">@");
+        html.push_str(&html_escape(handle));
+        html.push_str("</span>");
+    }
+
+    html.push_str("</span>");
+    html.push_str("</span>");
+
+    html
+}
+
+/// Render an external link card (title, description, thumbnail)
+///
+/// Used for link previews in posts and standalone link embeds.
+pub fn render_external_link(external: &ViewExternal<'_>) -> String {
+    let mut html = String::new();
+
+    html.push_str("<a class=\"embed-external\" href=\"");
+    html.push_str(&html_escape(external.uri.as_ref()));
+    html.push_str("\" target=\"_blank\" rel=\"noopener\">");
+
+    if let Some(thumb) = &external.thumb {
+        html.push_str("<img class=\"embed-external-thumb\" src=\"");
+        html.push_str(&html_escape(thumb.as_ref()));
+        html.push_str("\" alt=\"\" />");
+    }
+
+    html.push_str("<span class=\"embed-external-info\">");
+    html.push_str("<span class=\"embed-external-title\">");
+    html.push_str(&html_escape(external.title.as_ref()));
+    html.push_str("</span>");
+
+    if !external.description.is_empty() {
+        html.push_str("<span class=\"embed-external-description\">");
+        html.push_str(&html_escape(external.description.as_ref()));
+        html.push_str("</span>");
+    }
+
+    html.push_str("<span class=\"embed-external-url\">");
+    // Show just the domain
+    if let Some(domain) = extract_domain(external.uri.as_ref()) {
+        html.push_str(&html_escape(domain));
+    } else {
+        html.push_str(&html_escape(external.uri.as_ref()));
+    }
+    html.push_str("</span>");
+
+    html.push_str("</span>");
+    html.push_str("</a>");
+
+    html
+}
+
+/// Render an image gallery
+///
+/// Used for image embeds in posts.
+pub fn render_images(images: &[ViewImage<'_>]) -> String {
+    let mut html = String::new();
+
+    let class = match images.len() {
+        1 => "embed-images embed-images-1",
+        2 => "embed-images embed-images-2",
+        3 => "embed-images embed-images-3",
+        _ => "embed-images embed-images-4",
+    };
+
+    html.push_str("<span class=\"");
+    html.push_str(class);
+    html.push_str("\">");
+
+    for img in images {
+        html.push_str("<a class=\"embed-image-link\" href=\"");
+        html.push_str(&html_escape(img.fullsize.as_ref()));
+        html.push_str("\" target=\"_blank\"");
+
+        // Add aspect-ratio style if available
+        if let Some(aspect) = &img.aspect_ratio {
+            html.push_str(" style=\"aspect-ratio: ");
+            html.push_str(&aspect.width.to_string());
+            html.push_str(" / ");
+            html.push_str(&aspect.height.to_string());
+            html.push_str(";\"");
+        }
+
+        html.push_str(">");
+        html.push_str("<img class=\"embed-image\" src=\"");
+        html.push_str(&html_escape(img.thumb.as_ref()));
+        html.push_str("\" alt=\"");
+        html.push_str(&html_escape(img.alt.as_ref()));
+        html.push_str("\" />");
+        html.push_str("</a>");
+    }
+
+    html.push_str("</span>");
+
+    html
+}
+
+/// Render a quoted/embedded record
+///
+/// Used for quote posts and record embeds. Dispatches based on record type.
+pub fn render_quoted_record(record: &ViewRecord<'_>) -> String {
+    let mut html = String::new();
+
+    html.push_str("<span class=\"embed-quote\">");
 
-    // 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>");
+    // Dispatch based on record type
+    match record.value.type_discriminator() {
+        Some("app.bsky.feed.post") => {
+            // Post - show author and text
+            html.push_str(&render_author_block(&record.author, true));
+            if let Ok(post) =
+                jacquard::from_data::<weaver_api::app_bsky::feed::post::Post>(&record.value)
+            {
+                html.push_str("<span class=\"embed-content\">");
+                html.push_str(&html_escape(post.text.as_ref()));
+                html.push_str("</span>");
+            }
+        }
+        Some("app.bsky.feed.generator") => {
+            // Custom feed - show feed info with type label
+            if let Ok(generator) =
+                jacquard::from_data::<weaver_api::app_bsky::feed::generator::Generator>(
+                    &record.value,
+                )
+            {
+                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(&render_author_block(&record.author, true));
+            }
+        }
+        Some("app.bsky.graph.list") => {
+            // List - show list info
+            if let Ok(list) =
+                jacquard::from_data::<weaver_api::app_bsky::graph::list::List>(&record.value)
+            {
+                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(&render_author_block(&record.author, true));
+            }
+        }
+        Some("app.bsky.graph.starterpack") => {
+            // Starter pack
+            if let Ok(sp) = jacquard::from_data::<weaver_api::app_bsky::graph::starterpack::Starterpack>(&record.value) {
+                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(&render_author_block(&record.author, true));
+            }
+        }
+        _ => {
+            // Unknown type - show author and probe for common fields
+            html.push_str(&render_author_block(&record.author, true));
+            html.push_str(&render_generic_data(&record.value));
+        }
     }
 
-    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>");
+    // Render nested embeds if present (applies to all types)
+    if let Some(embeds) = &record.embeds {
+        for embed in embeds {
+            html.push_str(&render_view_record_embed(embed));
+        }
     }
 
-    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>");
+    html.push_str("</span>");
+
+    html
+}
+
+/// Render an embed item from a ViewRecord (nested embeds in quotes)
+fn render_view_record_embed(embed: &weaver_api::app_bsky::embed::record::ViewRecordEmbedsItem<'_>) -> String {
+    use weaver_api::app_bsky::embed::record::ViewRecordEmbedsItem;
+
+    match embed {
+        ViewRecordEmbedsItem::ImagesView(images) => render_images(&images.images),
+        ViewRecordEmbedsItem::ExternalView(external) => render_external_link(&external.external),
+        ViewRecordEmbedsItem::View(record_view) => render_record_embed(&record_view.record),
+        ViewRecordEmbedsItem::RecordWithMediaView(rwm) => {
+            let mut html = String::new();
+            // Render media first
+            match &rwm.media {
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::ImagesView(img) => {
+                    html.push_str(&render_images(&img.images));
+                }
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::ExternalView(ext) => {
+                    html.push_str(&render_external_link(&ext.external));
+                }
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::VideoView(_) => {
+                    html.push_str("<span class=\"embed-video-placeholder\">[Video]</span>");
+                }
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::Unknown(_) => {}
+            }
+            // Then the record
+            html.push_str(&render_record_embed(&rwm.record.record));
+            html
+        }
+        ViewRecordEmbedsItem::VideoView(_) => {
+            "<span class=\"embed-video-placeholder\">[Video]</span>".to_string()
+        }
+        ViewRecordEmbedsItem::Unknown(data) => render_generic_data(data),
     }
+}
 
-    // 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>");
+/// Render a PostViewEmbed (images, external, record, video, etc.)
+pub fn render_post_embed(embed: &PostViewEmbed<'_>) -> String {
+    match embed {
+        PostViewEmbed::ImagesView(images) => render_images(&images.images),
+        PostViewEmbed::ExternalView(external) => render_external_link(&external.external),
+        PostViewEmbed::RecordView(record) => render_record_embed(&record.record),
+        PostViewEmbed::RecordWithMediaView(rwm) => {
+            let mut html = String::new();
+            // Render media first
+            match &rwm.media {
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::ImagesView(img) => {
+                    html.push_str(&render_images(&img.images));
+                }
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::ExternalView(ext) => {
+                    html.push_str(&render_external_link(&ext.external));
+                }
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::VideoView(_) => {
+                    html.push_str("<span class=\"embed-video-placeholder\">[Video]</span>");
+                }
+                weaver_api::app_bsky::embed::record_with_media::ViewMedia::Unknown(_) => {}
+            }
+            // Then the record
+            html.push_str(&render_record_embed(&rwm.record.record));
+            html
+        }
+        PostViewEmbed::VideoView(_) => {
+            "<span class=\"embed-video-placeholder\">[Video]</span>".to_string()
+        }
+        PostViewEmbed::Unknown(data) => render_generic_data(data),
     }
+}
 
-    html.push_str("</div>");
+/// Render a ViewUnionRecord (the actual content of a record embed)
+fn render_record_embed(record: &ViewUnionRecord<'_>) -> String {
+    match record {
+        ViewUnionRecord::ViewRecord(r) => render_quoted_record(r),
+        ViewUnionRecord::ViewNotFound(_) => {
+            "<span class=\"embed-not-found\">Record not found</span>".to_string()
+        }
+        ViewUnionRecord::ViewBlocked(_) => {
+            "<span class=\"embed-blocked\">Content blocked</span>".to_string()
+        }
+        ViewUnionRecord::ViewDetached(_) => {
+            "<span class=\"embed-detached\">Content unavailable</span>".to_string()
+        }
+        ViewUnionRecord::GeneratorView(generator) => {
+            let mut html = String::new();
+            html.push_str("<span class=\"embed-record-card\">");
 
-    Ok(html)
+            // Icon + title + type (like author block layout)
+            html.push_str("<span class=\"embed-author\">");
+            if let Some(avatar) = &generator.avatar {
+                html.push_str("<img class=\"embed-avatar\" src=\"");
+                html.push_str(&html_escape(avatar.as_ref()));
+                html.push_str("\" alt=\"\" />");
+            }
+            html.push_str("<span class=\"embed-author-info\">");
+            html.push_str("<span class=\"embed-author-name\">");
+            html.push_str(&html_escape(generator.display_name.as_ref()));
+            html.push_str("</span>");
+            html.push_str("<span class=\"embed-author-handle\">Feed</span>");
+            html.push_str("</span>");
+            html.push_str("</span>");
+
+            // Description
+            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>");
+            }
+
+            // Creator
+            html.push_str(&render_author_block_full(&generator.creator, true));
+
+            // Stats
+            if let Some(likes) = generator.like_count {
+                html.push_str("<span class=\"embed-stats\">");
+                html.push_str("<span class=\"embed-stat\">");
+                html.push_str(&likes.to_string());
+                html.push_str(" likes</span>");
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+            html
+        }
+        ViewUnionRecord::ListView(list) => {
+            let mut html = String::new();
+            html.push_str("<span class=\"embed-record-card\">");
+
+            // Icon + title + type (like author block layout)
+            html.push_str("<span class=\"embed-author\">");
+            if let Some(avatar) = &list.avatar {
+                html.push_str("<img class=\"embed-avatar\" src=\"");
+                html.push_str(&html_escape(avatar.as_ref()));
+                html.push_str("\" alt=\"\" />");
+            }
+            html.push_str("<span class=\"embed-author-info\">");
+            html.push_str("<span class=\"embed-author-name\">");
+            html.push_str(&html_escape(list.name.as_ref()));
+            html.push_str("</span>");
+            html.push_str("<span class=\"embed-author-handle\">List</span>");
+            html.push_str("</span>");
+            html.push_str("</span>");
+
+            // Description
+            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>");
+            }
+
+            // Creator
+            html.push_str(&render_author_block_full(&list.creator, true));
+
+            // Stats
+            if let Some(count) = list.list_item_count {
+                html.push_str("<span class=\"embed-stats\">");
+                html.push_str("<span class=\"embed-stat\">");
+                html.push_str(&count.to_string());
+                html.push_str(" members</span>");
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+            html
+        }
+        ViewUnionRecord::LabelerView(labeler) => {
+            let mut html = String::new();
+            html.push_str("<span class=\"embed-record-card\">");
+
+            // Labeler uses creator as the identity, add type label
+            html.push_str("<span class=\"embed-author\">");
+            if let Some(avatar) = &labeler.creator.avatar {
+                html.push_str("<img class=\"embed-avatar\" src=\"");
+                html.push_str(&html_escape(avatar.as_ref()));
+                html.push_str("\" alt=\"\" />");
+            }
+            html.push_str("<span class=\"embed-author-info\">");
+            if let Some(name) = &labeler.creator.display_name {
+                html.push_str("<span class=\"embed-author-name\">");
+                html.push_str(&html_escape(name.as_ref()));
+                html.push_str("</span>");
+            }
+            html.push_str("<span class=\"embed-author-handle\">Labeler</span>");
+            html.push_str("</span>");
+            html.push_str("</span>");
+
+            // Stats
+            if let Some(likes) = labeler.like_count {
+                html.push_str("<span class=\"embed-stats\">");
+                html.push_str("<span class=\"embed-stat\">");
+                html.push_str(&likes.to_string());
+                html.push_str(" likes</span>");
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+            html
+        }
+        ViewUnionRecord::StarterPackViewBasic(sp) => {
+            let mut html = String::new();
+            html.push_str("<span class=\"embed-record-card\">");
+
+            // Use author block layout: avatar + info (name, subtitle)
+            html.push_str("<span class=\"embed-author\">");
+            if let Some(avatar) = &sp.creator.avatar {
+                html.push_str("<img class=\"embed-avatar\" src=\"");
+                html.push_str(&html_escape(avatar.as_ref()));
+                html.push_str("\" alt=\"\" />");
+            }
+            html.push_str("<span class=\"embed-author-info\">");
+
+            // Name as title
+            if let Some(name) = sp.record.query("name").single().and_then(|d| d.as_str()) {
+                html.push_str("<span class=\"embed-author-name\">");
+                html.push_str(&html_escape(name));
+                html.push_str("</span>");
+            }
+
+            // "Starter pack by @handle"
+            html.push_str("<span class=\"embed-author-handle\">by @");
+            html.push_str(&html_escape(sp.creator.handle.as_ref()));
+            html.push_str("</span>");
+
+            html.push_str("</span>"); // end info
+            html.push_str("</span>"); // end author
+
+            // Description
+            if let Some(desc) = sp.record.query("description").single().and_then(|d| d.as_str()) {
+                html.push_str("<span class=\"embed-description\">");
+                html.push_str(&html_escape(desc));
+                html.push_str("</span>");
+            }
+
+            // Stats
+            let has_stats = sp.list_item_count.is_some() || sp.joined_all_time_count.is_some();
+            if has_stats {
+                html.push_str("<span class=\"embed-stats\">");
+                if let Some(count) = sp.list_item_count {
+                    html.push_str("<span class=\"embed-stat\">");
+                    html.push_str(&count.to_string());
+                    html.push_str(" users</span>");
+                }
+                if let Some(joined) = sp.joined_all_time_count {
+                    html.push_str("<span class=\"embed-stat\">");
+                    html.push_str(&joined.to_string());
+                    html.push_str(" joined</span>");
+                }
+                html.push_str("</span>");
+            }
+
+            html.push_str("</span>");
+            html
+        }
+        ViewUnionRecord::Unknown(data) => render_generic_data(data),
+    }
+}
+
+/// Render generic/unknown data by iterating fields intelligently
+///
+/// Used as fallback for Unknown variants of open unions.
+fn render_generic_data(data: &Data<'_>) -> String {
+    let mut html = String::new();
+
+    html.push_str("<span class=\"embed-record-card\">");
+
+    // Show record type as header if present
+    if let Some(record_type) = data.type_discriminator() {
+        // Extract just the record name from full NSID (e.g., "app.bsky.feed.post" -> "post")
+        let type_name = record_type.rsplit('.').next().unwrap_or(record_type);
+        html.push_str("<span class=\"embed-author-handle\">");
+        html.push_str(&html_escape(type_name));
+        html.push_str("</span>");
+    }
+
+    // Priority fields to show first (in order)
+    let priority_fields = ["name", "displayName", "title", "text", "description"];
+    let mut shown_fields = Vec::new();
+
+    if let Some(obj) = data.as_object() {
+        for field_name in priority_fields {
+            if let Some(value) = obj.get(field_name) {
+                if let Some(s) = value.as_str() {
+                    let class = match field_name {
+                        "name" | "displayName" | "title" => "embed-author-name",
+                        "text" => "embed-content",
+                        "description" => "embed-description",
+                        _ => "embed-field-value",
+                    };
+                    html.push_str("<span class=\"");
+                    html.push_str(class);
+                    html.push_str("\">");
+                    html.push_str(&html_escape(s));
+                    html.push_str("</span>");
+                    shown_fields.push(field_name);
+                }
+            }
+        }
+
+        // Show remaining fields as a simple list
+        html.push_str("<span class=\"embed-fields\">");
+        for (key, value) in obj.iter() {
+            let key_str: &str = key.as_ref();
+
+            // Skip already shown, internal fields, and complex nested objects
+            if shown_fields.contains(&key_str)
+                || key_str.starts_with('$')
+                || key_str == "facets"
+                || key_str == "labels"
+            {
+                continue;
+            }
+
+            if let Some(formatted) = format_field_value(key_str, value) {
+                html.push_str("<span class=\"embed-field\">");
+                html.push_str("<span class=\"embed-field-name\">");
+                html.push_str(&html_escape(&format_field_name(key_str)));
+                html.push_str(":</span> ");
+                html.push_str(&formatted);
+                html.push_str("</span>");
+            }
+        }
+        html.push_str("</span>");
+    }
+
+    html.push_str("</span>");
+    html
+}
+
+/// Format a field name for display (camelCase -> "Camel Case")
+fn format_field_name(name: &str) -> String {
+    let mut result = String::new();
+    for (i, c) in name.chars().enumerate() {
+        if c.is_uppercase() && i > 0 {
+            result.push(' ');
+        }
+        if i == 0 {
+            result.extend(c.to_uppercase());
+        } else {
+            result.push(c);
+        }
+    }
+    result
+}
+
+/// Format a field value for display, returning None for complex/unrenderable values
+fn format_field_value(key: &str, value: &Data<'_>) -> Option<String> {
+    // String values - detect AT Protocol types
+    if let Some(s) = value.as_str() {
+        return Some(format_string_value(key, s));
+    }
+
+    // Numbers
+    if let Some(n) = value.as_integer() {
+        return Some(format!("<span class=\"embed-field-number\">{}</span>", n));
+    }
+
+    // Booleans
+    if let Some(b) = value.as_boolean() {
+        let class = if b { "embed-field-bool-true" } else { "embed-field-bool-false" };
+        return Some(format!("<span class=\"{}\">{}</span>", class, if b { "yes" } else { "no" }));
+    }
+
+    // Arrays - show count
+    if let Some(arr) = value.as_array() {
+        let len = arr.len();
+        return Some(format!(
+            "<span class=\"embed-field-count\">{} item{}</span>",
+            len,
+            if len == 1 { "" } else { "s" }
+        ));
+    }
+
+    // Skip nested objects - too complex for inline display
+    None
+}
+
+/// Format a string value with smart detection of AT Protocol types
+fn format_string_value(key: &str, s: &str) -> String {
+    // AT URI - link to record
+    if s.starts_with("at://") {
+        return format!(
+            "<a class=\"embed-field-aturi\" href=\"{}\">{}</a>",
+            html_escape(s),
+            format_aturi_display(s)
+        );
+    }
+
+    // DID
+    if s.starts_with("did:") {
+        return format_did_display(s);
+    }
+
+    // Regular URL
+    if s.starts_with("http://") || s.starts_with("https://") {
+        let domain = extract_domain(s).unwrap_or(s);
+        return format!(
+            "<a class=\"embed-field-link\" href=\"{}\">{}</a>",
+            html_escape(s),
+            html_escape(domain)
+        );
+    }
+
+    // Datetime fields - show just the date
+    if key.ends_with("At") || key == "createdAt" || key == "indexedAt" {
+        let date_part = s.split('T').next().unwrap_or(s);
+        return format!("<span class=\"embed-field-date\">{}</span>", html_escape(date_part));
+    }
+
+    // NSID (e.g., app.bsky.feed.post)
+    if s.contains('.') && s.chars().all(|c| c.is_alphanumeric() || c == '.') && s.matches('.').count() >= 2 {
+        return format!("<span class=\"embed-field-nsid\">{}</span>", html_escape(s));
+    }
+
+    // Handle (contains dots, no colons or slashes)
+    if s.contains('.') && !s.contains(':') && !s.contains('/') && s.chars().all(|c| c.is_alphanumeric() || c == '.' || c == '-' || c == '_') {
+        return format!("<span class=\"embed-field-handle\">@{}</span>", html_escape(s));
+    }
+
+    // Plain string
+    html_escape(s)
+}
+
+/// Format an AT URI for display with highlighted parts
+fn format_aturi_display(uri: &str) -> String {
+    if let Some(rest) = uri.strip_prefix("at://") {
+        let parts: Vec<&str> = rest.splitn(3, '/').collect();
+        let mut result = String::from("<span class=\"aturi-scheme\">at://</span>");
+
+        if !parts.is_empty() {
+            result.push_str(&format!("<span class=\"aturi-authority\">{}</span>", html_escape(parts[0])));
+        }
+        if parts.len() > 1 {
+            result.push_str("<span class=\"aturi-slash\">/</span>");
+            result.push_str(&format!("<span class=\"aturi-collection\">{}</span>", html_escape(parts[1])));
+        }
+        if parts.len() > 2 {
+            result.push_str("<span class=\"aturi-slash\">/</span>");
+            result.push_str(&format!("<span class=\"aturi-rkey\">{}</span>", html_escape(parts[2])));
+        }
+        result
+    } else {
+        html_escape(uri)
+    }
+}
+
+/// Format a DID for display with highlighted parts
+fn format_did_display(did: &str) -> String {
+    if let Some(rest) = did.strip_prefix("did:") {
+        if let Some((method, identifier)) = rest.split_once(':') {
+            return format!(
+                "<span class=\"embed-field-did\">\
+                    <span class=\"did-scheme\">did:</span>\
+                    <span class=\"did-method\">{}</span>\
+                    <span class=\"did-separator\">:</span>\
+                    <span class=\"did-identifier\">{}</span>\
+                </span>",
+                html_escape(method),
+                html_escape(identifier)
+            );
+        }
+    }
+    format!("<span class=\"embed-field-did\">{}</span>", html_escape(did))
+}
+
+// =============================================================================
+// Helper functions
+// =============================================================================
+
+/// Extract domain from a URL
+fn extract_domain(url: &str) -> Option<&str> {
+    let without_scheme = url
+        .strip_prefix("https://")
+        .or_else(|| url.strip_prefix("http://"))?;
+    without_scheme.split('/').next()
 }
 
 /// Simple HTML escaping

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

···
 use jacquard::{
     client::{Agent, AgentSession, AgentSessionExt},
     prelude::IdentityResolver,
-    types::string::{CowStr, Did, Handle},
+    types::{
+        ident::AtIdentifier,
+        string::{CowStr, Did, Handle},
+    },
 };
 use markdown_weaver::{CowStr as MdCowStr, Tag, WeaverAttributes};
 use std::{path::PathBuf, sync::Arc};
···
 
                     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());
+                        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());
+                        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::debug!("Fetching profile embed: {}", did.as_ref());
                         // Fetch and render the profile
-                        let content = match fetch_and_render_profile(&did, &*self.agent).await {
+                        let content = match fetch_and_render_profile(
+                            &AtIdentifier::Did(did.clone()),
+                            &*self.agent,
+                        )
+                        .await
+                        {
                             Ok(html) => Some(html),
                             Err(e) => {
                                 eprintln!("Failed to fetch profile {}: {}", did.as_ref(), e);

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

···
                 self.write("</code>")?;
             }
             InlineMath(text) => {
-                self.write(r#"<span class="math math-inline">"#)?;
-                escape_html(&mut self.writer, &text)?;
-                self.write("</span>")?;
+                match crate::math::render_math(&text, false) {
+                    crate::math::MathResult::Success(mathml) => {
+                        self.write(r#"<span class="math math-inline">"#)?;
+                        self.write(&mathml)?;
+                        self.write("</span>")?;
+                    }
+                    crate::math::MathResult::Error { html, .. } => {
+                        self.write(&html)?;
+                    }
+                }
             }
             DisplayMath(text) => {
-                self.write(r#"<span class="math math-display">"#)?;
-                escape_html(&mut self.writer, &text)?;
-                self.write("</span>")?;
+                match crate::math::render_math(&text, true) {
+                    crate::math::MathResult::Success(mathml) => {
+                        self.write(r#"<span class="math math-display">"#)?;
+                        self.write(&mathml)?;
+                        self.write("</span>")?;
+                    }
+                    crate::math::MathResult::Error { html, .. } => {
+                        self.write(&html)?;
+                    }
+                }
             }
             Html(html) | InlineHtml(html) => {
                 self.write(&html)?;

crates/weaver-renderer/src/base_html.rs

···
                     self.write("</code>")?;
                 }
                 InlineMath(text) => {
-                    self.write(r#"<span class="math math-inline">"#)?;
-                    escape_html(&mut self.writer, &text)?;
-                    self.write("</span>")?;
+                    match crate::math::render_math(&text, false) {
+                        crate::math::MathResult::Success(mathml) => {
+                            self.write(r#"<span class="math math-inline">"#)?;
+                            self.write(&mathml)?;
+                            self.write("</span>")?;
+                        }
+                        crate::math::MathResult::Error { html, .. } => {
+                            self.write(&html)?;
+                        }
+                    }
                 }
                 DisplayMath(text) => {
-                    self.write(r#"<span class="math math-display">"#)?;
-                    escape_html(&mut self.writer, &text)?;
-                    self.write("</span>")?;
+                    match crate::math::render_math(&text, true) {
+                        crate::math::MathResult::Success(mathml) => {
+                            self.write(r#"<span class="math math-display">"#)?;
+                            self.write(&mathml)?;
+                            self.write("</span>")?;
+                        }
+                        crate::math::MathResult::Error { html, .. } => {
+                            self.write(&html)?;
+                        }
+                    }
                 }
                 Html(html) | InlineHtml(html) => {
                     self.write(&html)?;

crates/weaver-renderer/src/css.rs

···
     text-decoration: underline;
 }}
 
+/* Wikilink validation (editor) */
+.link-valid {{
+    color: var(--color-link);
+}}
+
+.link-broken {{
+    color: var(--color-error);
+    text-decoration: underline wavy;
+    text-decoration-color: var(--color-error);
+    opacity: 0.8;
+}}
+
 /* Selection */
 ::selection {{
     background: var(--color-highlight);
···
     display: block;
     margin: 1rem 0;
     border-radius: 4px;
+}}
+
+/* AT Protocol Embeds - Container */
+/* Light mode: paper with shadow, dark mode: blueprint with borders */
+.atproto-embed {{
+    display: block;
+    position: relative;
+    max-width: 550px;
+    margin: 1rem 0;
+    padding: 1rem;
+    background: var(--color-surface);
+    border-left: 2px solid var(--color-secondary);
+    box-shadow: 0 1px 2px color-mix(in srgb, var(--color-text) 8%, transparent);
+}}
+
+.atproto-embed:hover {{
+    border-left-color: var(--color-primary);
+}}
+
+@media (prefers-color-scheme: dark) {{
+    .atproto-embed {{
+        box-shadow: none;
+        border: 1px solid var(--color-border);
+        border-left: 2px solid var(--color-secondary);
+    }}
+}}
+
+.atproto-embed-placeholder {{
+    color: var(--color-muted);
+    font-style: italic;
+}}
+
+.embed-loading {{
+    display: block;
+    padding: 0.5rem 0;
+    color: var(--color-subtle);
+    font-family: var(--font-mono);
+    font-size: 0.85rem;
+}}
+
+/* Embed Author Block */
+.embed-author {{
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    margin-bottom: 0.75rem;
+}}
+
+.embed-avatar {{
+    width: 42px;
+    height: 42px;
+    min-width: 42px;
+    min-height: 42px;
+    margin: 0;
+    flex-shrink: 0;
+    object-fit: cover;
+}}
+
+.embed-author-info {{
+    display: flex;
+    flex-direction: column;
+    gap: 0.1rem;
+    min-width: 0;
+}}
+
+.embed-avatar-link {{
+    display: block;
+    flex-shrink: 0;
+}}
+
+.embed-author-name {{
+    font-weight: 600;
+    color: var(--color-text);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    text-decoration: none;
+}}
+
+a.embed-author-name:hover {{
+    color: var(--color-link);
+}}
+
+.embed-author-handle {{
+    font-size: 0.9em;
+    font-family: var(--font-mono);
+    color: var(--color-subtle);
+    text-decoration: none;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}}
+
+.embed-author-handle:hover {{
+    color: var(--color-link);
+}}
+
+/* Card-wide clickable link (sits behind content) */
+.embed-card-link {{
+    position: absolute;
+    inset: 0;
+    z-index: 0;
+}}
+
+.embed-card-link:focus {{
+    outline: 2px solid var(--color-primary);
+    outline-offset: 2px;
+}}
+
+/* Interactive elements sit above the card link */
+.embed-author,
+.embed-external,
+.embed-quote,
+.embed-images,
+.embed-meta {{
+    position: relative;
+    z-index: 1;
+}}
+
+/* Embed Content Block */
+.embed-content {{
+    display: block;
+    color: var(--color-text);
+    line-height: 1.5;
+    margin-bottom: 0.75rem;
+    white-space: pre-wrap;
+}}
+
+.embed-description {{
+    display: block;
+    color: var(--color-text);
+    font-size: 0.95em;
+    line-height: 1.4;
+}}
+
+/* Embed Metadata Block */
+.embed-meta {{
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.85em;
+    color: var(--color-muted);
+    margin-top: 0.75rem;
+}}
+
+.embed-stats {{
+    display: flex;
+    gap: 1rem;
+    font-family: var(--font-mono);
+}}
+
+.embed-stat {{
+    color: var(--color-subtle);
+    font-size: 0.9em;
+}}
+
+.embed-time {{
+    color: var(--color-subtle);
+    text-decoration: none;
+    font-family: var(--font-mono);
+    font-size: 0.9em;
+}}
+
+.embed-time:hover {{
+    color: var(--color-link);
+}}
+
+.embed-type {{
+    font-size: 0.8em;
+    color: var(--color-subtle);
+    font-family: var(--font-mono);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}}
+
+/* Embed URL link (shown with syntax in editor) */
+.embed-url {{
+    color: var(--color-link);
+    font-family: var(--font-mono);
+    font-size: 0.9em;
+    word-break: break-all;
+}}
+
+/* External link cards */
+.embed-external {{
+    display: flex;
+    gap: 0.75rem;
+    padding: 0.75rem;
+    background: var(--color-surface);
+    border: 1px dashed var(--color-border);
+    text-decoration: none;
+    color: inherit;
+    margin-top: 0.5rem;
+}}
+
+.embed-external:hover {{
+    border-left: 2px solid var(--color-primary);
+    margin-left: -1px;
+}}
+
+@media (prefers-color-scheme: dark) {{
+    .embed-external {{
+        border: 1px solid var(--color-border);
+    }}
+
+    .embed-external:hover {{
+        border-left: 2px solid var(--color-primary);
+        margin-left: -1px;
+    }}
+}}
+
+.embed-external-thumb {{
+    width: 120px;
+    height: 80px;
+    object-fit: cover;
+    flex-shrink: 0;
+}}
+
+.embed-external-info {{
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    min-width: 0;
+}}
+
+.embed-external-title {{
+    font-weight: 600;
+    color: var(--color-text);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}}
+
+.embed-external-description {{
+    font-size: 0.9em;
+    color: var(--color-muted);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+}}
+
+.embed-external-url {{
+    font-size: 0.8em;
+    font-family: var(--font-mono);
+    color: var(--color-subtle);
+}}
+
+/* Image embeds */
+.embed-images {{
+    display: grid;
+    gap: 4px;
+    margin-top: 0.5rem;
+    overflow: hidden;
+}}
+
+.embed-images-1 {{
+    grid-template-columns: 1fr;
+}}
+
+.embed-images-2 {{
+    grid-template-columns: 1fr 1fr;
+}}
+
+.embed-images-3 {{
+    grid-template-columns: 1fr 1fr;
+}}
+
+.embed-images-4 {{
+    grid-template-columns: 1fr 1fr;
+}}
+
+.embed-image-link {{
+    display: block;
+    line-height: 0;
+}}
+
+.embed-image {{
+    width: 100%;
+    height: auto;
+    max-height: 500px;
+    object-fit: cover;
+    object-position: center;
+    margin: 0;
+}}
+
+/* Quoted records */
+.embed-quote {{
+    display: block;
+    margin-top: 0.5rem;
+    padding: 0.75rem;
+    background: var(--color-overlay);
+    border-left: 2px solid var(--color-tertiary);
+}}
+
+@media (prefers-color-scheme: dark) {{
+    .embed-quote {{
+        border: 1px solid var(--color-border);
+        border-left: 2px solid var(--color-tertiary);
+    }}
+}}
+
+.embed-quote .embed-author {{
+    margin-bottom: 0.5rem;
+}}
+
+.embed-quote .embed-avatar {{
+    width: 24px;
+    height: 24px;
+    min-width: 24px;
+    min-height: 24px;
+}}
+
+.embed-quote .embed-content {{
+    font-size: 0.95em;
+    margin-bottom: 0;
+}}
+
+/* Placeholder states */
+.embed-video-placeholder,
+.embed-not-found,
+.embed-blocked,
+.embed-detached,
+.embed-unknown {{
+    display: block;
+    padding: 1rem;
+    background: var(--color-overlay);
+    border-left: 2px solid var(--color-border);
+    color: var(--color-muted);
+    font-style: italic;
+    margin-top: 0.5rem;
+    font-family: var(--font-mono);
+    font-size: 0.9em;
+}}
+
+@media (prefers-color-scheme: dark) {{
+    .embed-video-placeholder,
+    .embed-not-found,
+    .embed-blocked,
+    .embed-detached,
+    .embed-unknown {{
+        border: 1px dashed var(--color-border);
+    }}
+}}
+
+/* Record card embeds (feeds, lists, labelers, starter packs) */
+.embed-record-card {{
+    display: block;
+    margin-top: 0.5rem;
+    padding: 0.75rem;
+    background: var(--color-overlay);
+    border-left: 2px solid var(--color-tertiary);
+}}
+
+.embed-record-card > .embed-author-name {{
+    display: block;
+    font-size: 1.1em;
+}}
+
+.embed-subtitle {{
+    display: block;
+    font-size: 0.85em;
+    color: var(--color-muted);
+    margin-bottom: 0.5rem;
+}}
+
+.embed-record-card .embed-description {{
+    display: block;
+    margin: 0.5rem 0;
+}}
+
+.embed-record-card .embed-stats {{
+    display: block;
+    margin-top: 0.25rem;
+}}
+
+/* Generic record fields */
+.embed-fields {{
+    display: block;
+    margin-top: 0.5rem;
+    font-size: 0.85em;
+    color: var(--color-muted);
+}}
+
+.embed-field {{
+    display: block;
+    margin-top: 0.25rem;
+}}
+
+.embed-field-name {{
+    color: var(--color-subtle);
+}}
+
+.embed-field-number {{
+    color: var(--color-tertiary);
+}}
+
+.embed-field-date {{
+    color: var(--color-muted);
+}}
+
+.embed-field-count {{
+    color: var(--color-muted);
+    font-style: italic;
+}}
+
+.embed-field-bool-true {{
+    color: var(--color-success);
+}}
+
+.embed-field-bool-false {{
+    color: var(--color-muted);
+}}
+
+.embed-field-link,
+.embed-field-aturi {{
+    color: var(--color-link);
+    text-decoration: none;
+}}
+
+.embed-field-link:hover,
+.embed-field-aturi:hover {{
+    text-decoration: underline;
+}}
+
+.embed-field-did {{
+    font-family: var(--font-mono);
+    font-size: 0.9em;
+}}
+
+.embed-field-did .did-scheme,
+.embed-field-did .did-separator {{
+    color: var(--color-muted);
+}}
+
+.embed-field-did .did-method {{
+    color: var(--color-tertiary);
+}}
+
+.embed-field-did .did-identifier {{
+    color: var(--color-text);
+}}
+
+.embed-field-nsid {{
+    color: var(--color-secondary);
+}}
+
+.embed-field-handle {{
+    color: var(--color-link);
+}}
+
+/* AT URI highlighting */
+.aturi-scheme {{
+    color: var(--color-muted);
+}}
+
+.aturi-slash {{
+    color: var(--color-muted);
+}}
+
+.aturi-authority {{
+    color: var(--color-link);
+}}
+
+.aturi-collection {{
+    color: var(--color-secondary);
+}}
+
+.aturi-rkey {{
+    color: var(--color-tertiary);
+}}
+
+/* Generic AT Protocol record embed */
+.atproto-record > .embed-author-handle {{
+    display: block;
+    margin-bottom: 0.25rem;
+    text-transform: capitalize;
+}}
+
+.atproto-record > .embed-author-name {{
+    display: block;
+    margin-bottom: 0.5rem;
+}}
+
+.atproto-record > .embed-content {{
+    margin-bottom: 0.5rem;
+}}
+
+/* Notebook entry embed - full width, expandable */
+.atproto-entry {{
+    max-width: none;
+    width: 100%;
+    margin: 1.5rem 0;
+    padding: 0;
+    background: var(--color-surface);
+    border: 1px solid var(--color-border);
+    border-left: 1px solid var(--color-border);
+    box-shadow: none;
+    overflow: hidden;
+}}
+
+.atproto-entry:hover {{
+    border-left-color: var(--color-border);
+}}
+
+@media (prefers-color-scheme: dark) {{
+    .atproto-entry {{
+        border: 1px solid var(--color-border);
+        border-left: 1px solid var(--color-border);
+    }}
+}}
+
+.embed-entry-header {{
+    display: flex;
+    flex-wrap: wrap;
+    align-items: baseline;
+    gap: 0.5rem 1rem;
+    padding: 0.75rem 1rem;
+    background: var(--color-overlay);
+    border-bottom: 1px solid var(--color-border);
+}}
+
+.embed-entry-title {{
+    font-size: 1.1em;
+    font-weight: 600;
+    color: var(--color-text);
+}}
+
+.embed-entry-author {{
+    font-size: 0.85em;
+    color: var(--color-muted);
+}}
+
+/* Hidden checkbox for expand/collapse */
+.embed-entry-toggle {{
+    display: none;
+}}
+
+/* Content wrapper - scrollable when collapsed */
+.embed-entry-content {{
+    max-height: 30rem;
+    overflow-y: auto;
+    padding: 1rem;
+    transition: max-height 0.3s ease;
+}}
+
+/* When checkbox is checked, expand fully */
+.embed-entry-toggle:checked ~ .embed-entry-content {{
+    max-height: none;
+}}
+
+/* Expand/collapse button */
+.embed-entry-expand {{
+    display: block;
+    width: 100%;
+    padding: 0.5rem;
+    text-align: center;
+    font-size: 0.85em;
+    color: var(--color-muted);
+    background: var(--color-overlay);
+    border-top: 1px solid var(--color-border);
+    cursor: pointer;
+    user-select: none;
+}}
+
+.embed-entry-expand:hover {{
+    color: var(--color-text);
+    background: var(--color-surface);
+}}
+
+/* Toggle button text */
+.embed-entry-expand::before {{
+    content: "Expand ↓";
+}}
+
+.embed-entry-toggle:checked ~ .embed-entry-expand::before {{
+    content: "Collapse ↑";
+}}
+
+/* Hide expand button if content doesn't overflow (via JS class) */
+.atproto-entry.no-overflow .embed-entry-expand {{
+    display: none;
 }}
 
 /* Horizontal Rule */

crates/weaver-renderer/src/lib.rs

···
 pub mod base_html;
 pub mod code_pretty;
 pub mod css;
+pub mod math;
 #[cfg(not(target_family = "wasm"))]
 pub mod static_site;
 pub mod theme;

crates/weaver-renderer/src/math.rs

···
+//! LaTeX math rendering via pulldown-latex → MathML
+
+use markdown_weaver_escape::escape_html;
+use pulldown_latex::{
+    config::DisplayMode, config::RenderConfig, mathml::push_mathml, Parser, Storage,
+};
+
+/// Result of attempting to render LaTeX math
+pub enum MathResult {
+    /// Successfully rendered MathML
+    Success(String),
+    /// Rendering failed - contains fallback HTML with source and error message
+    Error { html: String, message: String },
+}
+
+/// Render LaTeX math to MathML
+///
+/// # Arguments
+/// * `latex` - The LaTeX source string (without delimiters like $ or $$)
+/// * `display_mode` - If true, render as display math (block); if false, inline
+pub fn render_math(latex: &str, display_mode: bool) -> MathResult {
+    let storage = Storage::new();
+    let parser = Parser::new(latex, &storage);
+    let config = RenderConfig {
+        display_mode: if display_mode {
+            DisplayMode::Block
+        } else {
+            DisplayMode::Inline
+        },
+        ..Default::default()
+    };
+
+    let mut mathml = String::new();
+
+    // Collect events, tracking any errors
+    let events: Vec<_> = parser.collect();
+    let errors: Vec<String> = events
+        .iter()
+        .filter_map(|e| e.as_ref().err().map(|err| err.to_string()))
+        .collect();
+
+    if errors.is_empty() {
+        // All events parsed successfully - push_mathml wants the Results directly
+        if let Err(e) = push_mathml(&mut mathml, events.into_iter(), config) {
+            return MathResult::Error {
+                html: format_error_html(latex, &e.to_string(), display_mode),
+                message: e.to_string(),
+            };
+        }
+        MathResult::Success(mathml)
+    } else {
+        // Had parse errors - return error HTML
+        let error_msg = errors.join("; ");
+        MathResult::Error {
+            html: format_error_html(latex, &error_msg, display_mode),
+            message: error_msg,
+        }
+    }
+}
+
+fn format_error_html(latex: &str, error: &str, display_mode: bool) -> String {
+    let mode_class = if display_mode {
+        "math-display"
+    } else {
+        "math-inline"
+    };
+    let mut escaped_latex = String::new();
+    let mut escaped_error = String::new();
+    // These won't fail writing to String
+    let _ = escape_html(&mut escaped_latex, latex);
+    let _ = escape_html(&mut escaped_error, error);
+    format!(
+        r#"<span class="math math-error {mode_class}" title="{escaped_error}"><code>{escaped_latex}</code></span>"#
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn renders_inline_math() {
+        let result = render_math("x^2", false);
+        assert!(matches!(result, MathResult::Success(_)));
+        if let MathResult::Success(mathml) = result {
+            assert!(mathml.contains("<math"));
+            assert!(mathml.contains("</math>"));
+        }
+    }
+
+    #[test]
+    fn renders_display_math() {
+        let result = render_math(r"\frac{a}{b}", true);
+        assert!(matches!(result, MathResult::Success(_)));
+        if let MathResult::Success(mathml) = result {
+            assert!(mathml.contains("<math"));
+            assert!(mathml.contains("<mfrac"));
+        }
+    }
+
+    #[test]
+    fn renders_complex_math() {
+        let result = render_math(r"\sum_{i=0}^{n} x_i", true);
+        assert!(matches!(result, MathResult::Success(_)));
+    }
+
+    #[test]
+    fn handles_invalid_latex() {
+        // Unclosed brace
+        let result = render_math(r"\frac{a", false);
+        assert!(matches!(result, MathResult::Error { .. }));
+        if let MathResult::Error { html, message } = result {
+            assert!(html.contains("math-error"));
+            assert!(!message.is_empty());
+        }
+    }
+}

crates/weaver-renderer/src/static_site/snapshots/weaver_renderer__static_site__tests__code_block_rendering.snap

···
 source: crates/weaver-renderer/src/static_site/tests.rs
 expression: output
 ---
-<pre><code class="wvrcode-code language-Rust"><span class="wvrcode-source wvrcode-rust"><span class="wvrcode-meta wvrcode-function wvrcode-rust"><span class="wvrcode-meta wvrcode-function wvrcode-rust"><span class="wvrcode-storage wvrcode-type wvrcode-function wvrcode-rust">fn</span> </span><span class="wvrcode-entity wvrcode-name wvrcode-function wvrcode-rust">main</span></span><span class="wvrcode-meta wvrcode-function wvrcode-rust"><span class="wvrcode-meta wvrcode-function wvrcode-parameters wvrcode-rust"><span class="wvrcode-punctuation wvrcode-section wvrcode-parameters wvrcode-begin wvrcode-rust">(</span></span><span class="wvrcode-meta wvrcode-function wvrcode-rust"><span class="wvrcode-meta wvrcode-function wvrcode-parameters wvrcode-rust"><span class="wvrcode-punctuation wvrcode-section wvrcode-parameters wvrcode-end wvrcode-rust">)</span></span></span></span><span class="wvrcode-meta wvrcode-function wvrcode-rust"> </span><span class="wvrcode-meta wvrcode-function wvrcode-rust"><span class="wvrcode-meta wvrcode-block wvrcode-rust"><span class="wvrcode-punctuation wvrcode-section wvrcode-block wvrcode-begin wvrcode-rust">{</span>
-    <span class="wvrcode-support wvrcode-macro wvrcode-rust">println!</span><span class="wvrcode-meta wvrcode-group wvrcode-rust"><span class="wvrcode-punctuation wvrcode-section wvrcode-group wvrcode-begin wvrcode-rust">(</span></span><span class="wvrcode-meta wvrcode-group wvrcode-rust"><span class="wvrcode-string wvrcode-quoted wvrcode-double wvrcode-rust"><span class="wvrcode-punctuation wvrcode-definition wvrcode-string wvrcode-begin wvrcode-rust">&quot;</span>Hello<span class="wvrcode-punctuation wvrcode-definition wvrcode-string wvrcode-end wvrcode-rust">&quot;</span></span></span><span class="wvrcode-meta wvrcode-group wvrcode-rust"><span class="wvrcode-punctuation wvrcode-section wvrcode-group wvrcode-end wvrcode-rust">)</span></span><span class="wvrcode-punctuation wvrcode-terminator wvrcode-rust">;</span>
-</span><span class="wvrcode-meta wvrcode-block wvrcode-rust"><span class="wvrcode-punctuation wvrcode-section wvrcode-block wvrcode-end wvrcode-rust">}</span></span></span>
+<pre><code class="wvc-code language-Rust"><span class="wvc-source wvc-rust"><span class="wvc-meta wvc-function wvc-rust"><span class="wvc-meta wvc-function wvc-rust"><span class="wvc-storage wvc-type wvc-function wvc-rust">fn</span> </span><span class="wvc-entity wvc-name wvc-function wvc-rust">main</span></span><span class="wvc-meta wvc-function wvc-rust"><span class="wvc-meta wvc-function wvc-parameters wvc-rust"><span class="wvc-punctuation wvc-section wvc-parameters wvc-begin wvc-rust">(</span></span><span class="wvc-meta wvc-function wvc-rust"><span class="wvc-meta wvc-function wvc-parameters wvc-rust"><span class="wvc-punctuation wvc-section wvc-parameters wvc-end wvc-rust">)</span></span></span></span><span class="wvc-meta wvc-function wvc-rust"> </span><span class="wvc-meta wvc-function wvc-rust"><span class="wvc-meta wvc-block wvc-rust"><span class="wvc-punctuation wvc-section wvc-block wvc-begin wvc-rust">{</span>
+    <span class="wvc-support wvc-macro wvc-rust">println!</span><span class="wvc-meta wvc-group wvc-rust"><span class="wvc-punctuation wvc-section wvc-group wvc-begin wvc-rust">(</span></span><span class="wvc-meta wvc-group wvc-rust"><span class="wvc-string wvc-quoted wvc-double wvc-rust"><span class="wvc-punctuation wvc-definition wvc-string wvc-begin wvc-rust">&quot;</span>Hello<span class="wvc-punctuation wvc-definition wvc-string wvc-end wvc-rust">&quot;</span></span></span><span class="wvc-meta wvc-group wvc-rust"><span class="wvc-punctuation wvc-section wvc-group wvc-end wvc-rust">)</span></span><span class="wvc-punctuation wvc-terminator wvc-rust">;</span>
+</span><span class="wvc-meta wvc-block wvc-rust"><span class="wvc-punctuation wvc-section wvc-block wvc-end wvc-rust">}</span></span></span>
 </span></code></pre>

lexicons/notebook/entry.json

···
           "title": { "type": "ref", "ref": "sh.weaver.notebook.defs#title" },
           "path": { "type": "ref", "ref": "sh.weaver.notebook.defs#path" },
           "tags": { "type": "ref", "ref": "sh.weaver.notebook.defs#tags" },
-
+          "authors": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "sh.weaver.actor.defs#author"
+            }
+          },
           "content": {
             "type": "string",
-            "maxLength": 200000,
             "description": "The content of the notebook entry. This should be some flavor of Markdown."
           },
-
           "createdAt": {
             "type": "string",
             "format": "datetime",

lexicons/notebook/theme.json

···
           "fonts": {
             "type": "object",
             "required": ["body", "heading", "monospace"],
+            "description": "Fonts to be used in the notebook. Can specify a name or list of names (will load if available) or a file or list of files for each. Empty lists will use site defaults."
             "properties": {
               "body": {
-                "type": "string"
+                "type": "array",
+                "items": {
+                  "type": "ref",
+                  "ref": "#font"
+                }
               },
               "heading": {
-                "type": "string"
+                "type": "array",
+                "items": {
+                  "type": "ref",
+                  "ref": "#font"
+                }
               },
               "monospace": {
-                "type": "string"
+                "type": "array",
+                "items": {
+                  "type": "ref",
+                  "ref": "#font"
+                }
               }
             }
           },
···
     },
     "codeThemeFile": {
       "type": "object",
-      "required": ["name", "did", "content"],
+      "required": ["name", "content"],
+      "description": "Custom syntax highlighting theme file (sublime text/textmate theme format)",
       "properties": {
         "name": {
           "type": "string"
         },
-        "did": {
-          "type": "string",
-          "format": "did"
+        "content": {
+          "type": "blob",
+          "accept": ["*/*"],
+          "maxSize": 20000
+        }
+      }
+    },
+    "font": {
+      "type": "object",
+      "required": ["value"],
+      "properties": {
+        "value": {
+          "type": "union",
+          "refs": ["#fontName", "#fontFile"],
+          "description": "Font for a notebook"
+        }
+      }
+    },
+    "fontName": {
+      "type": "string"
+    },
+    "fontFile": {
+      "type": "object",
+      "required": ["name", "content"],
+      "description": "Custom woff(2) or ttf font file"
+      "properties": {
+        "name": {
+          "type": "string"
         },
         "content": {
           "type": "blob",