broke up mega-writer file in editor

Cargo.lock

···
 
 [[package]]
 name = "cc"
-version = "1.2.49"
+version = "1.2.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90583009037521a116abf44494efecd645ba48b6622457080f080b85544e2215"
+checksum = "9f50d563227a1c37cc0a263f64eca3334388c01c5e4c4861a9def205c614383c"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
···
 [[package]]
 name = "dioxus-primitives"
 version = "0.0.1"
-source = "git+https://github.com/DioxusLabs/components#3564270718866d2e886f879973afc77d7c3a1689"
+source = "git+https://github.com/DioxusLabs/components#545aa7f55205b488f6403f92133fffb6c66838de"
 dependencies = [
  "dioxus 0.7.2",
  "dioxus-sdk-time",
···
 
 [[package]]
 name = "jacquard"
-version = "0.9.4"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
···
  "regex",
  "regex-lite",
  "reqwest",
- "ring",
  "serde",
  "serde_html_form",
  "serde_json",
···
 
 [[package]]
 name = "jacquard-api"
-version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "bon",
  "bytes",
···
 
 [[package]]
 name = "jacquard-axum"
-version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.6"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "axum",
  "bytes",
···
 
 [[package]]
 name = "jacquard-common"
-version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
  "regex",
  "regex-lite",
  "reqwest",
- "ring",
  "serde",
  "serde_bytes",
  "serde_html_form",
···
 
 [[package]]
 name = "jacquard-derive"
-version = "0.9.4"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 
 [[package]]
 name = "jacquard-identity"
-version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "bon",
  "bytes",
···
  "jacquard-common",
  "jacquard-lexicon",
  "miette 7.6.0",
- "mini-moka 0.10.99",
+ "mini-moka-wasm",
  "n0-future 0.1.3",
  "percent-encoding",
  "reqwest",
- "ring",
  "serde",
  "serde_html_form",
  "serde_json",
···
 
 [[package]]
 name = "jacquard-lexicon"
-version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "cid",
  "dashmap 6.1.0",
···
 
 [[package]]
 name = "jacquard-oauth"
-version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.6"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "base64 0.22.1",
  "bytes",
···
  "miette 7.6.0",
  "p256",
  "rand 0.8.5",
- "ring",
  "rouille",
  "serde",
  "serde_html_form",
···
 
 [[package]]
 name = "jacquard-repo"
-version = "0.9.4"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.9.5"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "bytes",
  "cid",
···
 [[package]]
 name = "markdown-weaver"
 version = "0.13.0"
-source = "git+https://github.com/rsform/markdown-weaver?branch=para-end-context#d1d3e3188bc0c52a060eb194a311f66c08e54377"
+source = "git+https://github.com/rsform/markdown-weaver?branch=para-end-context#5f4257b7ee3175f73974b43c3269b2130a4479ca"
 dependencies = [
  "bitflags 2.10.0",
  "getopts",
···
 [[package]]
 name = "markdown-weaver-escape"
 version = "0.11.0"
-source = "git+https://github.com/rsform/markdown-weaver?branch=para-end-context#d1d3e3188bc0c52a060eb194a311f66c08e54377"
+source = "git+https://github.com/rsform/markdown-weaver?branch=para-end-context#5f4257b7ee3175f73974b43c3269b2130a4479ca"
 
 [[package]]
 name = "markup5ever"
···
 
 [[package]]
 name = "mini-moka"
-version = "0.10.99"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
+version = "0.11.0"
+source = "git+https://github.com/moka-rs/mini-moka?rev=da864e849f5d034f32e02197fee9bb5d5af36d3d#da864e849f5d034f32e02197fee9bb5d5af36d3d"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
···
 ]
 
 [[package]]
-name = "mini-moka"
-version = "0.11.0"
-source = "git+https://github.com/moka-rs/mini-moka?rev=da864e849f5d034f32e02197fee9bb5d5af36d3d#da864e849f5d034f32e02197fee9bb5d5af36d3d"
+name = "mini-moka-wasm"
+version = "0.10.99"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#9021d423a2c199294a9206fa3ec2b8b2c261e117"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
···
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.1"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+checksum = "f59e70c4aef1e55797c2e8fd94a4f2a973fc972cfde0e0b05f683667b0cd39dd"
 
 [[package]]
 name = "portmapper"
···
  "markdown-weaver",
  "markdown-weaver-escape",
  "mime-sniffer",
- "mini-moka 0.11.0",
+ "mini-moka",
  "n0-future 0.1.3",
  "postcard",
  "regex",
···
  "k256",
  "loro",
  "miette 7.6.0",
- "mini-moka 0.11.0",
+ "mini-moka",
  "n0-future 0.1.3",
  "rand 0.8.5",
  "regex",

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

···
 /* Entry page layout - centered content with sidenote margin */
 .entry-page {
-    --content-width: 65ch;
+    --content-width: 95ch;
     --sidenote-width: 14rem;
     --sidenote-gap: 1.5rem;
 
···
     color: var(--color-primary);
 }
 
-.entry-header .nav-button-prev {
-    flex-shrink: 1;
+.entry-header .nav-button-prev,
+.entry-header .nav-placeholder:first-child {
+    flex: 1;
     min-width: 0;
 }
 
-.entry-header .nav-button-next {
-    flex-shrink: 1;
+.entry-header .nav-button-next,
+.entry-header .nav-placeholder:last-child {
+    flex: 1;
     min-width: 0;
+    justify-content: flex-end;
 }
 
 .entry-header .nav-arrow {
···
     text-overflow: ellipsis;
 }
 
-/* Metadata takes center, flexes to fill */
+/* Metadata anchored to content width */
 .entry-header .entry-metadata {
-    flex: 1;
-    max-width: var(--content-width);
+    width: min(var(--content-width), 100%);
+    flex-shrink: 1;
     margin: 0;
     padding: 0;
     border: none;
···
 .entry-content-main {
     width: var(--content-width);
     max-width: 100%;
+    border-top: 1px solid var(--color-border);
     position: relative;
 }
 
-/* When sidenotes exist, shift content left to make room */
-.entry-content-main:has(.sidenote) {
-    margin-right: calc(var(--sidenote-width) + var(--sidenote-gap));
-}
+/* Sidenote layout handled by css.rs body padding */
 
 /* Footer navigation */
 .entry-footer-nav {
···
     }
 }
 
-/* Responsive: when sidenotes need to squeeze */
-@media (max-width: 1000px) {
-    .entry-content-main:has(.sidenote) {
-        margin-right: calc(var(--sidenote-width) + 0.5rem);
-        margin-left: -3rem;
-    }
-}
-
-/* Responsive: narrower - compress left margin more */
+/* Responsive: narrower */
 @media (max-width: 900px) {
     .entry-header .nav-title {
         max-width: 8rem;
     }
-
-    .entry-content-main:has(.sidenote) {
-        margin-left: -5rem;
-    }
 }
 
-/* Responsive: mobile - sidenotes go inline */
+/* Responsive: mobile */
 @media (max-width: 768px) {
     .entry-header {
         flex-direction: column;
         align-items: stretch;
         gap: 0.5rem;
-    }
-
-    .entry-content-main:has(.sidenote) {
-        margin-left: 0;
-        margin-right: 0;
     }
 
     .entry-footer-nav {

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

···
 use super::toolbar::EditorToolbar;
 use super::visibility::update_syntax_visibility;
 #[allow(unused_imports)]
-use super::writer::{EditorImageResolver, SyntaxSpanInfo};
+use super::writer::EditorImageResolver;
+#[allow(unused_imports)]
+use super::writer::SyntaxSpanInfo;
 use crate::auth::AuthState;
 use crate::components::collab::CollaboratorAvatars;
 use crate::components::editor::ReportButton;

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

···
 //!
 //! Uses Parser::into_offset_iter() to track gaps between events, which
 //! represent consumed formatting characters.
+pub mod embed;
+pub mod segmented;
+pub mod syntax;
+pub mod tags;
+
+use crate::components::editor::writer::segmented::SegmentedWriter;
+pub use embed::{EditorImageResolver, EmbedContentProvider, ImageResolver};
+pub use syntax::{SyntaxSpanInfo, SyntaxType};
+
 #[allow(unused_imports)]
 use super::offset_map::{OffsetMapping, RenderResult};
-use jacquard::types::{ident::AtIdentifier, string::Rkey};
 use loro::LoroText;
-use markdown_weaver::{
-    Alignment, BlockQuoteKind, CodeBlockKind, CowStr, EmbedType, Event, LinkType, Tag,
-    WeaverAttributes,
-};
-use markdown_weaver_escape::{
-    StrWrite, escape_href, escape_html, escape_html_body_text,
-    escape_html_body_text_with_char_count,
-};
+use markdown_weaver::{Alignment, CowStr, Event, WeaverAttributes};
+use markdown_weaver_escape::{StrWrite, escape_html, escape_html_body_text_with_char_count};
 use std::collections::HashMap;
 use std::fmt;
 use std::ops::Range;
-use weaver_common::{EntryIndex, ResolvedContent};
-
-/// Writer that segments output by paragraph boundaries.
-///
-/// Each paragraph's HTML is written to a separate String in the segments Vec.
-/// Call `new_segment()` at paragraph boundaries to start a new segment.
-#[derive(Debug, Clone, Default)]
-pub struct SegmentedWriter {
-    segments: Vec<String>,
-}
-
-#[allow(dead_code)]
-impl SegmentedWriter {
-    pub fn new() -> Self {
-        Self {
-            segments: vec![String::new()],
-        }
-    }
-
-    /// Start a new segment for the next paragraph.
-    pub fn new_segment(&mut self) {
-        self.segments.push(String::new());
-    }
-
-    /// Get the completed segments.
-    pub fn into_segments(self) -> Vec<String> {
-        self.segments
-    }
-
-    /// Get current segment count.
-    pub fn segment_count(&self) -> usize {
-        self.segments.len()
-    }
-}
-
-impl StrWrite for SegmentedWriter {
-    type Error = fmt::Error;
-
-    #[inline]
-    fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
-        if let Some(segment) = self.segments.last_mut() {
-            segment.push_str(s);
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, args: fmt::Arguments) -> Result<(), Self::Error> {
-        if let Some(segment) = self.segments.last_mut() {
-            fmt::Write::write_fmt(segment, args)?;
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Write for SegmentedWriter {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        <Self as StrWrite>::write_str(self, s)
-    }
-
-    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
-        <Self as StrWrite>::write_fmt(self, args)
-    }
-}
+use weaver_common::EntryIndex;
 
 /// Result of rendering with the EditorWriter.
 #[derive(Debug, Clone)]
···
     pub collected_refs_by_paragraph: Vec<Vec<weaver_common::ExtractedRef>>,
 }
 
-/// Classification of markdown syntax characters
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SyntaxType {
-    /// Inline formatting: **, *, ~~, `, $, [, ], (, )
-    Inline,
-    /// Block formatting: #, >, -, *, 1., ```, ---
-    Block,
-}
-
-/// Information about a syntax span for conditional visibility
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SyntaxSpanInfo {
-    /// Unique identifier for this syntax span (e.g., "s0", "s1")
-    pub syn_id: String,
-    /// Source char range this syntax covers (just this marker)
-    pub char_range: Range<usize>,
-    /// Whether this is inline or block-level syntax
-    pub syntax_type: SyntaxType,
-    /// For paired inline syntax (**, *, etc), the full formatted region
-    /// from opening marker through content to closing marker.
-    /// When cursor is anywhere in this range, the syntax is visible.
-    pub formatted_range: Option<Range<usize>>,
-}
-
-impl SyntaxSpanInfo {
-    /// Adjust all position fields by a character delta.
-    ///
-    /// This adjusts both `char_range` and `formatted_range` (if present) together,
-    /// ensuring they stay in sync. Use this instead of manually adjusting fields
-    /// to avoid forgetting one.
-    pub fn adjust_positions(&mut self, char_delta: isize) {
-        self.char_range.start = (self.char_range.start as isize + char_delta) as usize;
-        self.char_range.end = (self.char_range.end as isize + char_delta) as usize;
-        if let Some(ref mut fr) = self.formatted_range {
-            fr.start = (fr.start as isize + char_delta) as usize;
-            fr.end = (fr.end as isize + char_delta) as usize;
-        }
-    }
-}
-
-/// Classify syntax text as inline or block level
-fn classify_syntax(text: &str) -> SyntaxType {
-    let trimmed = text.trim_start();
-
-    // Check for block-level markers
-    if trimmed.starts_with('#')
-        || trimmed.starts_with('>')
-        || trimmed.starts_with("```")
-        || trimmed.starts_with("---")
-        || (trimmed.starts_with('-')
-            && trimmed
-                .chars()
-                .nth(1)
-                .map(|c| c.is_whitespace())
-                .unwrap_or(false))
-        || (trimmed.starts_with('*')
-            && trimmed
-                .chars()
-                .nth(1)
-                .map(|c| c.is_whitespace())
-                .unwrap_or(false))
-        || trimmed
-            .chars()
-            .next()
-            .map(|c| c.is_ascii_digit())
-            .unwrap_or(false)
-            && trimmed.contains('.')
-    {
-        SyntaxType::Block
-    } else {
-        SyntaxType::Inline
-    }
-}
-
-/// Synchronous callback for injecting embed content
-///
-/// Takes the embed tag and returns optional HTML content to inject.
-pub trait EmbedContentProvider {
-    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<String>;
-}
-
-impl EmbedContentProvider for () {
-    fn get_embed_content(&self, _tag: &Tag<'_>) -> Option<String> {
-        None
-    }
-}
-
-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").
-/// This trait maps those names to the actual CDN URL using the blob CID and owner DID.
-pub trait ImageResolver {
-    /// Resolve an image URL from markdown to a CDN URL.
-    ///
-    /// Returns `Some(cdn_url)` if the image is found, `None` to use the original URL.
-    fn resolve_image_url(&self, url: &str) -> Option<String>;
-}
-
-impl ImageResolver for () {
-    fn resolve_image_url(&self, _url: &str) -> Option<String> {
-        None
-    }
-}
-
-/// Concrete image resolver that maps image names to URLs.
-///
-/// Resolved image path type
-#[derive(Clone, Debug)]
-enum ResolvedImage {
-    /// Data URL for immediate preview (still uploading)
-    Pending(String),
-    /// Draft image: `/image/{ident}/draft/{blob_rkey}/{name}`
-    Draft {
-        blob_rkey: Rkey<'static>,
-        ident: AtIdentifier<'static>,
-    },
-    /// Published image: `/image/{ident}/{entry_rkey}/{name}`
-    Published {
-        entry_rkey: Rkey<'static>,
-        ident: AtIdentifier<'static>,
-    },
-}
-
-/// Resolves image paths in the editor.
-///
-/// Supports three states for images:
-/// - Pending: uses data URL for immediate preview while upload is in progress
-/// - Draft: uses path format `/image/{did}/draft/{blob_rkey}/{name}`
-/// - Published: uses path format `/image/{did}/{entry_rkey}/{name}`
-///
-/// Image URLs in markdown use the format `/image/{name}`.
-#[derive(Clone, Default)]
-pub struct EditorImageResolver {
-    /// All resolved images: name -> resolved path info
-    images: std::collections::HashMap<String, ResolvedImage>,
-}
-
-impl EditorImageResolver {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Add a pending image with a data URL for immediate preview.
-    pub fn add_pending(&mut self, name: String, data_url: String) {
-        self.images.insert(name, ResolvedImage::Pending(data_url));
-    }
-
-    /// Promote a pending image to uploaded (draft) status.
-    pub fn promote_to_uploaded(
-        &mut self,
-        name: &str,
-        blob_rkey: Rkey<'static>,
-        ident: AtIdentifier<'static>,
-    ) {
-        self.images
-            .insert(name.to_string(), ResolvedImage::Draft { blob_rkey, ident });
-    }
-
-    /// Add an already-uploaded draft image.
-    pub fn add_uploaded(
-        &mut self,
-        name: String,
-        blob_rkey: Rkey<'static>,
-        ident: AtIdentifier<'static>,
-    ) {
-        self.images
-            .insert(name, ResolvedImage::Draft { blob_rkey, ident });
-    }
-
-    /// Add a published image.
-    pub fn add_published(
-        &mut self,
-        name: String,
-        entry_rkey: Rkey<'static>,
-        ident: AtIdentifier<'static>,
-    ) {
-        self.images
-            .insert(name, ResolvedImage::Published { entry_rkey, ident });
-    }
-
-    /// Check if an image is pending upload.
-    pub fn is_pending(&self, name: &str) -> bool {
-        matches!(self.images.get(name), Some(ResolvedImage::Pending(_)))
-    }
-
-    /// Build a resolver from editor images and user identifier.
-    ///
-    /// For draft mode (entry_rkey=None), only images with a `published_blob_uri` are included.
-    /// For published mode (entry_rkey=Some), all images are included.
-    pub fn from_images<'a>(
-        images: impl IntoIterator<Item = &'a super::document::EditorImage>,
-        ident: AtIdentifier<'static>,
-        entry_rkey: Option<Rkey<'static>>,
-    ) -> Self {
-        use jacquard::IntoStatic;
-
-        let mut resolver = Self::new();
-        for editor_image in images {
-            // Get the name from the Image (use alt text as fallback if name is empty)
-            let name = editor_image
-                .image
-                .name
-                .as_ref()
-                .map(|n| n.to_string())
-                .unwrap_or_else(|| editor_image.image.alt.to_string());
-
-            if name.is_empty() {
-                continue;
-            }
-
-            match &entry_rkey {
-                // Published mode: use entry rkey for all images
-                Some(rkey) => {
-                    resolver.add_published(name, rkey.clone(), ident.clone());
-                }
-                // Draft mode: use published_blob_uri rkey
-                None => {
-                    let blob_rkey = match &editor_image.published_blob_uri {
-                        Some(uri) => match uri.rkey() {
-                            Some(rkey) => rkey.0.clone().into_static(),
-                            None => continue,
-                        },
-                        None => continue,
-                    };
-                    resolver.add_uploaded(name, blob_rkey, ident.clone());
-                }
-            }
-        }
-        resolver
-    }
-}
-
-impl ImageResolver for EditorImageResolver {
-    fn resolve_image_url(&self, url: &str) -> Option<String> {
-        // Extract image name from /image/{name} format
-        let name = url.strip_prefix("/image/").unwrap_or(url);
-
-        let resolved = self.images.get(name)?;
-        match resolved {
-            ResolvedImage::Pending(data_url) => Some(data_url.clone()),
-            ResolvedImage::Draft { blob_rkey, ident } => {
-                Some(format!("/image/{}/draft/{}/{}", ident, blob_rkey, name))
-            }
-            ResolvedImage::Published { entry_rkey, ident } => {
-                Some(format!("/image/{}/{}/{}", ident, entry_rkey, name))
-            }
-        }
-    }
-}
-
-impl ImageResolver for &EditorImageResolver {
-    fn resolve_image_url(&self, url: &str) -> Option<String> {
-        (*self).resolve_image_url(url)
-    }
-}
-
 /// Tracks the type of wrapper element emitted for WeaverBlock prefix
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum WrapperElement {
     Aside,
     Div,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum TableState {
+    Head,
+    Body,
 }
 
 /// HTML writer that preserves markdown formatting characters.
···
     current_footnote_def: Option<(String, usize, usize)>,
 
     _phantom: std::marker::PhantomData<&'a ()>,
-}
-
-#[derive(Debug, Clone, Copy)]
-enum TableState {
-    Head,
-    Body,
 }
 
 impl<'a, I: Iterator<Item = (Event<'a>, Range<usize>)>, E: EmbedContentProvider, R: ImageResolver>
···
         }
     }
 
-    /// Emit syntax span for a given range and record offset mapping
-    fn emit_syntax(&mut self, range: Range<usize>) -> Result<(), fmt::Error> {
-        if range.start < range.end {
-            let syntax = &self.source[range.clone()];
-            if !syntax.is_empty() {
-                let char_start = self.last_char_offset;
-                let syntax_char_len = syntax.chars().count();
-                let char_end = char_start + syntax_char_len;
-
-                tracing::trace!(
-                    target: "weaver::writer",
-                    byte_range = ?range,
-                    char_range = ?(char_start..char_end),
-                    syntax = %syntax.escape_debug(),
-                    "emit_syntax"
-                );
-
-                // Whitespace-only content (trailing spaces, newlines) should be emitted
-                // as plain text, not wrapped in a hideable syntax span
-                let is_whitespace_only = syntax.trim().is_empty();
-
-                if is_whitespace_only {
-                    // Emit as plain text with tracking span (not hideable)
-                    let created_node = if self.current_node_id.is_none() {
-                        let node_id = self.gen_node_id();
-                        write!(&mut self.writer, "<span id=\"{}\">", node_id)?;
-                        self.begin_node(node_id);
-                        true
-                    } else {
-                        false
-                    };
-
-                    escape_html(&mut self.writer, syntax)?;
-
-                    // Record offset mapping BEFORE end_node (which clears current_node_id)
-                    self.record_mapping(range.clone(), char_start..char_end);
-                    self.last_char_offset = char_end;
-                    self.last_byte_offset = range.end;
-
-                    if created_node {
-                        self.write("</span>")?;
-                        self.end_node();
-                    }
-                } else {
-                    // Real syntax - wrap in hideable span
-                    let syntax_type = classify_syntax(syntax);
-                    let class = match syntax_type {
-                        SyntaxType::Inline => "md-syntax-inline",
-                        SyntaxType::Block => "md-syntax-block",
-                    };
-
-                    // Generate unique ID for this syntax span
-                    let syn_id = self.gen_syn_id();
-
-                    // If we're outside any node, create a wrapper span for tracking
-                    let created_node = if self.current_node_id.is_none() {
-                        let node_id = self.gen_node_id();
-                        write!(
-                            &mut self.writer,
-                            "<span id=\"{}\" class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
-                            node_id, class, syn_id, char_start, char_end
-                        )?;
-                        self.begin_node(node_id);
-                        true
-                    } else {
-                        write!(
-                            &mut self.writer,
-                            "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
-                            class, syn_id, char_start, char_end
-                        )?;
-                        false
-                    };
-
-                    escape_html(&mut self.writer, syntax)?;
-                    self.write("</span>")?;
-
-                    // Record syntax span info for visibility toggling
-                    self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type,
-                        formatted_range: None,
-                    });
-
-                    // Record offset mapping for this syntax
-                    self.record_mapping(range.clone(), char_start..char_end);
-                    self.last_char_offset = char_end;
-                    self.last_byte_offset = range.end;
-
-                    // Close wrapper if we created one
-                    if created_node {
-                        self.write("</span>")?;
-                        self.end_node();
-                    }
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// Emit syntax span inside current node with full offset tracking.
-    ///
-    /// Use this for syntax markers that appear inside block elements (headings, lists,
-    /// blockquotes, code fences). Unlike `emit_syntax` which is for gaps and creates
-    /// wrapper nodes, this assumes we're already inside a tracked node.
-    ///
-    /// - Writes `<span class="md-syntax-{class}">{syntax}</span>`
-    /// - Records offset mapping (for cursor positioning)
-    /// - Updates both `last_char_offset` and `last_byte_offset`
-    fn emit_inner_syntax(
-        &mut self,
-        syntax: &str,
-        byte_start: usize,
-        syntax_type: SyntaxType,
-    ) -> Result<(), fmt::Error> {
-        if syntax.is_empty() {
-            return Ok(());
-        }
-
-        let char_start = self.last_char_offset;
-        let syntax_char_len = syntax.chars().count();
-        let char_end = char_start + syntax_char_len;
-        let byte_end = byte_start + syntax.len();
-
-        let class_str = match syntax_type {
-            SyntaxType::Inline => "md-syntax-inline",
-            SyntaxType::Block => "md-syntax-block",
-        };
-
-        // Generate unique ID for this syntax span
-        let syn_id = self.gen_syn_id();
-
-        write!(
-            &mut self.writer,
-            "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
-            class_str, syn_id, char_start, char_end
-        )?;
-        escape_html(&mut self.writer, syntax)?;
-        self.write("</span>")?;
-
-        // Record syntax span info for visibility toggling
-        self.syntax_spans.push(SyntaxSpanInfo {
-            syn_id,
-            char_range: char_start..char_end,
-            syntax_type,
-            formatted_range: None,
-        });
-
-        // Record offset mapping for cursor positioning
-        self.record_mapping(byte_start..byte_end, char_start..char_end);
-
-        self.last_char_offset = char_end;
-        self.last_byte_offset = byte_end;
-
-        Ok(())
-    }
-
-    /// Emit any gap between last position and next offset
-    fn emit_gap_before(&mut self, next_offset: usize) -> Result<(), fmt::Error> {
-        // Skip gap emission if we're inside a table being rendered as markdown
-        if self.table_start_offset.is_some() && self.render_tables_as_markdown {
-            return Ok(());
-        }
-
-        // Skip gap emission if we're buffering code block content
-        // The code block handler manages its own syntax emission
-        if self.code_buffer.is_some() {
-            return Ok(());
-        }
-
-        if next_offset > self.last_byte_offset {
-            self.emit_syntax(self.last_byte_offset..next_offset)?;
-        }
-        Ok(())
-    }
-
     /// Generate a unique node ID.
     /// If a prefix is set (paragraph ID), produces `{prefix}-n{counter}`.
     /// Otherwise produces `n{counter}` for backwards compatibility.
···
                 let key = key.trim();
                 let value = value.trim();
                 if !key.is_empty() && !value.is_empty() {
-                    attrs.push((CowStr::from(key.to_string()), CowStr::from(value.to_string())));
+                    attrs.push((
+                        CowStr::from(key.to_string()),
+                        CowStr::from(value.to_string()),
+                    ));
                 }
             } else {
                 // No colon - treat as class, strip leading dot if present
···
                 self.weaver_block_buffer.push_str(&text);
             }
         }
-        Ok(())
-    }
-
-    fn start_tag(&mut self, tag: Tag<'_>, range: Range<usize>) -> Result<(), fmt::Error> {
-        // Check if this is a block-level tag that should have syntax inside
-        let is_block_tag = matches!(tag, Tag::Heading { .. } | Tag::BlockQuote(_));
-
-        // For inline tags, emit syntax before tag
-        if !is_block_tag && range.start < range.end {
-            let raw_text = &self.source[range.clone()];
-            let opening_syntax = match &tag {
-                Tag::Strong => {
-                    if raw_text.starts_with("**") {
-                        Some("**")
-                    } else if raw_text.starts_with("__") {
-                        Some("__")
-                    } else {
-                        None
-                    }
-                }
-                Tag::Emphasis => {
-                    if raw_text.starts_with("*") {
-                        Some("*")
-                    } else if raw_text.starts_with("_") {
-                        Some("_")
-                    } else {
-                        None
-                    }
-                }
-                Tag::Strikethrough => {
-                    if raw_text.starts_with("~~") {
-                        Some("~~")
-                    } else {
-                        None
-                    }
-                }
-                Tag::Link { link_type, .. } => {
-                    if matches!(link_type, LinkType::WikiLink { .. }) {
-                        if raw_text.starts_with("[[") {
-                            Some("[[")
-                        } else {
-                            None
-                        }
-                    } else if raw_text.starts_with('[') {
-                        Some("[")
-                    } else {
-                        None
-                    }
-                }
-                // Note: Tag::Image and Tag::Embed handle their own syntax spans
-                // in their respective handlers, so don't emit here
-                _ => None,
-            };
-
-            if let Some(syntax) = opening_syntax {
-                let syntax_type = classify_syntax(syntax);
-                let class = match syntax_type {
-                    SyntaxType::Inline => "md-syntax-inline",
-                    SyntaxType::Block => "md-syntax-block",
-                };
-
-                let char_start = self.last_char_offset;
-                let syntax_char_len = syntax.chars().count();
-                let char_end = char_start + syntax_char_len;
-                let syntax_byte_len = syntax.len();
-
-                // Generate unique ID for this syntax span
-                let syn_id = self.gen_syn_id();
-
-                write!(
-                    &mut self.writer,
-                    "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
-                    class, syn_id, char_start, char_end
-                )?;
-                escape_html(&mut self.writer, syntax)?;
-                self.write("</span>")?;
-
-                // Record syntax span info for visibility toggling
-                self.syntax_spans.push(SyntaxSpanInfo {
-                    syn_id: syn_id.clone(),
-                    char_range: char_start..char_end,
-                    syntax_type,
-                    formatted_range: None, // Will be updated when closing tag is emitted
-                });
-
-                // Record offset mapping for cursor positioning
-                // This is critical - without it, current_node_char_offset is wrong
-                // and all subsequent cursor positions are shifted
-                let byte_start = range.start;
-                let byte_end = range.start + syntax_byte_len;
-                self.record_mapping(byte_start..byte_end, char_start..char_end);
-
-                // For paired inline syntax, track opening span for formatted_range
-                if matches!(
-                    tag,
-                    Tag::Strong | Tag::Emphasis | Tag::Strikethrough | Tag::Link { .. }
-                ) {
-                    self.pending_inline_formats.push((syn_id, char_start));
-                }
-
-                // Update tracking - we've consumed this opening syntax
-                self.last_char_offset = char_end;
-                self.last_byte_offset = range.start + syntax_byte_len;
-            }
-        }
-
-        // Emit the opening tag
-        match tag {
-            // HTML blocks get their own paragraph to try and corral them better
-            Tag::HtmlBlock => {
-                // Record paragraph start for boundary tracking
-                // BUT skip if inside a list - list owns the paragraph boundary
-                if self.list_depth == 0 {
-                    self.current_paragraph_start =
-                        Some((self.last_byte_offset, self.last_char_offset));
-                }
-                let node_id = self.gen_node_id();
-
-                if self.end_newline {
-                    write!(
-                        &mut self.writer,
-                        r#"<p id="{}" class="html-embed html-embed-block">"#,
-                        node_id
-                    )?;
-                } else {
-                    write!(
-                        &mut self.writer,
-                        r#"\n<p id="{}" class="html-embed html-embed-block">"#,
-                        node_id
-                    )?;
-                }
-                self.begin_node(node_id.clone());
-
-                // Map the start position of the paragraph (before any content)
-                // This allows cursor to be placed at the very beginning
-                let para_start_char = self.last_char_offset;
-                let mapping = OffsetMapping {
-                    byte_range: range.start..range.start,
-                    char_range: para_start_char..para_start_char,
-                    node_id,
-                    char_offset_in_node: 0,
-                    child_index: Some(0), // position before first child
-                    utf16_len: 0,
-                };
-                self.offset_maps.push(mapping);
-
-                Ok(())
-            }
-            Tag::Paragraph(_) => {
-                // Handle wrapper before block
-                self.emit_wrapper_start()?;
-
-                // Record paragraph start for boundary tracking
-                // BUT skip if inside a list - list owns the paragraph boundary
-                if self.list_depth == 0 {
-                    self.current_paragraph_start =
-                        Some((self.last_byte_offset, self.last_char_offset));
-                }
-
-                let node_id = self.gen_node_id();
-                if self.end_newline {
-                    write!(&mut self.writer, "<p id=\"{}\">", node_id)?;
-                } else {
-                    write!(&mut self.writer, "\n<p id=\"{}\">", node_id)?;
-                }
-                self.begin_node(node_id.clone());
-
-                // Map the start position of the paragraph (before any content)
-                // This allows cursor to be placed at the very beginning
-                let para_start_char = self.last_char_offset;
-                let mapping = OffsetMapping {
-                    byte_range: range.start..range.start,
-                    char_range: para_start_char..para_start_char,
-                    node_id,
-                    char_offset_in_node: 0,
-                    child_index: Some(0), // position before first child
-                    utf16_len: 0,
-                };
-                self.offset_maps.push(mapping);
-
-                // Emit > syntax if we're inside a blockquote
-                if let Some(bq_range) = self.pending_blockquote_range.take() {
-                    if bq_range.start < bq_range.end {
-                        let raw_text = &self.source[bq_range.clone()];
-                        if let Some(gt_pos) = raw_text.find('>') {
-                            // Extract > [!NOTE] or just >
-                            let after_gt = &raw_text[gt_pos + 1..];
-                            let syntax_end = if after_gt.trim_start().starts_with("[!") {
-                                // Find the closing ]
-                                if let Some(close_bracket) = after_gt.find(']') {
-                                    gt_pos + 1 + close_bracket + 1
-                                } else {
-                                    gt_pos + 1
-                                }
-                            } else {
-                                // Just > and maybe a space
-                                (gt_pos + 1).min(raw_text.len())
-                            };
-
-                            let syntax = &raw_text[gt_pos..syntax_end];
-                            let syntax_byte_start = bq_range.start + gt_pos;
-                            self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxType::Block)?;
-                        }
-                    }
-                }
-                Ok(())
-            }
-            Tag::Heading {
-                level,
-                id,
-                classes,
-                attrs,
-            } => {
-                // Emit wrapper if pending (but don't close on heading end - wraps following block too)
-                self.emit_wrapper_start()?;
-
-                // Record paragraph start for boundary tracking
-                // Treat headings as paragraph-level blocks
-                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
-
-                if !self.end_newline {
-                    self.write("\n")?;
-                }
-
-                // Generate node ID for offset tracking
-                let node_id = self.gen_node_id();
-
-                self.write("<")?;
-                write!(&mut self.writer, "{}", level)?;
-
-                // Add our tracking ID as data attribute (preserve user's id if present)
-                self.write(" data-node-id=\"")?;
-                self.write(&node_id)?;
-                self.write("\"")?;
-
-                if let Some(id) = id {
-                    self.write(" id=\"")?;
-                    escape_html(&mut self.writer, &id)?;
-                    self.write("\"")?;
-                }
-                if !classes.is_empty() {
-                    self.write(" class=\"")?;
-                    for (i, class) in classes.iter().enumerate() {
-                        if i > 0 {
-                            self.write(" ")?;
-                        }
-                        escape_html(&mut self.writer, class)?;
-                    }
-                    self.write("\"")?;
-                }
-                for (attr, value) in attrs {
-                    self.write(" ")?;
-                    escape_html(&mut self.writer, &attr)?;
-                    if let Some(val) = value {
-                        self.write("=\"")?;
-                        escape_html(&mut self.writer, &val)?;
-                        self.write("\"")?;
-                    } else {
-                        self.write("=\"\"")?;
-                    }
-                }
-                self.write(">")?;
-
-                // Begin node tracking for offset mapping
-                self.begin_node(node_id.clone());
-
-                // Map the start position of the heading (before any content)
-                // This allows cursor to be placed at the very beginning
-                let heading_start_char = self.last_char_offset;
-                let mapping = OffsetMapping {
-                    byte_range: range.start..range.start,
-                    char_range: heading_start_char..heading_start_char,
-                    node_id: node_id.clone(),
-                    char_offset_in_node: 0,
-                    child_index: Some(0), // position before first child
-                    utf16_len: 0,
-                };
-                self.offset_maps.push(mapping);
-
-                // Emit # syntax inside the heading tag
-                if range.start < range.end {
-                    let raw_text = &self.source[range.clone()];
-                    let count = level as usize;
-                    let pattern = "#".repeat(count);
-
-                    // Find where the # actually starts (might have leading whitespace)
-                    if let Some(hash_pos) = raw_text.find(&pattern) {
-                        // Extract "# " or "## " etc
-                        let syntax_end = (hash_pos + count + 1).min(raw_text.len());
-                        let syntax = &raw_text[hash_pos..syntax_end];
-                        let syntax_byte_start = range.start + hash_pos;
-
-                        self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxType::Block)?;
-                    }
-                }
-                Ok(())
-            }
-            Tag::Table(alignments) => {
-                if self.render_tables_as_markdown {
-                    // Store start offset and skip HTML rendering
-                    self.table_start_offset = Some(range.start);
-                    self.in_non_writing_block = true; // Suppress content output
-                    Ok(())
-                } else {
-                    self.emit_wrapper_start()?;
-                    self.table_alignments = alignments;
-                    self.write("<table>")
-                }
-            }
-            Tag::TableHead => {
-                if self.render_tables_as_markdown {
-                    Ok(()) // Skip HTML rendering
-                } else {
-                    self.table_state = TableState::Head;
-                    self.table_cell_index = 0;
-                    self.write("<thead><tr>")
-                }
-            }
-            Tag::TableRow => {
-                if self.render_tables_as_markdown {
-                    Ok(()) // Skip HTML rendering
-                } else {
-                    self.table_cell_index = 0;
-                    self.write("<tr>")
-                }
-            }
-            Tag::TableCell => {
-                if self.render_tables_as_markdown {
-                    Ok(()) // Skip HTML rendering
-                } else {
-                    match self.table_state {
-                        TableState::Head => self.write("<th")?,
-                        TableState::Body => self.write("<td")?,
-                    }
-                    match self.table_alignments.get(self.table_cell_index) {
-                        Some(&Alignment::Left) => self.write(" style=\"text-align: left\">"),
-                        Some(&Alignment::Center) => self.write(" style=\"text-align: center\">"),
-                        Some(&Alignment::Right) => self.write(" style=\"text-align: right\">"),
-                        _ => self.write(">"),
-                    }
-                }
-            }
-            Tag::BlockQuote(kind) => {
-                self.emit_wrapper_start()?;
-
-                let class_str = match kind {
-                    None => "",
-                    Some(BlockQuoteKind::Note) => " class=\"markdown-alert-note\"",
-                    Some(BlockQuoteKind::Tip) => " class=\"markdown-alert-tip\"",
-                    Some(BlockQuoteKind::Important) => " class=\"markdown-alert-important\"",
-                    Some(BlockQuoteKind::Warning) => " class=\"markdown-alert-warning\"",
-                    Some(BlockQuoteKind::Caution) => " class=\"markdown-alert-caution\"",
-                };
-                if self.end_newline {
-                    write!(&mut self.writer, "<blockquote{}>\n", class_str)?;
-                } else {
-                    write!(&mut self.writer, "\n<blockquote{}>\n", class_str)?;
-                }
-
-                // Store range for emitting > inside the next paragraph
-                self.pending_blockquote_range = Some(range);
-                Ok(())
-            }
-            Tag::CodeBlock(info) => {
-                self.emit_wrapper_start()?;
-
-                // Track code block as paragraph-level block
-                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
-
-                if !self.end_newline {
-                    self.write_newline()?;
-                }
-
-                // Generate node ID for code block
-                let node_id = self.gen_node_id();
-
-                match info {
-                    CodeBlockKind::Fenced(info) => {
-                        // Emit opening ```language and track both char and byte offsets
-                        if range.start < range.end {
-                            let raw_text = &self.source[range.clone()];
-                            if let Some(fence_pos) = raw_text.find("```") {
-                                let fence_end = (fence_pos + 3 + info.len()).min(raw_text.len());
-                                let syntax = &raw_text[fence_pos..fence_end];
-                                let syntax_char_len = syntax.chars().count() + 1; // +1 for newline
-                                let syntax_byte_len = syntax.len() + 1; // +1 for newline
-
-                                let syn_id = self.gen_syn_id();
-                                let char_start = self.last_char_offset;
-                                let char_end = char_start + syntax_char_len;
-
-                                write!(
-                                    &mut self.writer,
-                                    "<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("</span>\n")?;
-
-                                // Track opening span index for formatted_range update later
-                                self.code_block_opening_span_idx = Some(self.syntax_spans.len());
-                                self.code_block_char_start = Some(char_start);
-
-                                self.syntax_spans.push(SyntaxSpanInfo {
-                                    syn_id,
-                                    char_range: char_start..char_end,
-                                    syntax_type: SyntaxType::Block,
-                                    formatted_range: None, // Will be set in TagEnd::CodeBlock
-                                });
-
-                                self.last_char_offset += syntax_char_len;
-                                self.last_byte_offset = range.start + fence_pos + syntax_byte_len;
-                            }
-                        }
-
-                        let lang = info.split(' ').next().unwrap();
-                        let lang_opt = if lang.is_empty() {
-                            None
-                        } else {
-                            Some(lang.to_string())
-                        };
-                        // Start buffering
-                        self.code_buffer = Some((lang_opt, String::new()));
-
-                        // Begin node tracking for offset mapping
-                        self.begin_node(node_id);
-                        Ok(())
-                    }
-                    CodeBlockKind::Indented => {
-                        // Ignore indented code blocks (as per executive decision)
-                        self.code_buffer = Some((None, String::new()));
-
-                        // Begin node tracking for offset mapping
-                        self.begin_node(node_id);
-                        Ok(())
-                    }
-                }
-            }
-            Tag::List(Some(1)) => {
-                self.emit_wrapper_start()?;
-                // Track list as paragraph-level block
-                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
-                self.list_depth += 1;
-                if self.end_newline {
-                    self.write("<ol>\n")
-                } else {
-                    self.write("\n<ol>\n")
-                }
-            }
-            Tag::List(Some(start)) => {
-                self.emit_wrapper_start()?;
-                // Track list as paragraph-level block
-                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
-                self.list_depth += 1;
-                if self.end_newline {
-                    self.write("<ol start=\"")?;
-                } else {
-                    self.write("\n<ol start=\"")?;
-                }
-                write!(&mut self.writer, "{}", start)?;
-                self.write("\">\n")
-            }
-            Tag::List(None) => {
-                self.emit_wrapper_start()?;
-                // Track list as paragraph-level block
-                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
-                self.list_depth += 1;
-                if self.end_newline {
-                    self.write("<ul>\n")
-                } else {
-                    self.write("\n<ul>\n")
-                }
-            }
-            Tag::Item => {
-                // Generate node ID for list item
-                let node_id = self.gen_node_id();
-
-                if self.end_newline {
-                    write!(&mut self.writer, "<li data-node-id=\"{}\">", node_id)?;
-                } else {
-                    write!(&mut self.writer, "\n<li data-node-id=\"{}\">", node_id)?;
-                }
-
-                // Begin node tracking
-                self.begin_node(node_id);
-
-                // Emit list marker syntax inside the <li> tag and track both offsets
-                if range.start < range.end {
-                    let raw_text = &self.source[range.clone()];
-
-                    // Try to find the list marker (-, *, or digit.)
-                    let trimmed = raw_text.trim_start();
-                    let leading_ws_bytes = raw_text.len() - trimmed.len();
-                    let leading_ws_chars = raw_text.chars().count() - trimmed.chars().count();
-
-                    if let Some(marker) = trimmed.chars().next() {
-                        if marker == '-' || marker == '*' {
-                            // Unordered list: extract "- " or "* "
-                            let marker_end = trimmed
-                                .find(|c: char| c != '-' && c != '*')
-                                .map(|pos| pos + 1)
-                                .unwrap_or(1);
-                            let syntax = &trimmed[..marker_end.min(trimmed.len())];
-                            let char_start = self.last_char_offset;
-                            let syntax_char_len = leading_ws_chars + syntax.chars().count();
-                            let syntax_byte_len = leading_ws_bytes + syntax.len();
-                            let char_end = char_start + syntax_char_len;
-
-                            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=\"{}\" spellcheck=\"false\">",
-                                syn_id, char_start, char_end
-                            )?;
-                            escape_html(&mut self.writer, syntax)?;
-                            self.write("</span>")?;
-
-                            self.syntax_spans.push(SyntaxSpanInfo {
-                                syn_id,
-                                char_range: char_start..char_end,
-                                syntax_type: SyntaxType::Block,
-                                formatted_range: None,
-                            });
-
-                            // Record offset mapping for cursor positioning
-                            self.record_mapping(
-                                range.start..range.start + syntax_byte_len,
-                                char_start..char_end,
-                            );
-                            self.last_char_offset = char_end;
-                            self.last_byte_offset = range.start + syntax_byte_len;
-                        } else if marker.is_ascii_digit() {
-                            // Ordered list: extract "1. " or similar (including trailing space)
-                            if let Some(dot_pos) = trimmed.find('.') {
-                                let syntax_end = (dot_pos + 2).min(trimmed.len());
-                                let syntax = &trimmed[..syntax_end];
-                                let char_start = self.last_char_offset;
-                                let syntax_char_len = leading_ws_chars + syntax.chars().count();
-                                let syntax_byte_len = leading_ws_bytes + syntax.len();
-                                let char_end = char_start + syntax_char_len;
-
-                                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=\"{}\" spellcheck=\"false\">",
-                                    syn_id, char_start, char_end
-                                )?;
-                                escape_html(&mut self.writer, syntax)?;
-                                self.write("</span>")?;
-
-                                self.syntax_spans.push(SyntaxSpanInfo {
-                                    syn_id,
-                                    char_range: char_start..char_end,
-                                    syntax_type: SyntaxType::Block,
-                                    formatted_range: None,
-                                });
-
-                                // Record offset mapping for cursor positioning
-                                self.record_mapping(
-                                    range.start..range.start + syntax_byte_len,
-                                    char_start..char_end,
-                                );
-                                self.last_char_offset = char_end;
-                                self.last_byte_offset = range.start + syntax_byte_len;
-                            }
-                        }
-                    }
-                }
-                Ok(())
-            }
-            Tag::DefinitionList => {
-                self.emit_wrapper_start()?;
-                if self.end_newline {
-                    self.write("<dl>\n")
-                } else {
-                    self.write("\n<dl>\n")
-                }
-            }
-            Tag::DefinitionListTitle => {
-                let node_id = self.gen_node_id();
-
-                if self.end_newline {
-                    write!(&mut self.writer, "<dt data-node-id=\"{}\">", node_id)?;
-                } else {
-                    write!(&mut self.writer, "\n<dt data-node-id=\"{}\">", node_id)?;
-                }
-
-                self.begin_node(node_id);
-                Ok(())
-            }
-            Tag::DefinitionListDefinition => {
-                let node_id = self.gen_node_id();
-
-                if self.end_newline {
-                    write!(&mut self.writer, "<dd data-node-id=\"{}\">", node_id)?;
-                } else {
-                    write!(&mut self.writer, "\n<dd data-node-id=\"{}\">", node_id)?;
-                }
-
-                self.begin_node(node_id);
-                Ok(())
-            }
-            Tag::Subscript => self.write("<sub>"),
-            Tag::Superscript => self.write("<sup>"),
-            Tag::Emphasis => self.write("<em>"),
-            Tag::Strong => self.write("<strong>"),
-            Tag::Strikethrough => self.write("<s>"),
-            Tag::Link {
-                link_type: LinkType::Email,
-                dest_url,
-                title,
-                ..
-            } => {
-                self.write("<a href=\"mailto:")?;
-                escape_href(&mut self.writer, &dest_url)?;
-                if !title.is_empty() {
-                    self.write("\" title=\"")?;
-                    escape_html(&mut self.writer, &title)?;
-                }
-                self.write("\">")
-            }
-            Tag::Link {
-                link_type,
-                dest_url,
-                title,
-                ..
-            } => {
-                // 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=\"")?;
-                    escape_html(&mut self.writer, &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()];
-                let syn_id = self.gen_syn_id();
-                let opening_char_start = self.last_char_offset;
-
-                // Find the alt text and closing syntax positions
-                let paren_pos = raw_text.rfind("](").unwrap_or(raw_text.len());
-                let alt_text = if raw_text.starts_with("![") && paren_pos > 2 {
-                    &raw_text[2..paren_pos]
-                } else {
-                    ""
-                };
-                let closing_syntax = if paren_pos < raw_text.len() {
-                    &raw_text[paren_pos..]
-                } else {
-                    ""
-                };
-
-                // Calculate char positions
-                let alt_char_len = alt_text.chars().count();
-                let closing_char_len = closing_syntax.chars().count();
-                let opening_char_end = opening_char_start + 2; // "!["
-                let alt_char_start = opening_char_end;
-                let alt_char_end = alt_char_start + alt_char_len;
-                let closing_char_start = alt_char_end;
-                let closing_char_end = closing_char_start + closing_char_len;
-                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=\"{}\" spellcheck=\"false\">![</span>",
-                        syn_id, opening_char_start, opening_char_end
-                    )?;
-
-                    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()),
-                    });
-
-                    // Record offset mapping for ![
-                    self.record_mapping(
-                        range.start..range.start + 2,
-                        opening_char_start..opening_char_end,
-                    );
-                }
-
-                // 2. Emit alt text span (same syn_id, editable when visible)
-                if !alt_text.is_empty() {
-                    write!(
-                        &mut self.writer,
-                        "<span class=\"image-alt\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
-                        syn_id, alt_char_start, alt_char_end
-                    )?;
-                    escape_html(&mut self.writer, alt_text)?;
-                    self.write("</span>")?;
-
-                    self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id: syn_id.clone(),
-                        char_range: alt_char_start..alt_char_end,
-                        syntax_type: SyntaxType::Inline,
-                        formatted_range: Some(formatted_range.clone()),
-                    });
-
-                    // Record offset mapping for alt text
-                    self.record_mapping(
-                        range.start + 2..range.start + 2 + alt_text.len(),
-                        alt_char_start..alt_char_end,
-                    );
-                }
-
-                // 3. Emit closing ](url) syntax span
-                if !closing_syntax.is_empty() {
-                    write!(
-                        &mut self.writer,
-                        "<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)?;
-                    self.write("</span>")?;
-
-                    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()),
-                    });
-
-                    // Record offset mapping for ](url)
-                    self.record_mapping(
-                        range.start + paren_pos..range.end,
-                        closing_char_start..closing_char_end,
-                    );
-                }
-
-                // 4. Emit <img> element (no syn_id - always visible)
-                self.write("<img src=\"")?;
-                let resolved_url = self
-                    .image_resolver
-                    .as_ref()
-                    .and_then(|r| r.resolve_image_url(&dest_url));
-                if let Some(ref cdn_url) = resolved_url {
-                    escape_href(&mut self.writer, cdn_url)?;
-                } else {
-                    escape_href(&mut self.writer, &dest_url)?;
-                }
-                self.write("\" alt=\"")?;
-                escape_html(&mut self.writer, alt_text)?;
-                self.write("\"")?;
-                if !title.is_empty() {
-                    self.write(" title=\"")?;
-                    escape_html(&mut self.writer, &title)?;
-                    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 {
-                        self.write(" ")?;
-                        escape_html(&mut self.writer, attr)?;
-                        self.write("=\"")?;
-                        escape_html(&mut self.writer, value)?;
-                        self.write("\"")?;
-                    }
-                }
-                self.write(" />")?;
-
-                // Consume the text events for alt (they're still in the iterator)
-                // Use consume_until_end() since we already wrote alt text from source
-                self.consume_until_end();
-
-                // Update offsets
-                self.last_char_offset = closing_char_end;
-                self.last_byte_offset = range.end;
-
-                Ok(())
-            }
-            Tag::Embed {
-                embed_type,
-                dest_url,
-                title,
-                id,
-                attrs,
-            } => self.write_embed(range, embed_type, dest_url, title, id, attrs),
-            Tag::WeaverBlock(_, attrs) => {
-                self.in_non_writing_block = true;
-                self.weaver_block_buffer.clear();
-                self.weaver_block_char_start = Some(self.last_char_offset);
-                // Store attrs from Start tag, will merge with parsed text on End
-                if !attrs.classes.is_empty() || !attrs.attrs.is_empty() {
-                    self.pending_block_attrs = Some(attrs.into_static());
-                }
-                Ok(())
-            }
-            Tag::FootnoteDefinition(name) => {
-                // Emit the [^name]: prefix as a hideable syntax span
-                // The source should have "[^name]: " at the start
-                let prefix = format!("[^{}]: ", name);
-                let char_start = self.last_char_offset;
-                let prefix_char_len = prefix.chars().count();
-                let char_end = char_start + prefix_char_len;
-                let syn_id = self.gen_syn_id();
-
-                if !self.end_newline {
-                    self.write("\n")?;
-                }
-
-                write!(
-                    &mut self.writer,
-                    "<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, &prefix)?;
-                self.write("</span>")?;
-
-                // Track this span for linking with the footnote reference
-                let def_span_index = self.syntax_spans.len();
-                self.syntax_spans.push(SyntaxSpanInfo {
-                    syn_id,
-                    char_range: char_start..char_end,
-                    syntax_type: SyntaxType::Block,
-                    formatted_range: None, // Set at FootnoteDefinition end
-                });
-
-                // Store the definition info for linking at end
-                self.current_footnote_def = Some((name.to_string(), def_span_index, char_start));
-
-                // Record offset mapping for the syntax span
-                self.record_mapping(range.start..range.start + prefix.len(), char_start..char_end);
-
-                // Update tracking for the prefix
-                self.last_char_offset = char_end;
-                self.last_byte_offset = range.start + prefix.len();
-
-                // Emit the definition container
-                write!(
-                    &mut self.writer,
-                    "<div class=\"footnote-definition\" id=\"fn-{}\">",
-                    name
-                )?;
-
-                // Get/create footnote number for the label
-                let len = self.numbers.len() + 1;
-                let number = *self.numbers.entry(name.to_string()).or_insert(len);
-                write!(
-                    &mut self.writer,
-                    "<sup class=\"footnote-definition-label\">{}</sup>",
-                    number
-                )?;
-
-                Ok(())
-            }
-            Tag::MetadataBlock(_) => {
-                self.in_non_writing_block = true;
-                Ok(())
-            }
-        }
-    }
-
-    fn end_tag(
-        &mut self,
-        tag: markdown_weaver::TagEnd,
-        range: Range<usize>,
-    ) -> Result<(), fmt::Error> {
-        use markdown_weaver::TagEnd;
-
-        // Emit tag HTML first
-        let result = match tag {
-            TagEnd::HtmlBlock => {
-                // Capture paragraph boundary info BEFORE writing closing HTML
-                // Skip if inside a list - list owns the paragraph boundary
-                let para_boundary = if self.list_depth == 0 {
-                    self.current_paragraph_start
-                        .take()
-                        .map(|(byte_start, char_start)| {
-                            (
-                                byte_start..self.last_byte_offset,
-                                char_start..self.last_char_offset,
-                            )
-                        })
-                } else {
-                    None
-                };
-
-                // Write closing HTML to current segment
-                self.end_node();
-                self.write("</p>\n")?;
-
-                // Now finalize paragraph (starts new segment)
-                if let Some((byte_range, char_range)) = para_boundary {
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-                Ok(())
-            }
-            TagEnd::Paragraph(_) => {
-                // Capture paragraph boundary info BEFORE writing closing HTML
-                // Skip if inside a list - list owns the paragraph boundary
-                let para_boundary = if self.list_depth == 0 {
-                    self.current_paragraph_start
-                        .take()
-                        .map(|(byte_start, char_start)| {
-                            (
-                                byte_start..self.last_byte_offset,
-                                char_start..self.last_char_offset,
-                            )
-                        })
-                } else {
-                    None
-                };
-
-                // Write closing HTML to current segment
-                self.end_node();
-                self.write("</p>\n")?;
-                self.close_wrapper()?;
-
-                // Now finalize paragraph (starts new segment)
-                if let Some((byte_range, char_range)) = para_boundary {
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-                Ok(())
-            }
-            TagEnd::Heading(level) => {
-                // Capture paragraph boundary info BEFORE writing closing HTML
-                let para_boundary =
-                    self.current_paragraph_start
-                        .take()
-                        .map(|(byte_start, char_start)| {
-                            (
-                                byte_start..self.last_byte_offset,
-                                char_start..self.last_char_offset,
-                            )
-                        });
-
-                // Write closing HTML to current segment
-                self.end_node();
-                self.write("</")?;
-                write!(&mut self.writer, "{}", level)?;
-                self.write(">\n")?;
-                // Note: Don't close wrapper here - headings typically go with following block
-
-                // Now finalize paragraph (starts new segment)
-                if let Some((byte_range, char_range)) = para_boundary {
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-                Ok(())
-            }
-            TagEnd::Table => {
-                if self.render_tables_as_markdown {
-                    // Emit the raw markdown table
-                    if let Some(start) = self.table_start_offset.take() {
-                        let table_text = &self.source[start..range.end];
-                        self.in_non_writing_block = false;
-
-                        // Wrap in a pre or div for styling
-                        self.write("<pre class=\"table-markdown\">")?;
-                        escape_html(&mut self.writer, table_text)?;
-                        self.write("</pre>\n")?;
-                    }
-                    Ok(())
-                } else {
-                    self.write("</tbody></table>\n")
-                }
-            }
-            TagEnd::TableHead => {
-                if self.render_tables_as_markdown {
-                    Ok(()) // Skip HTML rendering
-                } else {
-                    self.write("</tr></thead><tbody>\n")?;
-                    self.table_state = TableState::Body;
-                    Ok(())
-                }
-            }
-            TagEnd::TableRow => {
-                if self.render_tables_as_markdown {
-                    Ok(()) // Skip HTML rendering
-                } else {
-                    self.write("</tr>\n")
-                }
-            }
-            TagEnd::TableCell => {
-                if self.render_tables_as_markdown {
-                    Ok(()) // Skip HTML rendering
-                } else {
-                    match self.table_state {
-                        TableState::Head => self.write("</th>")?,
-                        TableState::Body => self.write("</td>")?,
-                    }
-                    self.table_cell_index += 1;
-                    Ok(())
-                }
-            }
-            TagEnd::BlockQuote(_) => {
-                // If pending_blockquote_range is still set, the blockquote was empty
-                // (no paragraph inside). Emit the > as its own minimal paragraph.
-                let mut para_boundary = None;
-                if let Some(bq_range) = self.pending_blockquote_range.take() {
-                    if bq_range.start < bq_range.end {
-                        let raw_text = &self.source[bq_range.clone()];
-                        if let Some(gt_pos) = raw_text.find('>') {
-                            let para_byte_start = bq_range.start + gt_pos;
-                            let para_char_start = self.last_char_offset;
-
-                            // Create a minimal paragraph for the empty blockquote
-                            let node_id = self.gen_node_id();
-                            write!(&mut self.writer, "<div id=\"{}\"", node_id)?;
-
-                            // Record start-of-node mapping for cursor positioning
-                            self.offset_maps.push(OffsetMapping {
-                                byte_range: para_byte_start..para_byte_start,
-                                char_range: para_char_start..para_char_start,
-                                node_id: node_id.clone(),
-                                char_offset_in_node: gt_pos,
-                                child_index: Some(0),
-                                utf16_len: 0,
-                            });
-
-                            // Emit the > as block syntax
-                            let syntax = &raw_text[gt_pos..gt_pos + 1];
-                            self.emit_inner_syntax(syntax, para_byte_start, SyntaxType::Block)?;
-
-                            self.write("</div>\n")?;
-                            self.end_node();
-
-                            // Capture paragraph boundary for later finalization
-                            let byte_range = para_byte_start..bq_range.end;
-                            let char_range = para_char_start..self.last_char_offset;
-                            para_boundary = Some((byte_range, char_range));
-                        }
-                    }
-                }
-                self.write("</blockquote>\n")?;
-                self.close_wrapper()?;
-
-                // Now finalize paragraph if we had one
-                if let Some((byte_range, char_range)) = para_boundary {
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-                Ok(())
-            }
-            TagEnd::CodeBlock => {
-                use std::sync::LazyLock;
-                use syntect::parsing::SyntaxSet;
-                static SYNTAX_SET: LazyLock<SyntaxSet> =
-                    LazyLock::new(|| SyntaxSet::load_defaults_newlines());
-
-                if let Some((lang, buffer)) = self.code_buffer.take() {
-                    // Create offset mapping for code block content if we tracked ranges
-                    if let (Some(code_byte_range), Some(code_char_range)) = (
-                        self.code_buffer_byte_range.take(),
-                        self.code_buffer_char_range.take(),
-                    ) {
-                        // Record mapping before writing HTML
-                        // (current_node_id should be set by start_tag for CodeBlock)
-                        self.record_mapping(code_byte_range, code_char_range);
-                    }
-
-                    // Get node_id for data-node-id attribute (needed for cursor positioning)
-                    let node_id = self.current_node_id.clone();
-
-                    if let Some(ref lang_str) = lang {
-                        // Use a temporary String buffer for syntect
-                        let mut temp_output = String::new();
-                        match weaver_renderer::code_pretty::highlight(
-                            &SYNTAX_SET,
-                            Some(lang_str),
-                            &buffer,
-                            &mut temp_output,
-                        ) {
-                            Ok(_) => {
-                                // Inject data-node-id into the <pre> tag for cursor positioning
-                                if let Some(ref nid) = node_id {
-                                    let injected = temp_output.replacen(
-                                        "<pre>",
-                                        &format!("<pre data-node-id=\"{}\">", nid),
-                                        1,
-                                    );
-                                    self.write(&injected)?;
-                                } else {
-                                    self.write(&temp_output)?;
-                                }
-                            }
-                            Err(_) => {
-                                // Fallback to plain code block
-                                if let Some(ref nid) = node_id {
-                                    write!(
-                                        &mut self.writer,
-                                        "<pre data-node-id=\"{}\"><code class=\"language-",
-                                        nid
-                                    )?;
-                                } else {
-                                    self.write("<pre><code class=\"language-")?;
-                                }
-                                escape_html(&mut self.writer, lang_str)?;
-                                self.write("\">")?;
-                                escape_html_body_text(&mut self.writer, &buffer)?;
-                                self.write("</code></pre>\n")?;
-                            }
-                        }
-                    } else {
-                        if let Some(ref nid) = node_id {
-                            write!(&mut self.writer, "<pre data-node-id=\"{}\"><code>", nid)?;
-                        } else {
-                            self.write("<pre><code>")?;
-                        }
-                        escape_html_body_text(&mut self.writer, &buffer)?;
-                        self.write("</code></pre>\n")?;
-                    }
-
-                    // End node tracking
-                    self.end_node();
-                } else {
-                    self.write("</code></pre>\n")?;
-                }
-
-                // Emit closing ``` (emit_gap_before is skipped while buffering)
-                // Track the opening span index and char start before we potentially clear them
-                let opening_span_idx = self.code_block_opening_span_idx.take();
-                let code_block_start = self.code_block_char_start.take();
-
-                if range.start < range.end {
-                    let raw_text = &self.source[range.clone()];
-                    if let Some(fence_line) = raw_text.lines().last() {
-                        if fence_line.trim().starts_with("```") {
-                            let fence = fence_line.trim();
-                            let fence_char_len = fence.chars().count();
-
-                            let syn_id = self.gen_syn_id();
-                            let char_start = self.last_char_offset;
-                            let char_end = char_start + fence_char_len;
-
-                            write!(
-                                &mut self.writer,
-                                "<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)?;
-                            self.write("</span>")?;
-
-                            self.last_char_offset += fence_char_len;
-                            self.last_byte_offset += fence.len();
-
-                            // Compute formatted_range for entire code block (opening fence to closing fence)
-                            let formatted_range =
-                                code_block_start.map(|start| start..self.last_char_offset);
-
-                            // Update opening fence span with formatted_range
-                            if let (Some(idx), Some(fr)) =
-                                (opening_span_idx, formatted_range.as_ref())
-                            {
-                                if let Some(span) = self.syntax_spans.get_mut(idx) {
-                                    span.formatted_range = Some(fr.clone());
-                                }
-                            }
-
-                            // Push closing fence span with formatted_range
-                            self.syntax_spans.push(SyntaxSpanInfo {
-                                syn_id,
-                                char_range: char_start..char_end,
-                                syntax_type: SyntaxType::Block,
-                                formatted_range,
-                            });
-                        }
-                    }
-                }
-
-                // Finalize code block paragraph
-                if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
-                    let byte_range = byte_start..self.last_byte_offset;
-                    let char_range = char_start..self.last_char_offset;
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-
-                Ok(())
-            }
-            TagEnd::List(true) => {
-                self.list_depth = self.list_depth.saturating_sub(1);
-                // Capture paragraph boundary BEFORE writing closing HTML
-                let para_boundary =
-                    self.current_paragraph_start
-                        .take()
-                        .map(|(byte_start, char_start)| {
-                            (
-                                byte_start..self.last_byte_offset,
-                                char_start..self.last_char_offset,
-                            )
-                        });
-
-                self.write("</ol>\n")?;
-                self.close_wrapper()?;
-
-                // Finalize paragraph after closing HTML
-                if let Some((byte_range, char_range)) = para_boundary {
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-                Ok(())
-            }
-            TagEnd::List(false) => {
-                self.list_depth = self.list_depth.saturating_sub(1);
-                // Capture paragraph boundary BEFORE writing closing HTML
-                let para_boundary =
-                    self.current_paragraph_start
-                        .take()
-                        .map(|(byte_start, char_start)| {
-                            (
-                                byte_start..self.last_byte_offset,
-                                char_start..self.last_char_offset,
-                            )
-                        });
-
-                self.write("</ul>\n")?;
-                self.close_wrapper()?;
-
-                // Finalize paragraph after closing HTML
-                if let Some((byte_range, char_range)) = para_boundary {
-                    self.finalize_paragraph(byte_range, char_range);
-                }
-                Ok(())
-            }
-            TagEnd::Item => {
-                self.end_node();
-                self.write("</li>\n")
-            }
-            TagEnd::DefinitionList => {
-                self.write("</dl>\n")?;
-                self.close_wrapper()
-            }
-            TagEnd::DefinitionListTitle => {
-                self.end_node();
-                self.write("</dt>\n")
-            }
-            TagEnd::DefinitionListDefinition => {
-                self.end_node();
-                self.write("</dd>\n")
-            }
-            TagEnd::Emphasis => {
-                // Write closing tag FIRST, then emit closing syntax OUTSIDE the tag
-                self.write("</em>")?;
-                self.emit_gap_before(range.end)?;
-                self.finalize_paired_inline_format();
-                Ok(())
-            }
-            TagEnd::Superscript => self.write("</sup>"),
-            TagEnd::Subscript => self.write("</sub>"),
-            TagEnd::Strong => {
-                // Write closing tag FIRST, then emit closing syntax OUTSIDE the tag
-                self.write("</strong>")?;
-                self.emit_gap_before(range.end)?;
-                self.finalize_paired_inline_format();
-                Ok(())
-            }
-            TagEnd::Strikethrough => {
-                // Write closing tag FIRST, then emit closing syntax OUTSIDE the tag
-                self.write("</s>")?;
-                self.emit_gap_before(range.end)?;
-                self.finalize_paired_inline_format();
-                Ok(())
-            }
-            TagEnd::Link => {
-                self.write("</a>")?;
-                // Check if this is a wiki link (ends with ]]) vs regular link (ends with ))
-                let raw_text = &self.source[range.clone()];
-                if raw_text.ends_with("]]") {
-                    // WikiLink: emit ]] as closing syntax
-                    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=\"{}\" spellcheck=\"false\">]]</span>",
-                        syn_id, char_start, char_end
-                    )?;
-
-                    self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type: SyntaxType::Inline,
-                        formatted_range: None, // Will be set by finalize
-                    });
-
-                    self.last_char_offset = char_end;
-                    self.last_byte_offset = range.end;
-                } else {
-                    self.emit_gap_before(range.end)?;
-                }
-                self.finalize_paired_inline_format();
-                Ok(())
-            }
-            TagEnd::Image => Ok(()), // No-op: raw_text() already consumed the End(Image) event
-            TagEnd::Embed => Ok(()),
-            TagEnd::WeaverBlock(_) => {
-                self.in_non_writing_block = false;
-
-                // Emit the { content } as a hideable syntax span
-                if let Some(char_start) = self.weaver_block_char_start.take() {
-                    // Build the full syntax text: { buffered_content }
-                    let syntax_text = format!("{{{}}}", self.weaver_block_buffer);
-                    let syntax_char_len = syntax_text.chars().count();
-                    let char_end = char_start + syntax_char_len;
-
-                    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=\"{}\" spellcheck=\"false\">",
-                        syn_id, char_start, char_end
-                    )?;
-                    escape_html(&mut self.writer, &syntax_text)?;
-                    self.write("</span>")?;
-
-                    // Track the syntax span
-                    self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type: SyntaxType::Block,
-                        formatted_range: None,
-                    });
-
-                    // Record offset mapping for the syntax span
-                    self.record_mapping(range.clone(), char_start..char_end);
-
-                    // Update tracking
-                    self.last_char_offset = char_end;
-                    self.last_byte_offset = range.end;
-                }
-
-                // Parse the buffered text for attrs and store for next block
-                if !self.weaver_block_buffer.is_empty() {
-                    let parsed = Self::parse_weaver_attrs(&self.weaver_block_buffer);
-                    self.weaver_block_buffer.clear();
-                    // Merge with any existing pending attrs or set new
-                    if let Some(ref mut existing) = self.pending_block_attrs {
-                        existing.classes.extend(parsed.classes);
-                        existing.attrs.extend(parsed.attrs);
-                    } else {
-                        self.pending_block_attrs = Some(parsed);
-                    }
-                }
-
-                Ok(())
-            }
-            TagEnd::FootnoteDefinition => {
-                self.write("</div>\n")?;
-
-                // Link the footnote definition span with its reference span
-                if let Some((name, def_span_index, _def_char_start)) =
-                    self.current_footnote_def.take()
-                {
-                    let def_char_end = self.last_char_offset;
-
-                    // Look up the reference span
-                    if let Some(&(ref_span_index, ref_char_start)) =
-                        self.footnote_ref_spans.get(&name)
-                    {
-                        // Create formatted_range spanning from ref start to def end
-                        let formatted_range = ref_char_start..def_char_end;
-
-                        // Update both spans with the same formatted_range
-                        // so they show/hide together based on cursor proximity
-                        if let Some(ref_span) = self.syntax_spans.get_mut(ref_span_index) {
-                            ref_span.formatted_range = Some(formatted_range.clone());
-                        }
-                        if let Some(def_span) = self.syntax_spans.get_mut(def_span_index) {
-                            def_span.formatted_range = Some(formatted_range);
-                        }
-                    }
-                }
-
-                Ok(())
-            }
-            TagEnd::MetadataBlock(_) => {
-                self.in_non_writing_block = false;
-                Ok(())
-            }
-        };
-
-        result?;
-
-        // Note: Closing syntax for inline formatting tags (Strong, Emphasis, Strikethrough)
-        // is handled INSIDE their respective match arms above, AFTER writing the closing HTML.
-        // This ensures the closing syntax span appears OUTSIDE the formatted element.
-        // Other End events have their closing syntax emitted by emit_gap_before() in the main loop.
-
-        Ok(())
-    }
-}
-
-impl<'a, I: Iterator<Item = (Event<'a>, Range<usize>)>, E: EmbedContentProvider, R: ImageResolver>
-    EditorWriter<'a, I, E, R>
-{
-    fn write_embed(
-        &mut self,
-        range: Range<usize>,
-        embed_type: EmbedType,
-        dest_url: CowStr<'_>,
-        title: CowStr<'_>,
-        id: CowStr<'_>,
-        attrs: Option<markdown_weaver::WeaverAttributes<'_>>,
-    ) -> Result<(), fmt::Error> {
-        // 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()
-        };
-
-        // 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;
-
-        // 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
-            )?;
-
-            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.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 {
-            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
-                .attrs
-                .iter()
-                .find(|(k, _)| k.as_ref() == "content")
-                .map(|(_, v)| v.as_ref().to_string())
-        } else {
-            None
-        };
-
-        // If no content in attrs, try provider
-        let content = if let Some(content) = content_from_attrs {
-            Some(content)
-        } else if let Some(ref provider) = self.embed_provider {
-            let tag = Tag::Embed {
-                embed_type,
-                dest_url: dest_url.clone(),
-                title: title.clone(),
-                id: id.clone(),
-                attrs: attrs.clone(),
-            };
-            provider.get_embed_content(&tag)
-        } else {
-            None
-        };
-
-        if let Some(html_content) = content {
-            // Write the pre-rendered content directly
-            self.write(&html_content)?;
-        } else {
-            // 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>")?;
-        }
-
-        // 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();
-
-        // Update offsets
-        self.last_char_offset = closing_char_end;
-        self.last_byte_offset = range.end;
-
         Ok(())
     }
 }

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

