bunch of random little bugs squished

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

···
 //! Formatting actions and utilities for applying markdown formatting.
 
+use crate::components::editor::{ListContext, detect_list_context, find_line_end};
+
 use super::document::EditorDocument;
 
 /// Formatting actions available in the editor.
···
             doc.selection = None;
         }
         FormatAction::BulletList => {
-            let line_start = find_line_start(doc.loro_text(), doc.cursor.offset);
-            let _ = doc.insert_tracked(line_start, "- ");
-            doc.cursor.offset += 2;
-            doc.selection = None;
+            if let Some(ctx) = detect_list_context(doc.loro_text(), doc.cursor.offset) {
+                let continuation = match ctx {
+                    ListContext::Unordered { indent, marker } => {
+                        format!("\n{}{} ", indent, marker)
+                    }
+                    ListContext::Ordered { .. } => {
+                        format!("\n\n - ")
+                    }
+                };
+                let len = continuation.chars().count();
+                let _ = doc.insert_tracked(doc.cursor.offset, &continuation);
+                doc.cursor.offset += len;
+                doc.selection = None;
+            } else {
+                let line_start = find_line_start(doc.loro_text(), doc.cursor.offset);
+                let _ = doc.insert_tracked(line_start, " - ");
+                doc.cursor.offset += 3;
+                doc.selection = None;
+            }
         }
         FormatAction::NumberedList => {
-            let line_start = find_line_start(doc.loro_text(), doc.cursor.offset);
-            let _ = doc.insert_tracked(line_start, "1. ");
-            doc.cursor.offset += 3;
-            doc.selection = None;
+            if let Some(ctx) = detect_list_context(doc.loro_text(), doc.cursor.offset) {
+                let continuation = match ctx {
+                    ListContext::Unordered { .. } => {
+                        format!("\n\n1. ")
+                    }
+                    ListContext::Ordered { indent, number } => {
+                        format!("\n{}{}. ", indent, number + 1)
+                    }
+                };
+                let len = continuation.chars().count();
+                let _ = doc.insert_tracked(doc.cursor.offset, &continuation);
+                doc.cursor.offset += len;
+                doc.selection = None;
+            } else {
+                let line_start = find_line_start(doc.loro_text(), doc.cursor.offset);
+                let _ = doc.insert_tracked(line_start, "1. ");
+                doc.cursor.offset += 3;
+                doc.selection = None;
+            }
         }
         FormatAction::Quote => {
             let line_start = find_line_start(doc.loro_text(), doc.cursor.offset);

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

···
     // Update DOM when paragraphs change (incremental rendering)
     #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
     use_effect(move || {
-        tracing::info!("DOM update effect triggered");
+        tracing::debug!("DOM update effect triggered");
 
         // Read document once to avoid multiple borrows
         let doc = document();
 
-        tracing::info!(
+        tracing::debug!(
             composition_active = doc.composition.is_some(),
             cursor = doc.cursor.offset,
             "DOM update: checking state"
···
 
         // Skip DOM updates during IME composition - browser controls the preview
         if doc.composition.is_some() {
-            tracing::info!("skipping DOM update during composition");
+            tracing::debug!("skipping DOM update during composition");
             return;
         }
+
+        tracing::debug!(
+            cursor = doc.cursor.offset,
+            len = doc.len_chars(),
+            "DOM update proceeding (not in composition)"
+        );
 
         let cursor_offset = doc.cursor.offset;
         let selection = doc.selection;
···
                         // During IME composition, let browser handle everything
                         // Exception: Escape cancels composition
                         if document.peek().composition.is_some() {
-                            tracing::info!(
+                            tracing::debug!(
                                 key = ?evt.key(),
                                 "keydown during composition - delegating to browser"
                             );
                             if evt.key() == Key::Escape {
-                                tracing::info!("Escape pressed - cancelling composition");
+                                tracing::debug!("Escape pressed - cancelling composition");
                                 document.with_mut(|doc| {
                                     doc.composition = None;
                                 });
···
 
                     onkeyup: move |evt| {
                         use dioxus::prelude::keyboard_types::Key;
-                        // Only sync cursor from DOM after navigation keys
-                        // Content-modifying keys update cursor directly in handle_keydown
-                        let dominated = matches!(
+
+                        // Navigation keys (with or without Shift for selection)
+                        let navigation = matches!(
                             evt.key(),
                             Key::ArrowLeft | Key::ArrowRight | Key::ArrowUp | Key::ArrowDown |
                             Key::Home | Key::End | Key::PageUp | Key::PageDown
                         );
-                        if dominated {
+
+                        // Cmd/Ctrl+A for select all
+                        let select_all = (evt.modifiers().meta() || evt.modifiers().ctrl())
+                            && matches!(evt.key(), Key::Character(ref c) if c == "a");
+
+                        if navigation || select_all {
                             let paras = cached_paragraphs();
                             sync_cursor_from_dom(&mut document, editor_id, &paras);
-                            // Update syntax visibility after cursor sync
                             let doc = document();
                             let spans = syntax_spans();
                             update_syntax_visibility(
···
                         }
                     },
 
+                    onselect: move |_evt| {
+                        tracing::debug!("onselect fired");
+                        let paras = cached_paragraphs();
+                        sync_cursor_from_dom(&mut document, editor_id, &paras);
+                        let doc = document();
+                        let spans = syntax_spans();
+                        update_syntax_visibility(
+                            doc.cursor.offset,
+                            doc.selection.as_ref(),
+                            &spans,
+                            &paras,
+                        );
+                    },
+
+                    onselectstart: move |_evt| {
+                        tracing::debug!("onselectstart fired");
+                        let paras = cached_paragraphs();
+                        sync_cursor_from_dom(&mut document, editor_id, &paras);
+                        let doc = document();
+                        let spans = syntax_spans();
+                        update_syntax_visibility(
+                            doc.cursor.offset,
+                            doc.selection.as_ref(),
+                            &spans,
+                            &paras,
+                        );
+                    },
+
+                    onselectionchange: move |_evt| {
+                        tracing::debug!("onselectionchange fired");
+                        let paras = cached_paragraphs();
+                        sync_cursor_from_dom(&mut document, editor_id, &paras);
+                        let doc = document();
+                        let spans = syntax_spans();
+                        update_syntax_visibility(
+                            doc.cursor.offset,
+                            doc.selection.as_ref(),
+                            &spans,
+                            &paras,
+                        );
+                    },
+
                     onclick: move |_evt| {
-                        // After mouse click or drag selection, sync cursor from DOM
-                        // (click fires after mouseup, so this handles both cases)
+                        tracing::debug!("onclick fired");
                         let paras = cached_paragraphs();
                         sync_cursor_from_dom(&mut document, editor_id, &paras);
-                        // Update syntax visibility after cursor sync
                         let doc = document();
                         let spans = syntax_spans();
                         update_syntax_visibility(
···
                         // Cancel any in-progress IME composition on focus loss
                         let had_composition = document.peek().composition.is_some();
                         if had_composition {
-                            tracing::info!("onblur: clearing active composition");
+                            tracing::debug!("onblur: clearing active composition");
                         }
                         document.with_mut(|doc| {
                             doc.composition = None;
···
 
                     oncompositionstart: move |evt: CompositionEvent| {
                         let data = evt.data().data();
-                        tracing::info!(
+                        tracing::debug!(
                             data = %data,
                             "compositionstart"
                         );
···
                             if let Some(sel) = doc.selection.take() {
                                 let (start, end) =
                                     (sel.anchor.min(sel.head), sel.anchor.max(sel.head));
-                                tracing::info!(
+                                tracing::debug!(
                                     start,
                                     end,
                                     "compositionstart: deleting selection"
···
                                 doc.cursor.offset = start;
                             }
 
-                            tracing::info!(
+                            tracing::debug!(
                                 cursor = doc.cursor.offset,
                                 "compositionstart: setting composition state"
                             );
···
 
                     oncompositionupdate: move |evt: CompositionEvent| {
                         let data = evt.data().data();
-                        tracing::info!(
+                        tracing::debug!(
                             data = %data,
                             "compositionupdate"
                         );
···
                             if let Some(ref mut comp) = doc.composition {
                                 comp.text = data;
                             } else {
-                                tracing::info!("compositionupdate without active composition state");
+                                tracing::debug!("compositionupdate without active composition state");
                             }
                         });
                     },
 
                     oncompositionend: move |evt: CompositionEvent| {
                         let final_text = evt.data().data();
-                        tracing::info!(
+                        tracing::debug!(
                             data = %final_text,
                             "compositionend"
                         );
                         document.with_mut(|doc| {
                             if let Some(comp) = doc.composition.take() {
-                                tracing::info!(
+                                tracing::debug!(
                                     start_offset = comp.start_offset,
                                     final_text = %final_text,
                                     chars = final_text.chars().count(),
···
                                 );
 
                                 if !final_text.is_empty() {
-                                    let _ = doc.insert_tracked(comp.start_offset, &final_text);
-                                    doc.cursor.offset =
-                                        comp.start_offset + final_text.chars().count();
+                                    let mut delete_start = comp.start_offset;
+                                    while delete_start > 0 {
+                                        match get_char_at(doc.loro_text(), delete_start - 1) {
+                                            Some('\u{200C}') | Some('\u{200B}') => delete_start -= 1,
+                                            _ => break,
+                                        }
+                                    }
+
+                                    let zw_count = doc.cursor.offset - delete_start;
+                                    if zw_count > 0 {
+                                        // Splice: delete zero-width chars and insert new char in one op
+                                        let _ = doc.replace_tracked(delete_start, zw_count, &final_text);
+                                        doc.cursor.offset = delete_start + final_text.chars().count();
+                                    } else if doc.cursor.offset == doc.len_chars() {
+                                        // Fast path: append at end
+                                        let _ = doc.push_tracked(&final_text);
+                                        doc.cursor.offset = comp.start_offset + final_text.chars().count();
+                                    } else {
+                                        let _ = doc.insert_tracked(doc.cursor.offset, &final_text);
+                                        doc.cursor.offset = comp.start_offset + final_text.chars().count();
+                                    }
                                 }
                             } else {
-                                tracing::info!("compositionend without active composition state");
+                                tracing::debug!("compositionend without active composition state");
                             }
                         });
                     },
                 }
-
-
             }
 
             EditorToolbar {
···
     let node_id = loop {
         if let Some(element) = current_node.dyn_ref::<web_sys::Element>() {
             if element == editor_element {
+                // Selection is on the editor container itself (e.g., Cmd+A select all)
+                // Return boundary position based on offset:
+                // offset 0 = start of editor, offset == child count = end of editor
+                let child_count = editor_element.child_element_count() as usize;
+                if offset_in_text_node == 0 {
+                    return Some(0); // Start of document
+                } else if offset_in_text_node >= child_count {
+                    // End of document - find last paragraph's end
+                    return paragraphs.last().map(|p| p.char_range.end);
+                }
                 break None;
             }
 
···
                         while delete_start > 0 {
                             let ch = get_char_at(doc.loro_text(), delete_start - 1);
                             match ch {
-                                Some(' ') | Some('\t') | Some('\u{200C}') | Some('\u{200B}') => {
+                                Some('\u{200C}') | Some('\u{200B}') => {
                                     delete_start -= 1;
                                 }
                                 Some('\n') => break, // stop at another newline
···
         if let Some(old_para) = old_paragraphs.get(idx) {
             // Paragraph exists - check if changed
             if new_para.source_hash != old_para.source_hash {
-                // Changed - update innerHTML
+                // Changed - clear and update innerHTML
+                // We clear first to ensure any browser-added content (from IME composition,
+                // contenteditable quirks, etc.) is fully removed before setting new content
                 if let Some(elem) = document.get_element_by_id(&para_id) {
+                    elem.set_text_content(None); // Clear completely
                     elem.set_inner_html(&new_para.html);
                 }
 

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__blockquote.snap

···
   char_range:
     - 0
     - 18
-  html: "<blockquote>\n<p id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">&gt; </span>This is a quote<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"17\" data-char-end=\"18\">\n</span></p>\n</blockquote>\n"
+  html: "<blockquote>\n<p id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"1\">&gt;</span> This is a quote\n</p>\n</blockquote>\n"
   offset_map:
     - byte_range:
         - 43
···
       utf16_len: 0
     - byte_range:
         - 41
-        - 43
+        - 42
       char_range:
         - 0
-        - 2
+        - 1
       node_id: n0
       char_offset_in_node: 0
       child_index: ~
-      utf16_len: 2
+      utf16_len: 1
+    - byte_range:
+        - 42
+        - 43
+      char_range:
+        - 1
+        - 2
+      node_id: n0
+      char_offset_in_node: 1
+      child_index: ~
+      utf16_len: 1
     - byte_range:
         - 43
         - 58

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__gap_between_blocks.snap

···
   char_range:
     - 0
     - 10
-  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>Heading<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"9\" data-char-end=\"10\">\n</span></h1>\n"
+  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>Heading\n</h1>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__hard_break.snap

···
   char_range:
     - 0
     - 19
-  html: "<p id=\"n0\">Line one<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"8\" data-char-end=\"10\">  </span><br />​Line two</p>\n"
+  html: "<p id=\"n0\">Line one<span class=\"md-placeholder\" data-syn-id=\"s0\" data-char-start=\"8\" data-char-end=\"10\">  </span><br /> Line two</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__heading_levels.snap

···
   char_range:
     - 0
     - 5
-  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>H1<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"4\" data-char-end=\"5\">\n</span></h1>\n"
+  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>H1\n</h1>\n"
   offset_map:
     - byte_range:
         - 0
···
   char_range:
     - 6
     - 12
-  html: "<h2 data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"0\" data-char-end=\"3\">## </span>H2<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"5\" data-char-end=\"6\">\n</span></h2>\n"
+  html: "<h2 data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s1\" data-char-start=\"0\" data-char-end=\"3\">## </span>H2\n</h2>\n"
   offset_map:
     - byte_range:
         - 6
···
   char_range:
     - 13
     - 20
-  html: "<h3 data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s4\" data-char-start=\"0\" data-char-end=\"4\">### </span>H3<span class=\"md-syntax-inline\" data-syn-id=\"s5\" data-char-start=\"6\" data-char-end=\"7\">\n</span></h3>\n"
+  html: "<h3 data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"0\" data-char-end=\"4\">### </span>H3\n</h3>\n"
   offset_map:
     - byte_range:
         - 13
···
   char_range:
     - 21
     - 28
-  html: "<h4 data-node-id=\"n3\"><span class=\"md-syntax-block\" data-syn-id=\"s6\" data-char-start=\"0\" data-char-end=\"5\">#### </span>H4</h4>\n"
+  html: "<h4 data-node-id=\"n3\"><span class=\"md-syntax-block\" data-syn-id=\"s3\" data-char-start=\"0\" data-char-end=\"5\">#### </span>H4</h4>\n"
   offset_map:
     - byte_range:
         - 21

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__multiple_blank_lines.snap

···
   char_range:
     - 0
     - 6
-  html: "<p id=\"n0\">First<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">\n</span></p>\n"
+  html: "<p id=\"n0\">First\n</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__nested_list.snap

···
   char_range:
     - 11
     - 33
-  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">- </span>Child 1<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"9\" data-char-end=\"12\">\n  </span>\n<ul>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"12\" data-char-end=\"14\">- </span>Child 2<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"21\" data-char-end=\"22\">\n</span></li>\n</ul>\n</li>\n</ul>\n"
+  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">- </span>Child 1\n  \n<ul>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s1\" data-char-start=\"12\" data-char-end=\"14\">- </span>Child 2\n</li>\n</ul>\n</li>\n</ul>\n"
   offset_map:
     - byte_range:
         - 11

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__ordered_list.snap

···
   char_range:
     - 0
     - 27
-  html: "<ol>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"3\">1. </span>First<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"8\" data-char-end=\"9\">\n</span></li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"9\" data-char-end=\"12\">2. </span>Second<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"18\" data-char-end=\"19\">\n</span></li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s4\" data-char-start=\"19\" data-char-end=\"22\">3. </span>Third</li>\n</ol>\n"
+  html: "<ol>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"3\">1. </span>First\n</li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s1\" data-char-start=\"9\" data-char-end=\"12\">2. </span>Second\n</li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"19\" data-char-end=\"22\">3. </span>Third</li>\n</ol>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__three_paragraphs.snap

···
   char_range:
     - 0
     - 5
-  html: "<p id=\"n0\">One.<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"4\" data-char-end=\"5\">\n</span></p>\n"
+  html: "<p id=\"n0\">One.\n</p>\n"
   offset_map:
     - byte_range:
         - 0
···
   char_range:
     - 6
     - 11
-  html: "<p id=\"n1\">Two.<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"4\" data-char-end=\"5\">\n</span></p>\n"
+  html: "<p id=\"n1\">Two.\n</p>\n"
   offset_map:
     - byte_range:
         - 6

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__trailing_double_newline.snap

···
   char_range:
     - 0
     - 6
-  html: "<p id=\"n0\">Hello<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">\n</span></p>\n"
+  html: "<p id=\"n0\">Hello\n</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__trailing_single_newline.snap

···
   char_range:
     - 0
     - 6
-  html: "<p id=\"n0\">Hello<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">\n</span></p>\n"
+  html: "<p id=\"n0\">Hello\n</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__two_paragraphs.snap

···
   char_range:
     - 0
     - 17
-  html: "<p id=\"n0\">First paragraph.<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"16\" data-char-end=\"17\">\n</span></p>\n"
+  html: "<p id=\"n0\">First paragraph.\n</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__unordered_list.snap

···
   char_range:
     - 0
     - 26
-  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">- </span>Item 1<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"8\" data-char-end=\"9\">\n</span></li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"9\" data-char-end=\"11\">- </span>Item 2<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"17\" data-char-end=\"18\">\n</span></li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s4\" data-char-start=\"18\" data-char-end=\"20\">- </span>Item 3</li>\n</ul>\n"
+  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">- </span>Item 1\n</li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s1\" data-char-start=\"9\" data-char-end=\"11\">- </span>Item 2\n</li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"18\" data-char-end=\"20\">- </span>Item 3</li>\n</ul>\n"
   offset_map:
     - byte_range:
         - 0

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

···
 }
 
 // =============================================================================
+// Syntax Span Edge Case Tests
+// =============================================================================
+
+#[test]
+fn test_invalid_heading_no_space() {
+    // "#text" without space is NOT a valid heading - should be plain text
+    // The '#' should NOT be wrapped in a syntax span
+    let result = render_test("#text");
+
+    // Should be a single paragraph with plain text
+    assert_eq!(result.len(), 1, "Should have 1 paragraph");
+
+    // HTML should NOT contain md-syntax-block for the #
+    assert!(
+        !result[0].html.contains("md-syntax-block"),
+        "Invalid heading '#text' should NOT have block syntax span. HTML: {}",
+        result[0].html
+    );
+
+    // The # should be visible as regular text content
+    assert!(
+        result[0].html.contains("#text") || result[0].html.contains("#text"),
+        "The '#text' should appear as regular text. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_valid_heading_with_space() {
+    // "# text" WITH space IS a valid heading
+    let result = render_test("# Heading");
+
+    // Should have heading syntax span
+    assert!(
+        result[0].html.contains("md-syntax-block"),
+        "Valid heading should have block syntax span. HTML: {}",
+        result[0].html
+    );
+
+    // Should have <h1> tag
+    assert!(
+        result[0].html.contains("<h1"),
+        "Valid heading should render as h1. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_hash_in_middle_of_text() {
+    // "#" in middle of text should not be treated as heading syntax
+    let result = render_test("Some #hashtag here");
+
+    assert!(
+        !result[0].html.contains("md-syntax-block"),
+        "# in middle of text should NOT be block syntax. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_unclosed_bold() {
+    // "**text" without closing ** should be plain text, not bold
+    let result = render_test("**unclosed bold");
+
+    // Should NOT have <strong> tag
+    assert!(
+        !result[0].html.contains("<strong>"),
+        "Unclosed ** should NOT render as bold. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_unclosed_italic() {
+    // "*text" without closing * should be plain text, not italic
+    let result = render_test("*unclosed italic");
+
+    // Should NOT have <em> tag
+    assert!(
+        !result[0].html.contains("<em>"),
+        "Unclosed * should NOT render as italic. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_asterisk_not_emphasis() {
+    // Single * surrounded by spaces is not emphasis
+    let result = render_test("5 * 3 = 15");
+
+    // Should NOT have <em> tag
+    assert!(
+        !result[0].html.contains("<em>"),
+        "Math expression with * should NOT be italic. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_list_marker_needs_space() {
+    // "-text" without space is NOT a list item
+    let result = render_test("-not-a-list");
+
+    // Should NOT have <li> or <ul> tags
+    assert!(
+        !result[0].html.contains("<li>") && !result[0].html.contains("<ul>"),
+        "'-text' without space should NOT be a list. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_valid_list_with_space() {
+    // "- text" WITH space IS a valid list item
+    let result = render_test("- List item");
+
+    // Should have list markup
+    assert!(
+        result[0].html.contains("<li>") || result[0].html.contains("<ul>"),
+        "Valid list should have list markup. HTML: {}",
+        result[0].html
+    );
+
+    // Should have block syntax span for the marker
+    assert!(
+        result[0].html.contains("md-syntax-block"),
+        "List marker should have block syntax span. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_number_dot_needs_space() {
+    // "1.text" without space is NOT an ordered list
+    let result = render_test("1.not-a-list");
+
+    // Should NOT have <ol> tag
+    assert!(
+        !result[0].html.contains("<ol>"),
+        "'1.text' without space should NOT be ordered list. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_hash_with_zero_width_char() {
+    // "#\u{200B}text" - zero-width space after # should NOT make it a valid heading
+    let result = render_test("#\u{200B}text");
+
+    // Debug: print what we got
+    eprintln!("HTML for '#\\u{{200B}}text': {}", result[0].html);
+
+    // Should NOT be a heading - zero-width space is not a real space
+    assert!(
+        !result[0].html.contains("<h1"),
+        "# followed by zero-width space should NOT be h1. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_hash_with_zwj() {
+    // Test with zero-width joiner
+    let result = render_test("#\u{200C}text");
+
+    eprintln!("HTML for '#\\u{{200C}}text': {}", result[0].html);
+
+    assert!(
+        !result[0].html.contains("<h1"),
+        "# followed by ZWNJ should NOT be h1. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_hash_space_then_zero_width() {
+    // "# \u{200B}" - valid heading marker, but content is just zero-width
+    let result = render_test("# \u{200B}");
+
+    eprintln!("HTML for '# \\u{{200B}}': {}", result[0].html);
+    eprintln!("Syntax spans: {:?}", result[0].offset_map);
+
+    // This IS a valid heading (has space after #), even if content is "invisible"
+    // The question is: should we hide the # syntax in this case?
+}
+
+#[test]
+fn test_hash_alone() {
+    // Just "#" at EOL IS a valid empty heading (standard CommonMark behavior)
+    let result = render_test("#");
+    eprintln!("HTML for '#': {}", result[0].html);
+
+    // This IS a heading - empty headings are valid
+    assert!(
+        result[0].html.contains("<h1"),
+        "'#' alone IS a valid empty h1. HTML: {}",
+        result[0].html
+    );
+}
+
+#[test]
+fn test_heading_to_non_heading_transition() {
+    // Simulates typing: start with "#" (heading), then add "t" to make "#t" (not heading)
+    // This tests that the syntax spans are correctly updated on content change.
+    use loro::LoroDoc;
+    use super::render::render_paragraphs_incremental;
+
+    let doc = LoroDoc::new();
+    let text = doc.get_text("content");
+
+    // Initial state: "#" is a valid empty heading
+    text.insert(0, "#").unwrap();
+    let (paras1, cache1) = render_paragraphs_incremental(&text, None, None);
+
+    eprintln!("State 1 ('#'): {}", paras1[0].html);
+    assert!(paras1[0].html.contains("<h1"), "# alone should be heading");
+    assert!(
+        paras1[0].html.contains("md-syntax-block"),
+        "# should have syntax span"
+    );
+
+    // Transition: add "t" to make "#t" - no longer a heading
+    text.insert(1, "t").unwrap();
+    let (paras2, _cache2) = render_paragraphs_incremental(&text, Some(&cache1), None);
+
+    eprintln!("State 2 ('#t'): {}", paras2[0].html);
+    assert!(
+        !paras2[0].html.contains("<h1"),
+        "#t should NOT be heading. HTML: {}",
+        paras2[0].html
+    );
+    assert!(
+        !paras2[0].html.contains("md-syntax-block"),
+        "#t should NOT have block syntax span. HTML: {}",
+        paras2[0].html
+    );
+}
+
+#[test]
+fn test_hash_space_alone() {
+    // "# " (hash + space, no content) - IS this a heading?
+    let result = render_test("# ");
+    eprintln!("HTML for '# ': {}", result[0].html);
+
+    // Document actual behavior - this determines if empty headings are valid
+}
+
+#[test]
+fn test_empty_blockquote() {
+    // Just ">" alone - empty blockquote
+    // BUG: Currently produces 0 paragraphs, making the > invisible!
+    let result = render_test(">");
+    eprintln!("Paragraphs for '>': {:?}", result.len());
+    for (i, p) in result.iter().enumerate() {
+        eprintln!("  Para {}: html={}, char_range={:?}", i, p.html, p.char_range);
+    }
+
+    // Empty blockquote should still produce at least one paragraph
+    // containing the > syntax so it can be rendered and edited
+    assert!(
+        !result.is_empty(),
+        "Empty blockquote should produce at least one paragraph, got 0"
+    );
+}
+
+#[test]
+fn test_blockquote_needs_space_or_newline() {
+    // ">text" directly attached might not be a blockquote depending on parser
+    // This test documents expected behavior
+    let result = render_test(">quote");
+
+    // Whether this is a blockquote depends on the parser - document actual behavior
+    insta::assert_yaml_snapshot!(result, @r#"
+    - byte_range:
+        - 6
+        - 6
+      char_range:
+        - 0
+        - 6
+      html: "<blockquote>\n<p id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"1\">&gt;</span>quote</p>\n</blockquote>\n"
+      offset_map:
+        - byte_range:
+            - 7
+            - 7
+          char_range:
+            - 0
+            - 0
+          node_id: n0
+          char_offset_in_node: 0
+          child_index: 0
+          utf16_len: 0
+        - byte_range:
+            - 6
+            - 7
+          char_range:
+            - 0
+            - 1
+          node_id: n0
+          char_offset_in_node: 0
+          child_index: ~
+          utf16_len: 1
+        - byte_range:
+            - 7
+            - 12
+          char_range:
+            - 1
+            - 6
+          node_id: n0
+          char_offset_in_node: 1
+          child_index: ~
+          utf16_len: 5
+      source_hash: 6279293067953035109
+    "#);
+}
+
+// =============================================================================
 // Char Range Coverage Tests
 // =============================================================================
 

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

···
             {
                 opening_span.formatted_range = Some(formatted_range.clone());
             } else {
-                tracing::warn!("[FINALIZE_PAIRED] Could not find opening span {}", opening_syn_id);
+                tracing::warn!(
+                    "[FINALIZE_PAIRED] Could not find opening span {}",
+                    opening_syn_id
+                );
             }
 
             // Update the closing span's formatted_range (the most recent one)
···
                     return Ok(());
                 }
 
-                let syntax_type = classify_syntax(syntax);
-                let class = match syntax_type {
-                    SyntaxType::Inline => "md-syntax-inline",
-                    SyntaxType::Block => "md-syntax-block",
-                };
+                // 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)?;
 
-                // Generate unique ID for this syntax span
-                let syn_id = self.gen_syn_id();
+                    if created_node {
+                        self.write("</span>")?;
+                        self.end_node();
+                    }
 
-                // 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
+                    // Record offset mapping but no syntax span info
+                    self.record_mapping(range.clone(), char_start..char_end);
+                    self.last_char_offset = char_end;
+                    self.last_byte_offset = range.end;
                 } else {
-                    write!(
-                        &mut self.writer,
-                        "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
-                        class, syn_id, char_start, char_end
-                    )?;
-                    false
-                };
+                    // 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>")?;
+                    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 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; // Mark bytes as processed
+                    // 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();
+                    // Close wrapper if we created one
+                    if created_node {
+                        self.write("</span>")?;
+                        self.end_node();
+                    }
                 }
             }
         }
···
 
             // Only add checkpoint if we've advanced
             if char_range.end > last_checkpoint.0 {
-                self.utf16_checkpoints.push((char_range.end, new_utf16_offset));
+                self.utf16_checkpoints
+                    .push((char_range.end, new_utf16_offset));
             }
 
             let mapping = OffsetMapping {
···
 
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        "<span class=\"md-placeholder\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
                         syn_id, char_start, char_end
                     )?;
                     escape_html(&mut self.writer, trailing)?;
                     self.write("</span>")?;
 
                     // Record syntax span info
-                    self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type: SyntaxType::Inline,
-                        formatted_range: None,
-                    });
+                    // self.syntax_spans.push(SyntaxSpanInfo {
+                    //     syn_id,
+                    //     char_range: char_start..char_end,
+                    //     syntax_type: SyntaxType::Inline,
+                    //     formatted_range: None,
+                    // });
 
                     // Record mapping if we have a node
                     if let Some(ref node_id) = self.current_node_id {
···
                     let syn_id = self.gen_syn_id();
                     write!(
                         &mut self.writer,
-                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        "<span class=\"md-placeholder\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
                         syn_id, char_start, char_end
                     )?;
                     escape_html(&mut self.writer, spaces)?;
                     self.write("</span>")?;
 
                     // Record syntax span info
-                    self.syntax_spans.push(SyntaxSpanInfo {
-                        syn_id,
-                        char_range: char_start..char_end,
-                        syntax_type: SyntaxType::Inline,
-                        formatted_range: None,
-                    });
+                    // self.syntax_spans.push(SyntaxSpanInfo {
+                    //     syn_id,
+                    //     char_range: char_start..char_end,
+                    //     syntax_type: SyntaxType::Inline,
+                    //     formatted_range: None,
+                    // });
 
                     // Count this span as a child
                     self.current_node_child_count += 1;
···
                     self.current_node_child_count += 1;
 
                     // After <br>, emit plain zero-width space for cursor positioning
-                    self.write("\u{200B}")?;
+                    self.write(" ")?;
+                    //self.write("\u{200B}")?;
 
                     // Count the zero-width space text node as a child
                     self.current_node_child_count += 1;
···
                 // 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));
+                    self.current_paragraph_start =
+                        Some((self.last_byte_offset, self.last_char_offset));
                 }
 
                 let node_id = self.gen_node_id();
···
                                 }
                             } else {
                                 // Just > and maybe a space
-                                (gt_pos + 2).min(raw_text.len())
+                                (gt_pos + 1).min(raw_text.len())
                             };
 
                             let syntax = &raw_text[gt_pos..syntax_end];
···
                     Ok(())
                 }
             }
-            TagEnd::BlockQuote(_) => self.write("</blockquote>\n"),
+            TagEnd::BlockQuote(_) => {
+                // If pending_blockquote_range is still set, the blockquote was empty
+                // (no paragraph inside). Emit the > as its own minimal paragraph.
+                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, "<p id=\"{}\"", node_id)?;
+                            // self.begin_node(node_id.clone());
+
+                            // // 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: 0,
+                            //     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("</p>\n")?;
+                            // self.end_node();
+
+                            // Record paragraph boundary for incremental rendering
+                            let byte_range = para_byte_start..bq_range.end;
+                            let char_range = para_char_start..self.last_char_offset;
+                            self.paragraph_ranges.push((byte_range, char_range));
+                        }
+                    }
+                }
+                self.write("</blockquote>\n")
+            }
             TagEnd::CodeBlock => {
                 use std::sync::LazyLock;
                 use syntect::parsing::SyntaxSet;

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

···
 //! Editor view - wraps the MarkdownEditor component for the /editor route.
 
-use dioxus::prelude::*;
 use crate::components::editor::MarkdownEditor;
+use dioxus::prelude::*;
 
 /// Editor page view.
 ///
···
 #[component]
 pub fn Editor() -> Element {
     rsx! {
+        EditorCss {}
         div { class: "editor-page",
             MarkdownEditor { initial_content: None }
         }
     }
 }
+
+#[component]
+pub fn EditorCss() -> Element {
+    use weaver_renderer::css::{generate_base_css, generate_syntax_css};
+    use weaver_renderer::theme::default_resolved_theme;
+
+    let css_content = use_resource(move || async move {
+        let resolved_theme = default_resolved_theme();
+        let mut css = generate_base_css(&resolved_theme);
+        css.push_str(
+            &generate_syntax_css(&resolved_theme)
+                .await
+                .unwrap_or_default(),
+        );
+
+        Some(css)
+    });
+
+    match css_content() {
+        Some(Some(css)) => rsx! { document::Style { {css} } },
+        _ => rsx! {},
+    }
+}