···
+use core::fmt;
+use std::ops::Range;
+
+use jacquard::types::{ident::AtIdentifier, string::Rkey};
+use markdown_weaver::{CowStr, EmbedType, Event, Tag};
+use markdown_weaver_escape::{StrWrite, escape_html};
+use weaver_common::ResolvedContent;
+
+use crate::components::editor::{
+    SyntaxSpanInfo, SyntaxType, document::EditorImage, writer::EditorWriter,
+};
+
+/// Synchronous callback for injecting embed content
+///
+/// Takes the embed tag and returns optional HTML content to inject.
+pub trait EmbedContentProvider {
+    fn get_embed_content(&self, tag: &Tag<'_>) -> Option<String>;
+}
+
+impl EmbedContentProvider for () {
+    fn get_embed_content(&self, _tag: &Tag<'_>) -> Option<String> {
+        None
+    }
+}
+
+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").
+/// This trait maps those names to the actual CDN URL using the blob CID and owner DID.
+pub trait ImageResolver {
+    /// Resolve an image URL from markdown to a CDN URL.
+    ///
+    /// Returns `Some(cdn_url)` if the image is found, `None` to use the original URL.
+    fn resolve_image_url(&self, url: &str) -> Option<String>;
+}
+
+impl ImageResolver for () {
+    fn resolve_image_url(&self, _url: &str) -> Option<String> {
+        None
+    }
+}
+
+/// Concrete image resolver that maps image names to URLs.
+///
+/// Resolved image path type
+#[derive(Clone, Debug)]
+enum ResolvedImage {
+    /// Data URL for immediate preview (still uploading)
+    Pending(String),
+    /// Draft image: `/image/{ident}/draft/{blob_rkey}/{name}`
+    Draft {
+        blob_rkey: Rkey<'static>,
+        ident: AtIdentifier<'static>,
+    },
+    /// Published image: `/image/{ident}/{entry_rkey}/{name}`
+    Published {
+        entry_rkey: Rkey<'static>,
+        ident: AtIdentifier<'static>,
+    },
+}
+
+/// Resolves image paths in the editor.
+///
+/// Supports three states for images:
+/// - Pending: uses data URL for immediate preview while upload is in progress
+/// - Draft: uses path format `/image/{did}/draft/{blob_rkey}/{name}`
+/// - Published: uses path format `/image/{did}/{entry_rkey}/{name}`
+///
+/// Image URLs in markdown use the format `/image/{name}`.
+#[derive(Clone, Default)]
+pub struct EditorImageResolver {
+    /// All resolved images: name -> resolved path info
+    images: std::collections::HashMap<String, ResolvedImage>,
+}
+
+impl EditorImageResolver {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add a pending image with a data URL for immediate preview.
+    pub fn add_pending(&mut self, name: String, data_url: String) {
+        self.images.insert(name, ResolvedImage::Pending(data_url));
+    }
+
+    /// Promote a pending image to uploaded (draft) status.
+    pub fn promote_to_uploaded(
+        &mut self,
+        name: &str,
+        blob_rkey: Rkey<'static>,
+        ident: AtIdentifier<'static>,
+    ) {
+        self.images
+            .insert(name.to_string(), ResolvedImage::Draft { blob_rkey, ident });
+    }
+
+    /// Add an already-uploaded draft image.
+    pub fn add_uploaded(
+        &mut self,
+        name: String,
+        blob_rkey: Rkey<'static>,
+        ident: AtIdentifier<'static>,
+    ) {
+        self.images
+            .insert(name, ResolvedImage::Draft { blob_rkey, ident });
+    }
+
+    /// Add a published image.
+    pub fn add_published(
+        &mut self,
+        name: String,
+        entry_rkey: Rkey<'static>,
+        ident: AtIdentifier<'static>,
+    ) {
+        self.images
+            .insert(name, ResolvedImage::Published { entry_rkey, ident });
+    }
+
+    /// Check if an image is pending upload.
+    pub fn is_pending(&self, name: &str) -> bool {
+        matches!(self.images.get(name), Some(ResolvedImage::Pending(_)))
+    }
+
+    /// Build a resolver from editor images and user identifier.
+    ///
+    /// For draft mode (entry_rkey=None), only images with a `published_blob_uri` are included.
+    /// For published mode (entry_rkey=Some), all images are included.
+    pub fn from_images<'a>(
+        images: impl IntoIterator<Item = &'a EditorImage>,
+        ident: AtIdentifier<'static>,
+        entry_rkey: Option<Rkey<'static>>,
+    ) -> Self {
+        use jacquard::IntoStatic;
+
+        let mut resolver = Self::new();
+        for editor_image in images {
+            // Get the name from the Image (use alt text as fallback if name is empty)
+            let name = editor_image
+                .image
+                .name
+                .as_ref()
+                .map(|n| n.to_string())
+                .unwrap_or_else(|| editor_image.image.alt.to_string());
+
+            if name.is_empty() {
+                continue;
+            }
+
+            match &entry_rkey {
+                // Published mode: use entry rkey for all images
+                Some(rkey) => {
+                    resolver.add_published(name, rkey.clone(), ident.clone());
+                }
+                // Draft mode: use published_blob_uri rkey
+                None => {
+                    let blob_rkey = match &editor_image.published_blob_uri {
+                        Some(uri) => match uri.rkey() {
+                            Some(rkey) => rkey.0.clone().into_static(),
+                            None => continue,
+                        },
+                        None => continue,
+                    };
+                    resolver.add_uploaded(name, blob_rkey, ident.clone());
+                }
+            }
+        }
+        resolver
+    }
+}
+
+impl ImageResolver for EditorImageResolver {
+    fn resolve_image_url(&self, url: &str) -> Option<String> {
+        // Extract image name from /image/{name} format
+        let name = url.strip_prefix("/image/").unwrap_or(url);
+
+        let resolved = self.images.get(name)?;
+        match resolved {
+            ResolvedImage::Pending(data_url) => Some(data_url.clone()),
+            ResolvedImage::Draft { blob_rkey, ident } => {
+                Some(format!("/image/{}/draft/{}/{}", ident, blob_rkey, name))
+            }
+            ResolvedImage::Published { entry_rkey, ident } => {
+                Some(format!("/image/{}/{}/{}", ident, entry_rkey, name))
+            }
+        }
+    }
+}
+
+impl ImageResolver for &EditorImageResolver {
+    fn resolve_image_url(&self, url: &str) -> Option<String> {
+        (*self).resolve_image_url(url)
+    }
+}
+
+impl<'a, I: Iterator<Item = (Event<'a>, Range<usize>)>, E: EmbedContentProvider, R: ImageResolver>
+    EditorWriter<'a, I, E, R>
+{
+    pub(crate) fn write_embed(
+        &mut self,
+        range: Range<usize>,
+        embed_type: EmbedType,
+        dest_url: CowStr<'_>,
+        title: CowStr<'_>,
+        id: CowStr<'_>,
+        attrs: Option<markdown_weaver::WeaverAttributes<'_>>,
+    ) -> Result<(), fmt::Error> {
+        // 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()
+        };
+
+        // 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;
+
+        // 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
+            )?;
+
+            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.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 {
+            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
+                .attrs
+                .iter()
+                .find(|(k, _)| k.as_ref() == "content")
+                .map(|(_, v)| v.as_ref().to_string())
+        } else {
+            None
+        };
+
+        // If no content in attrs, try provider
+        let content = if let Some(content) = content_from_attrs {
+            Some(content)
+        } else if let Some(ref provider) = self.embed_provider {
+            let tag = Tag::Embed {
+                embed_type,
+                dest_url: dest_url.clone(),
+                title: title.clone(),
+                id: id.clone(),
+                attrs: attrs.clone(),
+            };
+            provider.get_embed_content(&tag)
+        } else {
+            None
+        };
+
+        if let Some(html_content) = content {
+            // Write the pre-rendered content directly
+            self.write(&html_content)?;
+        } else {
+            // 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>")?;
+        }
+
+        // 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();
+
+        // Update offsets
+        self.last_char_offset = closing_char_end;
+        self.last_byte_offset = range.end;
+
+        Ok(())
+    }
+}

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

···
+use core::fmt;
+
+use markdown_weaver_escape::StrWrite;
+
+/// Writer that segments output by paragraph boundaries.
+///
+/// Each paragraph's HTML is written to a separate String in the segments Vec.
+/// Call `new_segment()` at paragraph boundaries to start a new segment.
+#[derive(Debug, Clone, Default)]
+pub struct SegmentedWriter {
+    pub segments: Vec<String>,
+}
+
+#[allow(dead_code)]
+impl SegmentedWriter {
+    pub fn new() -> Self {
+        Self {
+            segments: vec![String::new()],
+        }
+    }
+
+    /// Start a new segment for the next paragraph.
+    pub fn new_segment(&mut self) {
+        self.segments.push(String::new());
+    }
+
+    /// Get the completed segments.
+    pub fn into_segments(self) -> Vec<String> {
+        self.segments
+    }
+
+    /// Get current segment count.
+    pub fn segment_count(&self) -> usize {
+        self.segments.len()
+    }
+}
+
+impl StrWrite for SegmentedWriter {
+    type Error = fmt::Error;
+
+    #[inline]
+    fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
+        if let Some(segment) = self.segments.last_mut() {
+            segment.push_str(s);
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, args: fmt::Arguments) -> Result<(), Self::Error> {
+        if let Some(segment) = self.segments.last_mut() {
+            fmt::Write::write_fmt(segment, args)?;
+        }
+        Ok(())
+    }
+}
+
+impl fmt::Write for SegmentedWriter {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        <Self as StrWrite>::write_str(self, s)
+    }
+
+    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
+        <Self as StrWrite>::write_fmt(self, args)
+    }
+}

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

···
+use core::fmt;
+use std::ops::Range;
+
+use markdown_weaver::Event;
+use markdown_weaver_escape::{StrWrite, escape_html};
+
+use crate::components::editor::writer::{
+    EditorWriter,
+    embed::{EmbedContentProvider, ImageResolver},
+};
+
+/// Classification of markdown syntax characters
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SyntaxType {
+    /// Inline formatting: **, *, ~~, `, $, [, ], (, )
+    Inline,
+    /// Block formatting: #, >, -, *, 1., ```, ---
+    Block,
+}
+
+/// Information about a syntax span for conditional visibility
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SyntaxSpanInfo {
+    /// Unique identifier for this syntax span (e.g., "s0", "s1")
+    pub syn_id: String,
+    /// Source char range this syntax covers (just this marker)
+    pub char_range: Range<usize>,
+    /// Whether this is inline or block-level syntax
+    pub syntax_type: SyntaxType,
+    /// For paired inline syntax (**, *, etc), the full formatted region
+    /// from opening marker through content to closing marker.
+    /// When cursor is anywhere in this range, the syntax is visible.
+    pub formatted_range: Option<Range<usize>>,
+}
+
+impl SyntaxSpanInfo {
+    /// Adjust all position fields by a character delta.
+    ///
+    /// This adjusts both `char_range` and `formatted_range` (if present) together,
+    /// ensuring they stay in sync. Use this instead of manually adjusting fields
+    /// to avoid forgetting one.
+    pub fn adjust_positions(&mut self, char_delta: isize) {
+        self.char_range.start = (self.char_range.start as isize + char_delta) as usize;
+        self.char_range.end = (self.char_range.end as isize + char_delta) as usize;
+        if let Some(ref mut fr) = self.formatted_range {
+            fr.start = (fr.start as isize + char_delta) as usize;
+            fr.end = (fr.end as isize + char_delta) as usize;
+        }
+    }
+}
+
+/// Classify syntax text as inline or block level
+pub(crate) fn classify_syntax(text: &str) -> SyntaxType {
+    let trimmed = text.trim_start();
+
+    // Check for block-level markers
+    if trimmed.starts_with('#')
+        || trimmed.starts_with('>')
+        || trimmed.starts_with("```")
+        || trimmed.starts_with("---")
+        || (trimmed.starts_with('-')
+            && trimmed
+                .chars()
+                .nth(1)
+                .map(|c| c.is_whitespace())
+                .unwrap_or(false))
+        || (trimmed.starts_with('*')
+            && trimmed
+                .chars()
+                .nth(1)
+                .map(|c| c.is_whitespace())
+                .unwrap_or(false))
+        || trimmed
+            .chars()
+            .next()
+            .map(|c| c.is_ascii_digit())
+            .unwrap_or(false)
+            && trimmed.contains('.')
+    {
+        SyntaxType::Block
+    } else {
+        SyntaxType::Inline
+    }
+}
+
+impl<'a, I: Iterator<Item = (Event<'a>, Range<usize>)>, E: EmbedContentProvider, R: ImageResolver>
+    EditorWriter<'a, I, E, R>
+{
+    /// Emit syntax span for a given range and record offset mapping
+    pub(crate) fn emit_syntax(&mut self, range: Range<usize>) -> Result<(), fmt::Error> {
+        if range.start < range.end {
+            let syntax = &self.source[range.clone()];
+            if !syntax.is_empty() {
+                let char_start = self.last_char_offset;
+                let syntax_char_len = syntax.chars().count();
+                let char_end = char_start + syntax_char_len;
+
+                tracing::trace!(
+                    target: "weaver::writer",
+                    byte_range = ?range,
+                    char_range = ?(char_start..char_end),
+                    syntax = %syntax.escape_debug(),
+                    "emit_syntax"
+                );
+
+                // Whitespace-only content (trailing spaces, newlines) should be emitted
+                // as plain text, not wrapped in a hideable syntax span
+                let is_whitespace_only = syntax.trim().is_empty();
+
+                if is_whitespace_only {
+                    // Emit as plain text with tracking span (not hideable)
+                    let created_node = if self.current_node_id.is_none() {
+                        let node_id = self.gen_node_id();
+                        write!(&mut self.writer, "<span id=\"{}\">", node_id)?;
+                        self.begin_node(node_id);
+                        true
+                    } else {
+                        false
+                    };
+
+                    escape_html(&mut self.writer, syntax)?;
+
+                    // Record offset mapping BEFORE end_node (which clears current_node_id)
+                    self.record_mapping(range.clone(), char_start..char_end);
+                    self.last_char_offset = char_end;
+                    self.last_byte_offset = range.end;
+
+                    if created_node {
+                        self.write("</span>")?;
+                        self.end_node();
+                    }
+                } else {
+                    // Real syntax - wrap in hideable span
+                    let syntax_type = classify_syntax(syntax);
+                    let class = match syntax_type {
+                        SyntaxType::Inline => "md-syntax-inline",
+                        SyntaxType::Block => "md-syntax-block",
+                    };
+
+                    // Generate unique ID for this syntax span
+                    let syn_id = self.gen_syn_id();
+
+                    // If we're outside any node, create a wrapper span for tracking
+                    let created_node = if self.current_node_id.is_none() {
+                        let node_id = self.gen_node_id();
+                        write!(
+                            &mut self.writer,
+                            "<span id=\"{}\" class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            node_id, class, syn_id, char_start, char_end
+                        )?;
+                        self.begin_node(node_id);
+                        true
+                    } else {
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            class, syn_id, char_start, char_end
+                        )?;
+                        false
+                    };
+
+                    escape_html(&mut self.writer, syntax)?;
+                    self.write("</span>")?;
+
+                    // Record syntax span info for visibility toggling
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type,
+                        formatted_range: None,
+                    });
+
+                    // Record offset mapping for this syntax
+                    self.record_mapping(range.clone(), char_start..char_end);
+                    self.last_char_offset = char_end;
+                    self.last_byte_offset = range.end;
+
+                    // Close wrapper if we created one
+                    if created_node {
+                        self.write("</span>")?;
+                        self.end_node();
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Emit syntax span inside current node with full offset tracking.
+    ///
+    /// Use this for syntax markers that appear inside block elements (headings, lists,
+    /// blockquotes, code fences). Unlike `emit_syntax` which is for gaps and creates
+    /// wrapper nodes, this assumes we're already inside a tracked node.
+    ///
+    /// - Writes `<span class="md-syntax-{class}">{syntax}</span>`
+    /// - Records offset mapping (for cursor positioning)
+    /// - Updates both `last_char_offset` and `last_byte_offset`
+    pub(crate) fn emit_inner_syntax(
+        &mut self,
+        syntax: &str,
+        byte_start: usize,
+        syntax_type: SyntaxType,
+    ) -> Result<(), fmt::Error> {
+        if syntax.is_empty() {
+            return Ok(());
+        }
+
+        let char_start = self.last_char_offset;
+        let syntax_char_len = syntax.chars().count();
+        let char_end = char_start + syntax_char_len;
+        let byte_end = byte_start + syntax.len();
+
+        let class_str = match syntax_type {
+            SyntaxType::Inline => "md-syntax-inline",
+            SyntaxType::Block => "md-syntax-block",
+        };
+
+        // Generate unique ID for this syntax span
+        let syn_id = self.gen_syn_id();
+
+        write!(
+            &mut self.writer,
+            "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+            class_str, syn_id, char_start, char_end
+        )?;
+        escape_html(&mut self.writer, syntax)?;
+        self.write("</span>")?;
+
+        // Record syntax span info for visibility toggling
+        self.syntax_spans.push(SyntaxSpanInfo {
+            syn_id,
+            char_range: char_start..char_end,
+            syntax_type,
+            formatted_range: None,
+        });
+
+        // Record offset mapping for cursor positioning
+        self.record_mapping(byte_start..byte_end, char_start..char_end);
+
+        self.last_char_offset = char_end;
+        self.last_byte_offset = byte_end;
+
+        Ok(())
+    }
+
+    /// Emit any gap between last position and next offset
+    pub(crate) fn emit_gap_before(&mut self, next_offset: usize) -> Result<(), fmt::Error> {
+        // Skip gap emission if we're inside a table being rendered as markdown
+        if self.table_start_offset.is_some() && self.render_tables_as_markdown {
+            return Ok(());
+        }
+
+        // Skip gap emission if we're buffering code block content
+        // The code block handler manages its own syntax emission
+        if self.code_buffer.is_some() {
+            return Ok(());
+        }
+
+        if next_offset > self.last_byte_offset {
+            self.emit_syntax(self.last_byte_offset..next_offset)?;
+        }
+        Ok(())
+    }
+}

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

···
+use core::fmt;
+use std::ops::Range;
+
+use markdown_weaver::{Alignment, BlockQuoteKind, CodeBlockKind, EmbedType, Event, LinkType, Tag};
+use markdown_weaver_escape::{StrWrite, escape_href, escape_html, escape_html_body_text};
+
+use crate::components::editor::{
+    OffsetMapping, SyntaxSpanInfo, SyntaxType,
+    writer::{
+        EditorWriter, TableState,
+        embed::{EmbedContentProvider, ImageResolver},
+        syntax::classify_syntax,
+    },
+};
+
+impl<'a, I: Iterator<Item = (Event<'a>, Range<usize>)>, E: EmbedContentProvider, R: ImageResolver>
+    EditorWriter<'a, I, E, R>
+{
+    pub(crate) fn start_tag(
+        &mut self,
+        tag: Tag<'_>,
+        range: Range<usize>,
+    ) -> Result<(), fmt::Error> {
+        // Check if this is a block-level tag that should have syntax inside
+        let is_block_tag = matches!(tag, Tag::Heading { .. } | Tag::BlockQuote(_));
+
+        // For inline tags, emit syntax before tag
+        if !is_block_tag && range.start < range.end {
+            let raw_text = &self.source[range.clone()];
+            let opening_syntax = match &tag {
+                Tag::Strong => {
+                    if raw_text.starts_with("**") {
+                        Some("**")
+                    } else if raw_text.starts_with("__") {
+                        Some("__")
+                    } else {
+                        None
+                    }
+                }
+                Tag::Emphasis => {
+                    if raw_text.starts_with("*") {
+                        Some("*")
+                    } else if raw_text.starts_with("_") {
+                        Some("_")
+                    } else {
+                        None
+                    }
+                }
+                Tag::Strikethrough => {
+                    if raw_text.starts_with("~~") {
+                        Some("~~")
+                    } else {
+                        None
+                    }
+                }
+                Tag::Link { link_type, .. } => {
+                    if matches!(link_type, LinkType::WikiLink { .. }) {
+                        if raw_text.starts_with("[[") {
+                            Some("[[")
+                        } else {
+                            None
+                        }
+                    } else if raw_text.starts_with('[') {
+                        Some("[")
+                    } else {
+                        None
+                    }
+                }
+                // Note: Tag::Image and Tag::Embed handle their own syntax spans
+                // in their respective handlers, so don't emit here
+                _ => None,
+            };
+
+            if let Some(syntax) = opening_syntax {
+                let syntax_type = classify_syntax(syntax);
+                let class = match syntax_type {
+                    SyntaxType::Inline => "md-syntax-inline",
+                    SyntaxType::Block => "md-syntax-block",
+                };
+
+                let char_start = self.last_char_offset;
+                let syntax_char_len = syntax.chars().count();
+                let char_end = char_start + syntax_char_len;
+                let syntax_byte_len = syntax.len();
+
+                // Generate unique ID for this syntax span
+                let syn_id = self.gen_syn_id();
+
+                write!(
+                    &mut self.writer,
+                    "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                    class, syn_id, char_start, char_end
+                )?;
+                escape_html(&mut self.writer, syntax)?;
+                self.write("</span>")?;
+
+                // Record syntax span info for visibility toggling
+                self.syntax_spans.push(SyntaxSpanInfo {
+                    syn_id: syn_id.clone(),
+                    char_range: char_start..char_end,
+                    syntax_type,
+                    formatted_range: None, // Will be updated when closing tag is emitted
+                });
+
+                // Record offset mapping for cursor positioning
+                // This is critical - without it, current_node_char_offset is wrong
+                // and all subsequent cursor positions are shifted
+                let byte_start = range.start;
+                let byte_end = range.start + syntax_byte_len;
+                self.record_mapping(byte_start..byte_end, char_start..char_end);
+
+                // For paired inline syntax, track opening span for formatted_range
+                if matches!(
+                    tag,
+                    Tag::Strong | Tag::Emphasis | Tag::Strikethrough | Tag::Link { .. }
+                ) {
+                    self.pending_inline_formats.push((syn_id, char_start));
+                }
+
+                // Update tracking - we've consumed this opening syntax
+                self.last_char_offset = char_end;
+                self.last_byte_offset = range.start + syntax_byte_len;
+            }
+        }
+
+        // Emit the opening tag
+        match tag {
+            // HTML blocks get their own paragraph to try and corral them better
+            Tag::HtmlBlock => {
+                // Record paragraph start for boundary tracking
+                // BUT skip if inside a list - list owns the paragraph boundary
+                if self.list_depth == 0 {
+                    self.current_paragraph_start =
+                        Some((self.last_byte_offset, self.last_char_offset));
+                }
+                let node_id = self.gen_node_id();
+
+                if self.end_newline {
+                    write!(
+                        &mut self.writer,
+                        r#"<p id="{}" class="html-embed html-embed-block">"#,
+                        node_id
+                    )?;
+                } else {
+                    write!(
+                        &mut self.writer,
+                        r#"\n<p id="{}" class="html-embed html-embed-block">"#,
+                        node_id
+                    )?;
+                }
+                self.begin_node(node_id.clone());
+
+                // Map the start position of the paragraph (before any content)
+                // This allows cursor to be placed at the very beginning
+                let para_start_char = self.last_char_offset;
+                let mapping = OffsetMapping {
+                    byte_range: range.start..range.start,
+                    char_range: para_start_char..para_start_char,
+                    node_id,
+                    char_offset_in_node: 0,
+                    child_index: Some(0), // position before first child
+                    utf16_len: 0,
+                };
+                self.offset_maps.push(mapping);
+
+                Ok(())
+            }
+            Tag::Paragraph(_) => {
+                // Handle wrapper before block
+                self.emit_wrapper_start()?;
+
+                // Record paragraph start for boundary tracking
+                // BUT skip if inside a list - list owns the paragraph boundary
+                if self.list_depth == 0 {
+                    self.current_paragraph_start =
+                        Some((self.last_byte_offset, self.last_char_offset));
+                }
+
+                let node_id = self.gen_node_id();
+                if self.end_newline {
+                    write!(&mut self.writer, "<p id=\"{}\">", node_id)?;
+                } else {
+                    write!(&mut self.writer, "\n<p id=\"{}\">", node_id)?;
+                }
+                self.begin_node(node_id.clone());
+
+                // Map the start position of the paragraph (before any content)
+                // This allows cursor to be placed at the very beginning
+                let para_start_char = self.last_char_offset;
+                let mapping = OffsetMapping {
+                    byte_range: range.start..range.start,
+                    char_range: para_start_char..para_start_char,
+                    node_id,
+                    char_offset_in_node: 0,
+                    child_index: Some(0), // position before first child
+                    utf16_len: 0,
+                };
+                self.offset_maps.push(mapping);
+
+                // Emit > syntax if we're inside a blockquote
+                if let Some(bq_range) = self.pending_blockquote_range.take() {
+                    if bq_range.start < bq_range.end {
+                        let raw_text = &self.source[bq_range.clone()];
+                        if let Some(gt_pos) = raw_text.find('>') {
+                            // Extract > [!NOTE] or just >
+                            let after_gt = &raw_text[gt_pos + 1..];
+                            let syntax_end = if after_gt.trim_start().starts_with("[!") {
+                                // Find the closing ]
+                                if let Some(close_bracket) = after_gt.find(']') {
+                                    gt_pos + 1 + close_bracket + 1
+                                } else {
+                                    gt_pos + 1
+                                }
+                            } else {
+                                // Just > and maybe a space
+                                (gt_pos + 1).min(raw_text.len())
+                            };
+
+                            let syntax = &raw_text[gt_pos..syntax_end];
+                            let syntax_byte_start = bq_range.start + gt_pos;
+                            self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxType::Block)?;
+                        }
+                    }
+                }
+                Ok(())
+            }
+            Tag::Heading {
+                level,
+                id,
+                classes,
+                attrs,
+            } => {
+                // Emit wrapper if pending (but don't close on heading end - wraps following block too)
+                self.emit_wrapper_start()?;
+
+                // Record paragraph start for boundary tracking
+                // Treat headings as paragraph-level blocks
+                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+
+                if !self.end_newline {
+                    self.write("\n")?;
+                }
+
+                // Generate node ID for offset tracking
+                let node_id = self.gen_node_id();
+
+                self.write("<")?;
+                write!(&mut self.writer, "{}", level)?;
+
+                // Add our tracking ID as data attribute (preserve user's id if present)
+                self.write(" data-node-id=\"")?;
+                self.write(&node_id)?;
+                self.write("\"")?;
+
+                if let Some(id) = id {
+                    self.write(" id=\"")?;
+                    escape_html(&mut self.writer, &id)?;
+                    self.write("\"")?;
+                }
+                if !classes.is_empty() {
+                    self.write(" class=\"")?;
+                    for (i, class) in classes.iter().enumerate() {
+                        if i > 0 {
+                            self.write(" ")?;
+                        }
+                        escape_html(&mut self.writer, class)?;
+                    }
+                    self.write("\"")?;
+                }
+                for (attr, value) in attrs {
+                    self.write(" ")?;
+                    escape_html(&mut self.writer, &attr)?;
+                    if let Some(val) = value {
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, &val)?;
+                        self.write("\"")?;
+                    } else {
+                        self.write("=\"\"")?;
+                    }
+                }
+                self.write(">")?;
+
+                // Begin node tracking for offset mapping
+                self.begin_node(node_id.clone());
+
+                // Map the start position of the heading (before any content)
+                // This allows cursor to be placed at the very beginning
+                let heading_start_char = self.last_char_offset;
+                let mapping = OffsetMapping {
+                    byte_range: range.start..range.start,
+                    char_range: heading_start_char..heading_start_char,
+                    node_id: node_id.clone(),
+                    char_offset_in_node: 0,
+                    child_index: Some(0), // position before first child
+                    utf16_len: 0,
+                };
+                self.offset_maps.push(mapping);
+
+                // Emit # syntax inside the heading tag
+                if range.start < range.end {
+                    let raw_text = &self.source[range.clone()];
+                    let count = level as usize;
+                    let pattern = "#".repeat(count);
+
+                    // Find where the # actually starts (might have leading whitespace)
+                    if let Some(hash_pos) = raw_text.find(&pattern) {
+                        // Extract "# " or "## " etc
+                        let syntax_end = (hash_pos + count + 1).min(raw_text.len());
+                        let syntax = &raw_text[hash_pos..syntax_end];
+                        let syntax_byte_start = range.start + hash_pos;
+
+                        self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxType::Block)?;
+                    }
+                }
+                Ok(())
+            }
+            Tag::Table(alignments) => {
+                if self.render_tables_as_markdown {
+                    // Store start offset and skip HTML rendering
+                    self.table_start_offset = Some(range.start);
+                    self.in_non_writing_block = true; // Suppress content output
+                    Ok(())
+                } else {
+                    self.emit_wrapper_start()?;
+                    self.table_alignments = alignments;
+                    self.write("<table>")
+                }
+            }
+            Tag::TableHead => {
+                if self.render_tables_as_markdown {
+                    Ok(()) // Skip HTML rendering
+                } else {
+                    self.table_state = TableState::Head;
+                    self.table_cell_index = 0;
+                    self.write("<thead><tr>")
+                }
+            }
+            Tag::TableRow => {
+                if self.render_tables_as_markdown {
+                    Ok(()) // Skip HTML rendering
+                } else {
+                    self.table_cell_index = 0;
+                    self.write("<tr>")
+                }
+            }
+            Tag::TableCell => {
+                if self.render_tables_as_markdown {
+                    Ok(()) // Skip HTML rendering
+                } else {
+                    match self.table_state {
+                        TableState::Head => self.write("<th")?,
+                        TableState::Body => self.write("<td")?,
+                    }
+                    match self.table_alignments.get(self.table_cell_index) {
+                        Some(&Alignment::Left) => self.write(" style=\"text-align: left\">"),
+                        Some(&Alignment::Center) => self.write(" style=\"text-align: center\">"),
+                        Some(&Alignment::Right) => self.write(" style=\"text-align: right\">"),
+                        _ => self.write(">"),
+                    }
+                }
+            }
+            Tag::BlockQuote(kind) => {
+                self.emit_wrapper_start()?;
+
+                let class_str = match kind {
+                    None => "",
+                    Some(BlockQuoteKind::Note) => " class=\"markdown-alert-note\"",
+                    Some(BlockQuoteKind::Tip) => " class=\"markdown-alert-tip\"",
+                    Some(BlockQuoteKind::Important) => " class=\"markdown-alert-important\"",
+                    Some(BlockQuoteKind::Warning) => " class=\"markdown-alert-warning\"",
+                    Some(BlockQuoteKind::Caution) => " class=\"markdown-alert-caution\"",
+                };
+                if self.end_newline {
+                    write!(&mut self.writer, "<blockquote{}>\n", class_str)?;
+                } else {
+                    write!(&mut self.writer, "\n<blockquote{}>\n", class_str)?;
+                }
+
+                // Store range for emitting > inside the next paragraph
+                self.pending_blockquote_range = Some(range);
+                Ok(())
+            }
+            Tag::CodeBlock(info) => {
+                self.emit_wrapper_start()?;
+
+                // Track code block as paragraph-level block
+                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+
+                if !self.end_newline {
+                    self.write_newline()?;
+                }
+
+                // Generate node ID for code block
+                let node_id = self.gen_node_id();
+
+                match info {
+                    CodeBlockKind::Fenced(info) => {
+                        // Emit opening ```language and track both char and byte offsets
+                        if range.start < range.end {
+                            let raw_text = &self.source[range.clone()];
+                            if let Some(fence_pos) = raw_text.find("```") {
+                                let fence_end = (fence_pos + 3 + info.len()).min(raw_text.len());
+                                let syntax = &raw_text[fence_pos..fence_end];
+                                let syntax_char_len = syntax.chars().count() + 1; // +1 for newline
+                                let syntax_byte_len = syntax.len() + 1; // +1 for newline
+
+                                let syn_id = self.gen_syn_id();
+                                let char_start = self.last_char_offset;
+                                let char_end = char_start + syntax_char_len;
+
+                                write!(
+                                    &mut self.writer,
+                                    "<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("</span>\n")?;
+
+                                // Track opening span index for formatted_range update later
+                                self.code_block_opening_span_idx = Some(self.syntax_spans.len());
+                                self.code_block_char_start = Some(char_start);
+
+                                self.syntax_spans.push(SyntaxSpanInfo {
+                                    syn_id,
+                                    char_range: char_start..char_end,
+                                    syntax_type: SyntaxType::Block,
+                                    formatted_range: None, // Will be set in TagEnd::CodeBlock
+                                });
+
+                                self.last_char_offset += syntax_char_len;
+                                self.last_byte_offset = range.start + fence_pos + syntax_byte_len;
+                            }
+                        }
+
+                        let lang = info.split(' ').next().unwrap();
+                        let lang_opt = if lang.is_empty() {
+                            None
+                        } else {
+                            Some(lang.to_string())
+                        };
+                        // Start buffering
+                        self.code_buffer = Some((lang_opt, String::new()));
+
+                        // Begin node tracking for offset mapping
+                        self.begin_node(node_id);
+                        Ok(())
+                    }
+                    CodeBlockKind::Indented => {
+                        // Ignore indented code blocks (as per executive decision)
+                        self.code_buffer = Some((None, String::new()));
+
+                        // Begin node tracking for offset mapping
+                        self.begin_node(node_id);
+                        Ok(())
+                    }
+                }
+            }
+            Tag::List(Some(1)) => {
+                self.emit_wrapper_start()?;
+                // Track list as paragraph-level block
+                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                self.list_depth += 1;
+                if self.end_newline {
+                    self.write("<ol>\n")
+                } else {
+                    self.write("\n<ol>\n")
+                }
+            }
+            Tag::List(Some(start)) => {
+                self.emit_wrapper_start()?;
+                // Track list as paragraph-level block
+                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                self.list_depth += 1;
+                if self.end_newline {
+                    self.write("<ol start=\"")?;
+                } else {
+                    self.write("\n<ol start=\"")?;
+                }
+                write!(&mut self.writer, "{}", start)?;
+                self.write("\">\n")
+            }
+            Tag::List(None) => {
+                self.emit_wrapper_start()?;
+                // Track list as paragraph-level block
+                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                self.list_depth += 1;
+                if self.end_newline {
+                    self.write("<ul>\n")
+                } else {
+                    self.write("\n<ul>\n")
+                }
+            }
+            Tag::Item => {
+                // Generate node ID for list item
+                let node_id = self.gen_node_id();
+
+                if self.end_newline {
+                    write!(&mut self.writer, "<li data-node-id=\"{}\">", node_id)?;
+                } else {
+                    write!(&mut self.writer, "\n<li data-node-id=\"{}\">", node_id)?;
+                }
+
+                // Begin node tracking
+                self.begin_node(node_id);
+
+                // Emit list marker syntax inside the <li> tag and track both offsets
+                if range.start < range.end {
+                    let raw_text = &self.source[range.clone()];
+
+                    // Try to find the list marker (-, *, or digit.)
+                    let trimmed = raw_text.trim_start();
+                    let leading_ws_bytes = raw_text.len() - trimmed.len();
+                    let leading_ws_chars = raw_text.chars().count() - trimmed.chars().count();
+
+                    if let Some(marker) = trimmed.chars().next() {
+                        if marker == '-' || marker == '*' {
+                            // Unordered list: extract "- " or "* "
+                            let marker_end = trimmed
+                                .find(|c: char| c != '-' && c != '*')
+                                .map(|pos| pos + 1)
+                                .unwrap_or(1);
+                            let syntax = &trimmed[..marker_end.min(trimmed.len())];
+                            let char_start = self.last_char_offset;
+                            let syntax_char_len = leading_ws_chars + syntax.chars().count();
+                            let syntax_byte_len = leading_ws_bytes + syntax.len();
+                            let char_end = char_start + syntax_char_len;
+
+                            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=\"{}\" spellcheck=\"false\">",
+                                syn_id, char_start, char_end
+                            )?;
+                            escape_html(&mut self.writer, syntax)?;
+                            self.write("</span>")?;
+
+                            self.syntax_spans.push(SyntaxSpanInfo {
+                                syn_id,
+                                char_range: char_start..char_end,
+                                syntax_type: SyntaxType::Block,
+                                formatted_range: None,
+                            });
+
+                            // Record offset mapping for cursor positioning
+                            self.record_mapping(
+                                range.start..range.start + syntax_byte_len,
+                                char_start..char_end,
+                            );
+                            self.last_char_offset = char_end;
+                            self.last_byte_offset = range.start + syntax_byte_len;
+                        } else if marker.is_ascii_digit() {
+                            // Ordered list: extract "1. " or similar (including trailing space)
+                            if let Some(dot_pos) = trimmed.find('.') {
+                                let syntax_end = (dot_pos + 2).min(trimmed.len());
+                                let syntax = &trimmed[..syntax_end];
+                                let char_start = self.last_char_offset;
+                                let syntax_char_len = leading_ws_chars + syntax.chars().count();
+                                let syntax_byte_len = leading_ws_bytes + syntax.len();
+                                let char_end = char_start + syntax_char_len;
+
+                                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=\"{}\" spellcheck=\"false\">",
+                                    syn_id, char_start, char_end
+                                )?;
+                                escape_html(&mut self.writer, syntax)?;
+                                self.write("</span>")?;
+
+                                self.syntax_spans.push(SyntaxSpanInfo {
+                                    syn_id,
+                                    char_range: char_start..char_end,
+                                    syntax_type: SyntaxType::Block,
+                                    formatted_range: None,
+                                });
+
+                                // Record offset mapping for cursor positioning
+                                self.record_mapping(
+                                    range.start..range.start + syntax_byte_len,
+                                    char_start..char_end,
+                                );
+                                self.last_char_offset = char_end;
+                                self.last_byte_offset = range.start + syntax_byte_len;
+                            }
+                        }
+                    }
+                }
+                Ok(())
+            }
+            Tag::DefinitionList => {
+                self.emit_wrapper_start()?;
+                if self.end_newline {
+                    self.write("<dl>\n")
+                } else {
+                    self.write("\n<dl>\n")
+                }
+            }
+            Tag::DefinitionListTitle => {
+                let node_id = self.gen_node_id();
+
+                if self.end_newline {
+                    write!(&mut self.writer, "<dt data-node-id=\"{}\">", node_id)?;
+                } else {
+                    write!(&mut self.writer, "\n<dt data-node-id=\"{}\">", node_id)?;
+                }
+
+                self.begin_node(node_id);
+                Ok(())
+            }
+            Tag::DefinitionListDefinition => {
+                let node_id = self.gen_node_id();
+
+                if self.end_newline {
+                    write!(&mut self.writer, "<dd data-node-id=\"{}\">", node_id)?;
+                } else {
+                    write!(&mut self.writer, "\n<dd data-node-id=\"{}\">", node_id)?;
+                }
+
+                self.begin_node(node_id);
+                Ok(())
+            }
+            Tag::Subscript => self.write("<sub>"),
+            Tag::Superscript => self.write("<sup>"),
+            Tag::Emphasis => self.write("<em>"),
+            Tag::Strong => self.write("<strong>"),
+            Tag::Strikethrough => self.write("<s>"),
+            Tag::Link {
+                link_type: LinkType::Email,
+                dest_url,
+                title,
+                ..
+            } => {
+                self.write("<a href=\"mailto:")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Link {
+                link_type,
+                dest_url,
+                title,
+                ..
+            } => {
+                // 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=\"")?;
+                    escape_html(&mut self.writer, &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()];
+                let syn_id = self.gen_syn_id();
+                let opening_char_start = self.last_char_offset;
+
+                // Find the alt text and closing syntax positions
+                let paren_pos = raw_text.rfind("](").unwrap_or(raw_text.len());
+                let alt_text = if raw_text.starts_with("![") && paren_pos > 2 {
+                    &raw_text[2..paren_pos]
+                } else {
+                    ""
+                };
+                let closing_syntax = if paren_pos < raw_text.len() {
+                    &raw_text[paren_pos..]
+                } else {
+                    ""
+                };
+
+                // Calculate char positions
+                let alt_char_len = alt_text.chars().count();
+                let closing_char_len = closing_syntax.chars().count();
+                let opening_char_end = opening_char_start + 2; // "!["
+                let alt_char_start = opening_char_end;
+                let alt_char_end = alt_char_start + alt_char_len;
+                let closing_char_start = alt_char_end;
+                let closing_char_end = closing_char_start + closing_char_len;
+                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=\"{}\" spellcheck=\"false\">![</span>",
+                        syn_id, opening_char_start, opening_char_end
+                    )?;
+
+                    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()),
+                    });
+
+                    // Record offset mapping for ![
+                    self.record_mapping(
+                        range.start..range.start + 2,
+                        opening_char_start..opening_char_end,
+                    );
+                }
+
+                // 2. Emit alt text span (same syn_id, editable when visible)
+                if !alt_text.is_empty() {
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"image-alt\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        syn_id, alt_char_start, alt_char_end
+                    )?;
+                    escape_html(&mut self.writer, alt_text)?;
+                    self.write("</span>")?;
+
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id: syn_id.clone(),
+                        char_range: alt_char_start..alt_char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: Some(formatted_range.clone()),
+                    });
+
+                    // Record offset mapping for alt text
+                    self.record_mapping(
+                        range.start + 2..range.start + 2 + alt_text.len(),
+                        alt_char_start..alt_char_end,
+                    );
+                }
+
+                // 3. Emit closing ](url) syntax span
+                if !closing_syntax.is_empty() {
+                    write!(
+                        &mut self.writer,
+                        "<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)?;
+                    self.write("</span>")?;
+
+                    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()),
+                    });
+
+                    // Record offset mapping for ](url)
+                    self.record_mapping(
+                        range.start + paren_pos..range.end,
+                        closing_char_start..closing_char_end,
+                    );
+                }
+
+                // 4. Emit <img> element (no syn_id - always visible)
+                self.write("<img src=\"")?;
+                let resolved_url = self
+                    .image_resolver
+                    .as_ref()
+                    .and_then(|r| r.resolve_image_url(&dest_url));
+                if let Some(ref cdn_url) = resolved_url {
+                    escape_href(&mut self.writer, cdn_url)?;
+                } else {
+                    escape_href(&mut self.writer, &dest_url)?;
+                }
+                self.write("\" alt=\"")?;
+                escape_html(&mut self.writer, alt_text)?;
+                self.write("\"")?;
+                if !title.is_empty() {
+                    self.write(" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                    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 {
+                        self.write(" ")?;
+                        escape_html(&mut self.writer, attr)?;
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, value)?;
+                        self.write("\"")?;
+                    }
+                }
+                self.write(" />")?;
+
+                // Consume the text events for alt (they're still in the iterator)
+                // Use consume_until_end() since we already wrote alt text from source
+                self.consume_until_end();
+
+                // Update offsets
+                self.last_char_offset = closing_char_end;
+                self.last_byte_offset = range.end;
+
+                Ok(())
+            }
+            Tag::Embed {
+                embed_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => self.write_embed(range, embed_type, dest_url, title, id, attrs),
+            Tag::WeaverBlock(_, attrs) => {
+                self.in_non_writing_block = true;
+                self.weaver_block_buffer.clear();
+                self.weaver_block_char_start = Some(self.last_char_offset);
+                // Store attrs from Start tag, will merge with parsed text on End
+                if !attrs.classes.is_empty() || !attrs.attrs.is_empty() {
+                    self.pending_block_attrs = Some(attrs.into_static());
+                }
+                Ok(())
+            }
+            Tag::FootnoteDefinition(name) => {
+                // Emit the [^name]: prefix as a hideable syntax span
+                // The source should have "[^name]: " at the start
+                let prefix = format!("[^{}]: ", name);
+                let char_start = self.last_char_offset;
+                let prefix_char_len = prefix.chars().count();
+                let char_end = char_start + prefix_char_len;
+                let syn_id = self.gen_syn_id();
+
+                if !self.end_newline {
+                    self.write("\n")?;
+                }
+
+                write!(
+                    &mut self.writer,
+                    "<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, &prefix)?;
+                self.write("</span>")?;
+
+                // Track this span for linking with the footnote reference
+                let def_span_index = self.syntax_spans.len();
+                self.syntax_spans.push(SyntaxSpanInfo {
+                    syn_id,
+                    char_range: char_start..char_end,
+                    syntax_type: SyntaxType::Block,
+                    formatted_range: None, // Set at FootnoteDefinition end
+                });
+
+                // Store the definition info for linking at end
+                self.current_footnote_def = Some((name.to_string(), def_span_index, char_start));
+
+                // Record offset mapping for the syntax span
+                self.record_mapping(
+                    range.start..range.start + prefix.len(),
+                    char_start..char_end,
+                );
+
+                // Update tracking for the prefix
+                self.last_char_offset = char_end;
+                self.last_byte_offset = range.start + prefix.len();
+
+                // Emit the definition container
+                write!(
+                    &mut self.writer,
+                    "<div class=\"footnote-definition\" id=\"fn-{}\">",
+                    name
+                )?;
+
+                // Get/create footnote number for the label
+                let len = self.numbers.len() + 1;
+                let number = *self.numbers.entry(name.to_string()).or_insert(len);
+                write!(
+                    &mut self.writer,
+                    "<sup class=\"footnote-definition-label\">{}</sup>",
+                    number
+                )?;
+
+                Ok(())
+            }
+            Tag::MetadataBlock(_) => {
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+        }
+    }
+
+    pub(crate) fn end_tag(
+        &mut self,
+        tag: markdown_weaver::TagEnd,
+        range: Range<usize>,
+    ) -> Result<(), fmt::Error> {
+        use markdown_weaver::TagEnd;
+
+        // Emit tag HTML first
+        let result = match tag {
+            TagEnd::HtmlBlock => {
+                // Capture paragraph boundary info BEFORE writing closing HTML
+                // Skip if inside a list - list owns the paragraph boundary
+                let para_boundary = if self.list_depth == 0 {
+                    self.current_paragraph_start
+                        .take()
+                        .map(|(byte_start, char_start)| {
+                            (
+                                byte_start..self.last_byte_offset,
+                                char_start..self.last_char_offset,
+                            )
+                        })
+                } else {
+                    None
+                };
+
+                // Write closing HTML to current segment
+                self.end_node();
+                self.write("</p>\n")?;
+
+                // Now finalize paragraph (starts new segment)
+                if let Some((byte_range, char_range)) = para_boundary {
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+                Ok(())
+            }
+            TagEnd::Paragraph(_) => {
+                // Capture paragraph boundary info BEFORE writing closing HTML
+                // Skip if inside a list - list owns the paragraph boundary
+                let para_boundary = if self.list_depth == 0 {
+                    self.current_paragraph_start
+                        .take()
+                        .map(|(byte_start, char_start)| {
+                            (
+                                byte_start..self.last_byte_offset,
+                                char_start..self.last_char_offset,
+                            )
+                        })
+                } else {
+                    None
+                };
+
+                // Write closing HTML to current segment
+                self.end_node();
+                self.write("</p>\n")?;
+                self.close_wrapper()?;
+
+                // Now finalize paragraph (starts new segment)
+                if let Some((byte_range, char_range)) = para_boundary {
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+                Ok(())
+            }
+            TagEnd::Heading(level) => {
+                // Capture paragraph boundary info BEFORE writing closing HTML
+                let para_boundary =
+                    self.current_paragraph_start
+                        .take()
+                        .map(|(byte_start, char_start)| {
+                            (
+                                byte_start..self.last_byte_offset,
+                                char_start..self.last_char_offset,
+                            )
+                        });
+
+                // Write closing HTML to current segment
+                self.end_node();
+                self.write("</")?;
+                write!(&mut self.writer, "{}", level)?;
+                self.write(">\n")?;
+                // Note: Don't close wrapper here - headings typically go with following block
+
+                // Now finalize paragraph (starts new segment)
+                if let Some((byte_range, char_range)) = para_boundary {
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+                Ok(())
+            }
+            TagEnd::Table => {
+                if self.render_tables_as_markdown {
+                    // Emit the raw markdown table
+                    if let Some(start) = self.table_start_offset.take() {
+                        let table_text = &self.source[start..range.end];
+                        self.in_non_writing_block = false;
+
+                        // Wrap in a pre or div for styling
+                        self.write("<pre class=\"table-markdown\">")?;
+                        escape_html(&mut self.writer, table_text)?;
+                        self.write("</pre>\n")?;
+                    }
+                    Ok(())
+                } else {
+                    self.write("</tbody></table>\n")
+                }
+            }
+            TagEnd::TableHead => {
+                if self.render_tables_as_markdown {
+                    Ok(()) // Skip HTML rendering
+                } else {
+                    self.write("</tr></thead><tbody>\n")?;
+                    self.table_state = TableState::Body;
+                    Ok(())
+                }
+            }
+            TagEnd::TableRow => {
+                if self.render_tables_as_markdown {
+                    Ok(()) // Skip HTML rendering
+                } else {
+                    self.write("</tr>\n")
+                }
+            }
+            TagEnd::TableCell => {
+                if self.render_tables_as_markdown {
+                    Ok(()) // Skip HTML rendering
+                } else {
+                    match self.table_state {
+                        TableState::Head => self.write("</th>")?,
+                        TableState::Body => self.write("</td>")?,
+                    }
+                    self.table_cell_index += 1;
+                    Ok(())
+                }
+            }
+            TagEnd::BlockQuote(_) => {
+                // If pending_blockquote_range is still set, the blockquote was empty
+                // (no paragraph inside). Emit the > as its own minimal paragraph.
+                let mut para_boundary = None;
+                if let Some(bq_range) = self.pending_blockquote_range.take() {
+                    if bq_range.start < bq_range.end {
+                        let raw_text = &self.source[bq_range.clone()];
+                        if let Some(gt_pos) = raw_text.find('>') {
+                            let para_byte_start = bq_range.start + gt_pos;
+                            let para_char_start = self.last_char_offset;
+
+                            // Create a minimal paragraph for the empty blockquote
+                            let node_id = self.gen_node_id();
+                            write!(&mut self.writer, "<div id=\"{}\"", node_id)?;
+
+                            // Record start-of-node mapping for cursor positioning
+                            self.offset_maps.push(OffsetMapping {
+                                byte_range: para_byte_start..para_byte_start,
+                                char_range: para_char_start..para_char_start,
+                                node_id: node_id.clone(),
+                                char_offset_in_node: gt_pos,
+                                child_index: Some(0),
+                                utf16_len: 0,
+                            });
+
+                            // Emit the > as block syntax
+                            let syntax = &raw_text[gt_pos..gt_pos + 1];
+                            self.emit_inner_syntax(syntax, para_byte_start, SyntaxType::Block)?;
+
+                            self.write("</div>\n")?;
+                            self.end_node();
+
+                            // Capture paragraph boundary for later finalization
+                            let byte_range = para_byte_start..bq_range.end;
+                            let char_range = para_char_start..self.last_char_offset;
+                            para_boundary = Some((byte_range, char_range));
+                        }
+                    }
+                }
+                self.write("</blockquote>\n")?;
+                self.close_wrapper()?;
+
+                // Now finalize paragraph if we had one
+                if let Some((byte_range, char_range)) = para_boundary {
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+                Ok(())
+            }
+            TagEnd::CodeBlock => {
+                use std::sync::LazyLock;
+                use syntect::parsing::SyntaxSet;
+                static SYNTAX_SET: LazyLock<SyntaxSet> =
+                    LazyLock::new(|| SyntaxSet::load_defaults_newlines());
+
+                if let Some((lang, buffer)) = self.code_buffer.take() {
+                    // Create offset mapping for code block content if we tracked ranges
+                    if let (Some(code_byte_range), Some(code_char_range)) = (
+                        self.code_buffer_byte_range.take(),
+                        self.code_buffer_char_range.take(),
+                    ) {
+                        // Record mapping before writing HTML
+                        // (current_node_id should be set by start_tag for CodeBlock)
+                        self.record_mapping(code_byte_range, code_char_range);
+                    }
+
+                    // Get node_id for data-node-id attribute (needed for cursor positioning)
+                    let node_id = self.current_node_id.clone();
+
+                    if let Some(ref lang_str) = lang {
+                        // Use a temporary String buffer for syntect
+                        let mut temp_output = String::new();
+                        match weaver_renderer::code_pretty::highlight(
+                            &SYNTAX_SET,
+                            Some(lang_str),
+                            &buffer,
+                            &mut temp_output,
+                        ) {
+                            Ok(_) => {
+                                // Inject data-node-id into the <pre> tag for cursor positioning
+                                if let Some(ref nid) = node_id {
+                                    let injected = temp_output.replacen(
+                                        "<pre>",
+                                        &format!("<pre data-node-id=\"{}\">", nid),
+                                        1,
+                                    );
+                                    self.write(&injected)?;
+                                } else {
+                                    self.write(&temp_output)?;
+                                }
+                            }
+                            Err(_) => {
+                                // Fallback to plain code block
+                                if let Some(ref nid) = node_id {
+                                    write!(
+                                        &mut self.writer,
+                                        "<pre data-node-id=\"{}\"><code class=\"language-",
+                                        nid
+                                    )?;
+                                } else {
+                                    self.write("<pre><code class=\"language-")?;
+                                }
+                                escape_html(&mut self.writer, lang_str)?;
+                                self.write("\">")?;
+                                escape_html_body_text(&mut self.writer, &buffer)?;
+                                self.write("</code></pre>\n")?;
+                            }
+                        }
+                    } else {
+                        if let Some(ref nid) = node_id {
+                            write!(&mut self.writer, "<pre data-node-id=\"{}\"><code>", nid)?;
+                        } else {
+                            self.write("<pre><code>")?;
+                        }
+                        escape_html_body_text(&mut self.writer, &buffer)?;
+                        self.write("</code></pre>\n")?;
+                    }
+
+                    // End node tracking
+                    self.end_node();
+                } else {
+                    self.write("</code></pre>\n")?;
+                }
+
+                // Emit closing ``` (emit_gap_before is skipped while buffering)
+                // Track the opening span index and char start before we potentially clear them
+                let opening_span_idx = self.code_block_opening_span_idx.take();
+                let code_block_start = self.code_block_char_start.take();
+
+                if range.start < range.end {
+                    let raw_text = &self.source[range.clone()];
+                    if let Some(fence_line) = raw_text.lines().last() {
+                        if fence_line.trim().starts_with("```") {
+                            let fence = fence_line.trim();
+                            let fence_char_len = fence.chars().count();
+
+                            let syn_id = self.gen_syn_id();
+                            let char_start = self.last_char_offset;
+                            let char_end = char_start + fence_char_len;
+
+                            write!(
+                                &mut self.writer,
+                                "<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)?;
+                            self.write("</span>")?;
+
+                            self.last_char_offset += fence_char_len;
+                            self.last_byte_offset += fence.len();
+
+                            // Compute formatted_range for entire code block (opening fence to closing fence)
+                            let formatted_range =
+                                code_block_start.map(|start| start..self.last_char_offset);
+
+                            // Update opening fence span with formatted_range
+                            if let (Some(idx), Some(fr)) =
+                                (opening_span_idx, formatted_range.as_ref())
+                            {
+                                if let Some(span) = self.syntax_spans.get_mut(idx) {
+                                    span.formatted_range = Some(fr.clone());
+                                }
+                            }
+
+                            // Push closing fence span with formatted_range
+                            self.syntax_spans.push(SyntaxSpanInfo {
+                                syn_id,
+                                char_range: char_start..char_end,
+                                syntax_type: SyntaxType::Block,
+                                formatted_range,
+                            });
+                        }
+                    }
+                }
+
+                // Finalize code block paragraph
+                if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
+                    let byte_range = byte_start..self.last_byte_offset;
+                    let char_range = char_start..self.last_char_offset;
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+
+                Ok(())
+            }
+            TagEnd::List(true) => {
+                self.list_depth = self.list_depth.saturating_sub(1);
+                // Capture paragraph boundary BEFORE writing closing HTML
+                let para_boundary =
+                    self.current_paragraph_start
+                        .take()
+                        .map(|(byte_start, char_start)| {
+                            (
+                                byte_start..self.last_byte_offset,
+                                char_start..self.last_char_offset,
+                            )
+                        });
+
+                self.write("</ol>\n")?;
+                self.close_wrapper()?;
+
+                // Finalize paragraph after closing HTML
+                if let Some((byte_range, char_range)) = para_boundary {
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+                Ok(())
+            }
+            TagEnd::List(false) => {
+                self.list_depth = self.list_depth.saturating_sub(1);
+                // Capture paragraph boundary BEFORE writing closing HTML
+                let para_boundary =
+                    self.current_paragraph_start
+                        .take()
+                        .map(|(byte_start, char_start)| {
+                            (
+                                byte_start..self.last_byte_offset,
+                                char_start..self.last_char_offset,
+                            )
+                        });
+
+                self.write("</ul>\n")?;
+                self.close_wrapper()?;
+
+                // Finalize paragraph after closing HTML
+                if let Some((byte_range, char_range)) = para_boundary {
+                    self.finalize_paragraph(byte_range, char_range);
+                }
+                Ok(())
+            }
+            TagEnd::Item => {
+                self.end_node();
+                self.write("</li>\n")
+            }
+            TagEnd::DefinitionList => {
+                self.write("</dl>\n")?;
+                self.close_wrapper()
+            }
+            TagEnd::DefinitionListTitle => {
+                self.end_node();
+                self.write("</dt>\n")
+            }
+            TagEnd::DefinitionListDefinition => {
+                self.end_node();
+                self.write("</dd>\n")
+            }
+            TagEnd::Emphasis => {
+                // Write closing tag FIRST, then emit closing syntax OUTSIDE the tag
+                self.write("</em>")?;
+                self.emit_gap_before(range.end)?;
+                self.finalize_paired_inline_format();
+                Ok(())
+            }
+            TagEnd::Superscript => self.write("</sup>"),
+            TagEnd::Subscript => self.write("</sub>"),
+            TagEnd::Strong => {
+                // Write closing tag FIRST, then emit closing syntax OUTSIDE the tag
+                self.write("</strong>")?;
+                self.emit_gap_before(range.end)?;
+                self.finalize_paired_inline_format();
+                Ok(())
+            }
+            TagEnd::Strikethrough => {
+                // Write closing tag FIRST, then emit closing syntax OUTSIDE the tag
+                self.write("</s>")?;
+                self.emit_gap_before(range.end)?;
+                self.finalize_paired_inline_format();
+                Ok(())
+            }
+            TagEnd::Link => {
+                self.write("</a>")?;
+                // Check if this is a wiki link (ends with ]]) vs regular link (ends with ))
+                let raw_text = &self.source[range.clone()];
+                if raw_text.ends_with("]]") {
+                    // WikiLink: emit ]] as closing syntax
+                    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=\"{}\" spellcheck=\"false\">]]</span>",
+                        syn_id, char_start, char_end
+                    )?;
+
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None, // Will be set by finalize
+                    });
+
+                    self.last_char_offset = char_end;
+                    self.last_byte_offset = range.end;
+                } else {
+                    self.emit_gap_before(range.end)?;
+                }
+                self.finalize_paired_inline_format();
+                Ok(())
+            }
+            TagEnd::Image => Ok(()), // No-op: raw_text() already consumed the End(Image) event
+            TagEnd::Embed => Ok(()),
+            TagEnd::WeaverBlock(_) => {
+                self.in_non_writing_block = false;
+
+                // Emit the { content } as a hideable syntax span
+                if let Some(char_start) = self.weaver_block_char_start.take() {
+                    // Build the full syntax text: { buffered_content }
+                    let syntax_text = format!("{{{}}}", self.weaver_block_buffer);
+                    let syntax_char_len = syntax_text.chars().count();
+                    let char_end = char_start + syntax_char_len;
+
+                    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=\"{}\" spellcheck=\"false\">",
+                        syn_id, char_start, char_end
+                    )?;
+                    escape_html(&mut self.writer, &syntax_text)?;
+                    self.write("</span>")?;
+
+                    // Track the syntax span
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Block,
+                        formatted_range: None,
+                    });
+
+                    // Record offset mapping for the syntax span
+                    self.record_mapping(range.clone(), char_start..char_end);
+
+                    // Update tracking
+                    self.last_char_offset = char_end;
+                    self.last_byte_offset = range.end;
+                }
+
+                // Parse the buffered text for attrs and store for next block
+                if !self.weaver_block_buffer.is_empty() {
+                    let parsed = Self::parse_weaver_attrs(&self.weaver_block_buffer);
+                    self.weaver_block_buffer.clear();
+                    // Merge with any existing pending attrs or set new
+                    if let Some(ref mut existing) = self.pending_block_attrs {
+                        existing.classes.extend(parsed.classes);
+                        existing.attrs.extend(parsed.attrs);
+                    } else {
+                        self.pending_block_attrs = Some(parsed);
+                    }
+                }
+
+                Ok(())
+            }
+            TagEnd::FootnoteDefinition => {
+                self.write("</div>\n")?;
+
+                // Link the footnote definition span with its reference span
+                if let Some((name, def_span_index, _def_char_start)) =
+                    self.current_footnote_def.take()
+                {
+                    let def_char_end = self.last_char_offset;
+
+                    // Look up the reference span
+                    if let Some(&(ref_span_index, ref_char_start)) =
+                        self.footnote_ref_spans.get(&name)
+                    {
+                        // Create formatted_range spanning from ref start to def end
+                        let formatted_range = ref_char_start..def_char_end;
+
+                        // Update both spans with the same formatted_range
+                        // so they show/hide together based on cursor proximity
+                        if let Some(ref_span) = self.syntax_spans.get_mut(ref_span_index) {
+                            ref_span.formatted_range = Some(formatted_range.clone());
+                        }
+                        if let Some(def_span) = self.syntax_spans.get_mut(def_span_index) {
+                            def_span.formatted_range = Some(formatted_range);
+                        }
+                    }
+                }
+
+                Ok(())
+            }
+            TagEnd::MetadataBlock(_) => {
+                self.in_non_writing_block = false;
+                Ok(())
+            }
+        };
+
+        result?;
+
+        // Note: Closing syntax for inline formatting tags (Strong, Emphasis, Strikethrough)
+        // is handled INSIDE their respective match arms above, AFTER writing the closing HTML.
+        // This ensures the closing syntax span appears OUTSIDE the formatted element.
+        // Other End events have their closing syntax emitted by emit_gap_before() in the main loop.
+
+        Ok(())
+    }
+}

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

···
 
     tracing::info!("Entry: {book_title} - {title}");
 
-    let prev_entry = book_entry_view().prev.clone();
-    let next_entry = book_entry_view().next.clone();
-
     rsx! {
         EntryOgMeta {
             title: title.to_string(),
···
         div { class: "entry-page",
             // Header: nav prev + metadata + nav next
             header { class: "entry-header",
-                if let Some(ref prev) = prev_entry {
+                if let Some(ref prev) = book_entry_view().prev {
                     NavButton {
                         direction: "prev",
                         entry: prev.entry.clone(),
                         ident: ident(),
                         book_title: book_title()
                     }
+                } else {
+                    div { class: "nav-placeholder" }
                 }
 
                 {
···
                     }
                 }
 
-                if let Some(ref next) = next_entry {
+                if let Some(ref next) = book_entry_view().next {
                     NavButton {
                         direction: "next",
                         entry: next.entry.clone(),
                         ident: ident(),
                         book_title: book_title()
                     }
+                } else {
+                    div { class: "nav-placeholder" }
                 }
             }
 
···
 
             // Footer navigation
             footer { class: "entry-footer-nav",
-                if let Some(ref prev) = prev_entry {
+                if let Some(ref prev) = book_entry_view().prev {
                     NavButton {
                         direction: "prev",
                         entry: prev.entry.clone(),
···
                     }
                 }
 
-                if let Some(ref next) = next_entry {
+                if let Some(ref next) = book_entry_view().next {
                     NavButton {
                         direction: "next",
                         entry: next.entry.clone(),
···
 
 /// Render some text as markdown.
 pub fn EntryMarkdown(props: EntryMarkdownProps) -> Element {
-    let (_res, processed) = crate::data::use_rendered_markdown(props.content, props.ident);
+    let (mut _res, processed) = crate::data::use_rendered_markdown(props.content, props.ident);
+
+    // Track entry title to detect content change and restart resource
+    let mut last_title = use_signal(|| (props.content)().title.to_string());
+    let current_title = (props.content)().title.to_string();
+    if current_title != last_title() {
+        #[cfg(feature = "fullstack-server")]
+        if let Ok(ref mut r) = _res {
+            r.restart();
+        }
+        last_title.set(current_title);
+    }
+
     #[cfg(feature = "fullstack-server")]
     _res?;
 

crates/weaver-app/src/data.rs

···
 ) -> (Resource<Option<String>>, Memo<Option<String>>) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
-    let res = use_resource(move || {
+    let res = use_resource(use_reactive!(|(content, ident)| {
         let fetcher = fetcher.clone();
         async move {
             let entry = content();
···
 
             Some(render_markdown_impl(entry, did, resolved_content).await)
         }
-    });
-    let memo = use_memo(move || {
+    }));
+    let memo = use_memo(use_reactive!(|res| {
         if let Some(Some(value)) = &*res.read() {
             Some(value.clone())
         } else {
             None
         }
-    });
+    }));
     (res, memo)
 }
 

crates/weaver-index/src/endpoints/notebook.rs

···
         .maybe_path(non_empty_cowstr(&notebook_row.path))
         .build();
 
-    // Build entry views
-    let mut entries: Vec<BookEntryView<'static>> = Vec::with_capacity(entry_rows.len());
-    for (idx, entry_row) in entry_rows.iter().enumerate() {
+    // Build entry views (first pass: create EntryViews)
+    let mut entry_views: Vec<EntryView<'static>> = Vec::with_capacity(entry_rows.len());
+    for entry_row in entry_rows.iter() {
         let entry_uri = AtUri::new(&entry_row.uri).map_err(|e| {
             tracing::error!("Invalid entry URI in db: {}", e);
             XrpcErrorResponse::internal_error("Invalid URI stored")
···
             .maybe_path(non_empty_cowstr(&entry_row.path))
             .build();
 
-        let book_entry = BookEntryView::new()
-            .entry(entry_view)
-            .index(idx as i64)
-            .build();
+        entry_views.push(entry_view);
+    }
 
-        entries.push(book_entry);
+    // Build BookEntryViews with prev/next navigation
+    let mut entries: Vec<BookEntryView<'static>> = Vec::with_capacity(entry_views.len());
+    for (idx, entry_view) in entry_views.iter().enumerate() {
+        let prev = (idx > 0)
+            .then(|| BookEntryRef::new().entry(entry_views[idx - 1].clone()).build());
+        let next = entry_views
+            .get(idx + 1)
+            .map(|e| BookEntryRef::new().entry(e.clone()).build());
+
+        entries.push(
+            BookEntryView::new()
+                .entry(entry_view.clone())
+                .index(idx as i64)
+                .maybe_prev(prev)
+                .maybe_next(next)
+                .build(),
+        );
     }
 
     // Build cursor for pagination (position-based)

crates/weaver-renderer/src/css.rs

···
     color: var(--color-primary);
 }}
 
-/* Aside blocks (via WeaverBlock prefix) */
-aside, .aside {{
+/* Aside blocks (via WeaverBlock prefix) - scoped to notebook content */
+.notebook-content aside,
+.notebook-content .aside {{
     float: left;
     width: 40%;
     margin: 0 1.5rem 1rem 0;
···
     clear: left;
 }}
 
-aside > *:first-child,
-.aside > *:first-child {{
+.notebook-content aside > *:first-child,
+.notebook-content .aside > *:first-child {{
     margin-top: 0;
 }}
 
-aside > *:last-child,
-.aside > *:last-child {{
+.notebook-content aside > *:last-child,
+.notebook-content .aside > *:last-child {{
     margin-bottom: 0;
 }}
 
 /* Reset blockquote styling inside asides */
-aside > blockquote,
-.aside > blockquote {{
+.notebook-content aside > blockquote,
+.notebook-content .aside > blockquote {{
     border-left: none;
     background: transparent;
     padding: 0;

test-sidenotes.html

···
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>test-sidenotes</title>
+  <style>
+/* CSS Reset */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* CSS Variables - Light Mode (default) */
+:root {
+    --color-base: #faf4ed;
+    --color-surface: #fffaf3;
+    --color-overlay: #f2e9e1;
+    --color-text: #1f1d2e;
+    --color-muted: #635e74;
+    --color-subtle: #4a4560;
+    --color-emphasis: #1e1a2d;
+    --color-primary: #907aa9;
+    --color-secondary: #56949f;
+    --color-tertiary: #286983;
+    --color-error: #b4637a;
+    --color-warning: #ea9d34;
+    --color-success: #286983;
+    --color-border: #dfdad9;
+    --color-link: #d7827e;
+    --color-highlight: #cecacd;
+
+    --font-body: 'Adobe Caslon Pro','Latin Modern Roman','Times New Roman','serif';
+    --font-heading: 'IBM Plex Sans','system-ui','sans-serif';
+    --font-mono: 'Ioskeley Mono','IBM Plex Mono','Berkeley Mono','Consolas','monospace';
+
+    --spacing-base: 16px;
+    --spacing-line-height: 1.6;
+    --spacing-scale: 1.25;
+}
+
+/* CSS Variables - Dark Mode */
+@media (prefers-color-scheme: dark) {
+    :root {
+        --color-base: #191724;
+        --color-surface: #1f1d2e;
+        --color-overlay: #26233a;
+        --color-text: #e0def4;
+        --color-muted: #6e6a86;
+        --color-subtle: #908caa;
+        --color-emphasis: #e0def4;
+        --color-primary: #c4a7e7;
+        --color-secondary: #9ccfd8;
+        --color-tertiary: #ebbcba;
+        --color-error: #eb6f92;
+        --color-warning: #f6c177;
+        --color-success: #31748f;
+        --color-border: #403d52;
+        --color-link: #ebbcba;
+        --color-highlight: #524f67;
+    }
+}
+
+/* Base Styles */
+html {
+    font-size: var(--spacing-base);
+    line-height: var(--spacing-line-height);
+}
+
+/* Scoped to notebook-content container */
+.notebook-content {
+    font-family: var(--font-body);
+    color: var(--color-text);
+    background-color: var(--color-base);
+    margin: 0 auto;
+    padding: 1rem 0rem;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    counter-reset: sidenote-counter;
+    max-width: 95ch;
+}
+
+/* When sidenotes exist, body padding creates the gutter */
+/* Left padding shrinks first as viewport narrows, right stays for sidenotes */
+body:has(.sidenote) {
+    padding-left: clamp(0rem, calc((100vw - 95ch - 15.5rem - 2rem) / 2), 15.5rem);
+    padding-right: 15.5rem;
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6 {
+    font-family: var(--font-heading);
+    margin-top: calc(1rem * var(--spacing-scale));
+    margin-bottom: 0.5rem;
+    line-height: 1.2;
+}
+
+h1 {
+  font-size: 2rem;
+  color: var(--color-secondary);
+}
+h2 {
+  font-size: 1.5rem;
+  color: var(--color-primary);
+}
+h3 {
+  font-size: 1.25rem;
+  color: var(--color-secondary);
+}
+h4 {
+  font-size: 1.2rem;
+  color: var(--color-tertiary);
+}
+h5 {
+  font-size: 1.125rem;
+  color: var(--color-secondary);
+}
+h6 { font-size: 1rem; }
+
+p {
+    margin-bottom: 1rem;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+
+a {
+    color: var(--color-link);
+    text-decoration: none;
+}
+
+.notebook-content a:hover {
+    color: var(--color-emphasis);
+    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);
+    color: var(--color-text);
+}
+
+/* Lists */
+ul, ol {
+    margin-left: 1rem;
+    margin-bottom: 1rem;
+}
+
+li {
+    margin-bottom: 0.25rem;
+}
+
+/* Code */
+code {
+    font-family: var(--font-mono);
+    background: var(--color-surface);
+    padding: 0.125rem 0.25rem;
+    border-radius: 4px;
+    font-size: 0.9em;
+}
+
+pre {
+    overflow-x: auto;
+    margin-bottom: 1rem;
+    border-radius: 5px;
+    border: 1px solid var(--color-border);
+    box-sizing: border-box;
+}
+
+/* Code blocks inside pre are handled by syntax theme */
+pre code {
+
+    display: block;
+    width: fit-content;
+    min-width: 100%;
+    padding: 1rem;
+    background: var(--color-surface);
+}
+
+/* Math */
+.math {
+    font-family: var(--font-mono);
+}
+
+.math-display {
+    display: block;
+    margin: 1rem 0;
+    text-align: center;
+}
+
+/* Blockquotes */
+blockquote {
+    border-left: 2px solid var(--color-secondary);
+    background: var(--color-surface);
+    padding-left: 1rem;
+    padding-right: 1rem;
+    padding-top: 0.5rem;
+    padding-bottom: 0.04rem;
+    margin: 1rem 0;
+    font-size: 0.95em;
+    border-bottom-right-radius: 5px;
+    border-top-right-radius: 5px;
+}
+}
+
+/* Tables */
+table {
+    border-collapse: collapse;
+    width: 100%;
+    margin-bottom: 1rem;
+    display: block;
+    overflow-x: auto;
+    max-width: 100%;
+}
+
+th, td {
+    border: 1px solid var(--color-border);
+    padding: 0.5rem;
+    text-align: left;
+}
+
+th {
+    background: var(--color-surface);
+    font-weight: 600;
+}
+
+tr:hover {
+    background: var(--color-surface);
+}
+
+/* Footnotes */
+.footnote-reference {
+    font-size: 0.8em;
+    color: var(--color-subtle);
+}
+
+.footnote-definition {
+    order: 9999;
+    margin: 0;
+    padding: 0.5rem 0;
+    font-size: 0.9em;
+}
+
+.footnote-definition:first-of-type {
+    margin-top: 2rem;
+    padding-top: 1rem;
+    border-top: 2px solid var(--color-border);
+}
+
+.footnote-definition:first-of-type::before {
+    content: "Footnotes";
+    display: block;
+    font-weight: 600;
+    font-size: 1.1em;
+    color: var(--color-subtle);
+    margin-bottom: 0.75rem;
+}
+
+.footnote-definition-label {
+    font-weight: 600;
+    margin-right: 0.5rem;
+    color: var(--color-primary);
+}
+
+/* Aside blocks (via WeaverBlock prefix) - scoped to notebook content */
+.notebook-content aside,
+.notebook-content .aside {
+    float: left;
+    width: 40%;
+    margin: 0 1.5rem 1rem 0;
+    padding: 1rem;
+    background: var(--color-surface);
+    border-right: 3px solid var(--color-primary);
+    font-size: 0.9em;
+    clear: left;
+}
+
+.notebook-content aside > *:first-child,
+.notebook-content .aside > *:first-child {
+    margin-top: 0;
+}
+
+.notebook-content aside > *:last-child,
+.notebook-content .aside > *:last-child {
+    margin-bottom: 0;
+}
+
+/* Reset blockquote styling inside asides */
+.notebook-content aside > blockquote,
+.notebook-content .aside > blockquote {
+    border-left: none;
+    background: transparent;
+    padding: 0;
+    margin: 0;
+    font-size: inherit;
+}
+
+/* Indent utilities */
+.indent-1 { margin-left: 1em; }
+.indent-2 { margin-left: 2em; }
+.indent-3 { margin-left: 3em; }
+
+/* Tufte-style Sidenotes */
+/* Hide checkbox for sidenote toggle */
+.margin-toggle {
+    display: none;
+}
+
+/* Sidenote number marker (inline superscript) */
+.sidenote-number {
+    counter-increment: sidenote-counter;
+}
+
+.sidenote-number::after {
+    content: counter(sidenote-counter);
+    font-size: 0.7em;
+    position: relative;
+    top: -0.5em;
+    color: var(--color-primary);
+    padding-left: 0.1em;
+}
+
+/* Sidenote content (margin notes on wide screens) */
+.sidenote {
+    float: right;
+    clear: right;
+    margin-right: -15.5rem;
+    width: 14rem;
+    margin-top: 0.3rem;
+    margin-bottom: 1rem;
+    font-size: 0.85em;
+    line-height: 1.4;
+    color: var(--color-subtle);
+}
+
+.sidenote::before {
+    content: counter(sidenote-counter) ". ";
+    color: var(--color-primary);
+}
+
+/* Mobile sidenotes: toggle behavior */
+@media (max-width: 900px) {
+    /* Reset sidenote gutter on mobile */
+    body:has(.sidenote) {
+        padding-right: 0;
+    }
+
+    aside, .aside {
+        float: none;
+        width: 100%;
+        margin: 1rem 0;
+    }
+
+    .sidenote {
+        display: none;
+    }
+
+    .margin-toggle:checked + .sidenote {
+        display: block;
+        float: none;
+        width: 95%;
+        margin: 0.5rem 2.5%;
+        padding: 0.5rem;
+        background: var(--color-surface);
+        border-left: 2px solid var(--color-primary);
+    }
+
+    label.sidenote-number {
+        cursor: pointer;
+    }
+
+    label.sidenote-number::after {
+        text-decoration: underline;
+    }
+}
+
+/* Images */
+img {
+    max-width: 100%;
+    height: auto;
+    display: block;
+    margin: 1rem 0;
+    border-radius: 4px;
+}
+
+/* Hygiene for iframes */
+.html-embed-block {
+    max-width: 100%;
+    height: auto;
+    display: block;
+    margin: 1rem 0;
+}
+
+/* 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;
+    padding-bottom: 0.5rem;
+}
+
+.embed-avatar {
+    width: 36px;
+    height: 36px;
+    max-width: 36px;
+    max-height: 36px;
+    aspect-ratio: 1;
+    margin: 0;
+    object-fit: cover;
+}
+
+.embed-author-info {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    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;
+    line-height: 1.2;
+}
+
+a.embed-author-name:hover {
+    color: var(--color-link);
+}
+
+.embed-author-handle {
+    font-size: 0.85em;
+    font-family: var(--font-mono);
+    color: var(--color-subtle);
+    text-decoration: none;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    line-height: 1.2;
+}
+
+.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;
+    max-width: 24px;
+    max-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-family: var(--font-ui);
+    font-size: 0.85rem;
+    color: var(--color-muted);
+}
+
+.embed-field {
+    display: block;
+    margin-top: 0.25rem;
+}
+
+/* Nested fields get indentation */
+.embed-fields .embed-fields {
+    display: block;
+    margin-top: 0.5rem;
+    margin-left: 1rem;
+    padding-left: 0.5rem;
+    border-left: 1px solid var(--color-border);
+}
+
+/* Type label inside fields should be block with spacing */
+.embed-fields > .embed-author-handle {
+    display: block;
+    margin-bottom: 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;
+}
+
+.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;
+    font-family: var(--font-ui);
+    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 */
+hr {
+    border: none;
+    border-top: 2px solid var(--color-border);
+    margin: 2rem 0;
+}
+
+/* Tablet and mobile responsiveness */
+@media (max-width: 900px) {
+    .notebook-content {
+        padding: 1.5rem 1rem;
+        max-width: 100%;
+    }
+
+    h1 { font-size: 1.85rem; }
+    h2 { font-size: 1.4rem; }
+    h3 { font-size: 1.2rem; }
+
+    blockquote {
+        margin-left: 0;
+        margin-right: 0;
+    }
+}
+
+/* Small mobile phones */
+@media (max-width: 480px) {
+    .notebook-content {
+        padding: 1rem 0.75rem;
+    }
+
+    h1 { font-size: 1.65rem; }
+    h2 { font-size: 1.3rem; }
+    h3 { font-size: 1.1rem; }
+
+    blockquote {
+        padding-left: 0.75rem;
+        padding-right: 0.75rem;
+    }
+}
+  </style>
+  <style>
+/* Syntax highlighting - Light Mode (default) */
+/*
+ * theme "Rosé Pine Dawn" generated by syntect
+ */
+
+.wvc-code {
+ color: #575279;
+ background-color: #faf4ed;
+}
+
+.wvc-comment {
+ color: #797593;
+font-style: italic;
+}
+.wvc-string, .wvc-punctuation.wvc-definition.wvc-string {
+ color: #ea9d34;
+}
+.wvc-constant.wvc-numeric {
+ color: #ea9d34;
+}
+.wvc-constant.wvc-language {
+ color: #ea9d34;
+font-weight: bold;
+}
+.wvc-constant.wvc-character, .wvc-constant.wvc-other {
+ color: #ea9d34;
+}
+.wvc-variable {
+ color: #575279;
+font-style: italic;
+}
+.wvc-keyword {
+ color: #286983;
+}
+.wvc-storage {
+ color: #56949f;
+}
+.wvc-storage.wvc-type {
+ color: #56949f;
+}
+.wvc-entity.wvc-name.wvc-class {
+ color: #286983;
+font-weight: bold;
+}
+.wvc-entity.wvc-other.wvc-inherited-class {
+ color: #286983;
+font-style: italic;
+}
+.wvc-entity.wvc-name.wvc-function {
+ color: #d7827e;
+font-style: italic;
+}
+.wvc-variable.wvc-parameter {
+ color: #907aa9;
+}
+.wvc-entity.wvc-name.wvc-tag {
+ color: #286983;
+font-weight: bold;
+}
+.wvc-entity.wvc-other.wvc-attribute-name {
+ color: #907aa9;
+}
+.wvc-support.wvc-function {
+ color: #d7827e;
+font-weight: bold;
+}
+.wvc-support.wvc-constant {
+ color: #ea9d34;
+font-weight: bold;
+}
+.wvc-support.wvc-type, .wvc-support.wvc-class {
+ color: #56949f;
+font-weight: bold;
+}
+.wvc-support.wvc-other.wvc-variable {
+ color: #b4637a;
+font-weight: bold;
+}
+.wvc-invalid {
+ color: #575279;
+ background-color: #b4637a;
+}
+.wvc-invalid.wvc-deprecated {
+ color: #575279;
+ background-color: #907aa9;
+}
+.wvc-punctuation, .wvc-keyword.wvc-operator {
+ color: #797593;
+}
+
+
+/* Syntax highlighting - Dark Mode */
+@media (prefers-color-scheme: dark) {
+/*
+ * theme "Rosé Pine" generated by syntect
+ */
+
+.wvc-code {
+ color: #e0def4;
+ background-color: #191724;
+}
+
+.wvc-comment {
+ color: #908caa;
+font-style: italic;
+}
+.wvc-string, .wvc-punctuation.wvc-definition.wvc-string {
+ color: #f6c177;
+}
+.wvc-constant.wvc-numeric {
+ color: #f6c177;
+}
+.wvc-constant.wvc-language {
+ color: #f6c177;
+font-weight: bold;
+}
+.wvc-constant.wvc-character, .wvc-constant.wvc-other {
+ color: #f6c177;
+}
+.wvc-variable {
+ color: #e0def4;
+font-style: italic;
+}
+.wvc-keyword {
+ color: #31748f;
+}
+.wvc-storage {
+ color: #9ccfd8;
+}
+.wvc-storage.wvc-type {
+ color: #9ccfd8;
+}
+.wvc-entity.wvc-name.wvc-class {
+ color: #31748f;
+font-weight: bold;
+}
+.wvc-entity.wvc-other.wvc-inherited-class {
+ color: #31748f;
+font-style: italic;
+}
+.wvc-entity.wvc-name.wvc-function {
+ color: #ebbcba;
+font-style: italic;
+}
+.wvc-variable.wvc-parameter {
+ color: #c4a7e7;
+}
+.wvc-entity.wvc-name.wvc-tag {
+ color: #31748f;
+font-weight: bold;
+}
+.wvc-entity.wvc-other.wvc-attribute-name {
+ color: #c4a7e7;
+}
+.wvc-support.wvc-function {
+ color: #ebbcba;
+font-weight: bold;
+}
+.wvc-support.wvc-constant {
+ color: #f6c177;
+font-weight: bold;
+}
+.wvc-support.wvc-type, .wvc-support.wvc-class {
+ color: #9ccfd8;
+font-weight: bold;
+}
+.wvc-support.wvc-other.wvc-variable {
+ color: #eb6f92;
+font-weight: bold;
+}
+.wvc-invalid {
+ color: #e0def4;
+ background-color: #eb6f92;
+}
+.wvc-invalid.wvc-deprecated {
+ color: #e0def4;
+ background-color: #c4a7e7;
+}
+.wvc-punctuation, .wvc-keyword.wvc-operator {
+ color: #908caa;
+}
+}
+  </style>
+</head>
+<body style="background: var(--color-base); min-height: 100vh;">
+<div class="notebook-content">
+<h1>Weaver: Long-form Writing on AT Protocol</h1>
+<p><em>Or: "Get in kid, we're rebuilding the blogosphere!"</em></p>
+<p>I grew up, like a lot of people on Bluesky, in the era of the internet where most of your online social interactions took place via text. I had a MySpace account, MSN messenger and Google Chat, I first got on Facebook back when they required a school email to sign up, I had a Tumblr, though not a LiveJournal.<label for="sn-1" class="sidenote-number"></label><input type="checkbox" id="sn-1" class="margin-toggle"/><span class="sidenote">Hi Rahaeli. Sorry I was the wrong kind of nerd.</span></p>
+<blockquote>
+<p><img src="weaver_photo_med.jpg" alt="weaver_photo_med.jpg" /><em>The namesake of what I'm building</em></p>
+</blockquote>
+<p>Social media in the conventional sense has been in a lot of ways a small part of the story of my time on the internet. The broader independent blogosphere of my teens and early adulthood shaped my worldview, and I was an avid reader and sometime participant there.</p>
+<h2>The Blogosphere</h2>
+<p>I am an atheist in large part because of a blog called Common Sense Atheism.<label for="sn-2" class="sidenote-number"></label><input type="checkbox" id="sn-2" class="margin-toggle"/><span class="sidenote">The author, Luke Muehlhauser, was criticising both Richard Dawkins <em>and</em> some Christian apologetics I was familiar with.</span> Luke's blog was part of a cluster of blogs out of which grew the rationalists, one of, for better or for worse, the most influential intellectual movements of the 21st century.I also read blogs like boingboing.net, was a big fan of Cory Doctorow. I figured out I am trans in part because of Thing of Things,<label for="sn-3" class="sidenote-number"></label><input type="checkbox" id="sn-3" class="margin-toggle"/><span class="sidenote">Specifically their piece on the <a href="https://thingofthings.wordpress.com/2017/05/05/the-cluster-structure-of-genderspace/">cluster structure of genderspace</a>.</span> a blog by Ozy Frantz, a transmasc person in the broader rationalist and Effective Altruist blogosphere.One thing these all have in common is length. Part of the reason I only really got onto Twitter in 2020 or so was because the concept of microblogging, of having to fit your thoughts into such a small package, baffled me for ages.<label for="sn-4" class="sidenote-number"></label><input type="checkbox" id="sn-4" class="margin-toggle"/><span class="sidenote">Amusingly I now think that being on Twitter and now Bluesky made me a better writer. Restrictions breed creativity, after all.</span></p>
+<aside>
+<blockquote>
+<p><strong>On Platform Decay</strong></p>
+<p>Through all of this I was never really satisfied with the options that were out there for long-form writing. Wordpress required too much setup. Tumblr's system for comments remains insane. Hosting my own seemed like too much money to burn on something nobody might read.</p>
+</blockquote>
+</aside>
+<p>But at the same time, Substack's success proves that there is very much a desire for long-form writing, enough that people will pay for it, and that investors will back it. There are thoughts and forms of writing that you simply cannot fit into a post or even a thread of posts.</p>
+<p>Plus, I'm loathe to enable a centralised platform like Substack where the owners are unfortunately friendly to fascists.<label for="sn-5" class="sidenote-number"></label><input type="checkbox" id="sn-5" class="margin-toggle"/><span class="sidenote">I am very much a fan of freedom of expression. I'm not so much a fan of paying money to Nazis.</span>That's where the <code>at://</code> protocol and Weaver comes in.</p>
+<h2>The Pitch</h2>
+<p>Weaver is designed to be a highly flexible platform for medium and long-form writing on atproto.<label for="sn-6" class="sidenote-number"></label><input type="checkbox" id="sn-6" class="margin-toggle"/><span class="sidenote">The weaver bird builds intricate, self-contained homes—seemed fitting for a platform about owning your writing.</span> I was inspired by how weaver birds build their own homes, and by the notebooks, physical and virtual, that I create in the course of my work.The initial proof-of-concept is essentially a static site generator, able to turn a Markdown text file or a folder of Markdown files into a static "notebook" site. The intermediate goal is an elegant and intuitive writing platform with collaborative editing and straightforward, immediate publishing via a web-app.</p>
+<aside>
+<blockquote>
+<p><strong>The Ultimate Goal</strong></p>
+<p>Build a platform suitable for professional writers and journalists, an open alternative to platforms like Substack, with ways for readers to support writers, all on the <code>at://</code> protocol.</p>
+</blockquote>
+</aside>
+<h2>How It Works</h2>
+<p>Weaver works on a concept of notebooks with entries, which can be grouped into pages or chapters. They can have multiple attributed authors. You can tear out a metaphorical page and stick it in another notebook.</p>
+<p>You own what you write.<label for="sn-7" class="sidenote-number"></label><input type="checkbox" id="sn-7" class="margin-toggle"/><span class="sidenote">Technically you can include entries you don't control in your notebooks, although this isn't a supported mode—it's about <em>your</em> ownership of <em>your</em> words.</span> And once collaborative editing is in, collaborative work will be resilient against deletion by one author. They can delete their notebook or even their account, but what you write will be safe.Entries are Markdown text—specifically, an extension on the Obsidian flavour of Markdown.<label for="sn-8" class="sidenote-number"></label><input type="checkbox" id="sn-8" class="margin-toggle"/><span class="sidenote">I forked the popular rust markdown processing library <code>pulldown-cmark</code> because it had limited extensibility along the axes I wanted—custom syntax extensions to support Obsidian's Markdown flavour and additional useful features, like some of the ones on show here!</span> They support additional embed types, including atproto record embeds and other markdown documents, as well as resizable images.</p>
+<h2>Why Rust?</h2>
+<p>As to why I'm writing it in Rust (and currently zero Typescript) as opposed to Go and Typescript? Well it comes down to familiarity. Rust isn't necessarily anyone's first choice in a vacuum for a web-native programming language, but it works quite well as one. I can share the vast majority of the protocol code, as well as the markdown rendering engine, between front and back end, with few if any compromises on performance, save a larger bundle size due to the nature of WebAssembly.</p>
+<aside>
+<blockquote>
+<p><strong>On Interoperability</strong></p>
+<p>The <code>at://</code> protocol, while it was developed in concert with a microblogging app, is actually pretty damn good for "macroblogging" too. Weaver's app server can display Whitewind posts. With effort, it can faithfully render Leaflet posts. It doesn't care what app your profile is on.</p>
+</blockquote>
+</aside>
+<h2>Evolution</h2>
+<p>Weaver is therefore very much an evolving thing. It will always have and support the proof-of-concept workflow as a first-class citizen. That's part of the benefit of building this on atproto.</p>
+<p>If I screw this up, not too hard for someone else to pick up the torch and continue.<label for="sn-9" class="sidenote-number"></label><input type="checkbox" id="sn-9" class="margin-toggle"/><span class="sidenote">This is the traditional footnote, at the end, because sometimes you want your citations at the bottom of the page rather than in the margins.</span></p>
+</div>
+</body>
+</html>