newline cursor jumping fixed

crates/weaver-editor-browser/src/dom_sync.rs

···
                 let _ = div.set_attribute("data-hash", &new_hash);
                 let div_node: &web_sys::Node = div.as_ref();
                 let _ = editor.insert_before(div_node, cursor_node.as_ref());
-            }
 
-            if is_cursor_para {
-                cursor_para_updated = true;
+                if is_cursor_para {
+                    if let Err(e) =
+                        restore_cursor_position(cursor_offset, &new_para.offset_map, None)
+                    {
+                        tracing::warn!("Cursor restore for new paragraph failed: {:?}", e);
+                    }
+                    cursor_para_updated = true;
+                }
             }
         }
     }

crates/weaver-editor-core/src/writer/events.rs

···
 use std::fmt::Write as _;
 use std::ops::Range;
 
-use markdown_weaver::{Event, TagEnd};
+use markdown_weaver::{Event, Tag, TagEnd};
 use markdown_weaver_escape::{escape_html, escape_html_body_text_with_char_count};
 
 use crate::offset_map::OffsetMapping;
···
                 // Emit gap from last_byte_offset to range.end
                 self.emit_gap_before(range.end)?;
             } else if !matches!(&event, Event::End(_)) {
+                // For paragraph-level start events, capture pre-gap position so the
+                // paragraph's char_range includes leading whitespace/gap content.
+                let is_para_start = matches!(
+                    &event,
+                    Event::Start(
+                        Tag::Paragraph(_)
+                            | Tag::Heading { .. }
+                            | Tag::CodeBlock(_)
+                            | Tag::List(_)
+                            | Tag::BlockQuote(_)
+                            | Tag::HtmlBlock
+                    )
+                );
+                if is_para_start && self.paragraphs.should_track_boundaries() {
+                    self.paragraphs.pre_gap_start =
+                        Some((self.last_byte_offset, self.last_char_offset));
+                }
+
                 // For other events, emit any gap before range.start
                 // (emit_syntax handles char offset tracking)
                 self.emit_gap_before(range.start)?;
···
             // else: Event updated offset (e.g. start_tag emitted opening syntax), keep that value
         }
 
-        // Emit any trailing syntax
-        self.emit_gap_before(self.source.len())?;
+        // Check if document ends with a paragraph break (double newline) BEFORE emitting trailing.
+        // If so, we'll reserve the final newline for a synthetic trailing paragraph.
+        let ends_with_para_break = self.source.ends_with("\n\n")
+            || self.source.ends_with("\n\u{200C}\n");
+
+        // Determine where to stop emitting trailing syntax
+        let trailing_emit_end = if ends_with_para_break {
+            // Don't emit the final newline - save it for synthetic paragraph
+            self.source.len().saturating_sub(1)
+        } else {
+            self.source.len()
+        };
+
+        // Emit trailing syntax up to the determined point
+        self.emit_gap_before(trailing_emit_end)?;
 
         // Handle unmapped trailing content (stripped by parser)
         // This includes trailing spaces that markdown ignores
         let doc_byte_len = self.source.len();
         let doc_char_len = self.text_buffer.len_chars();
 
-        if self.last_byte_offset < doc_byte_len || self.last_char_offset < doc_char_len {
-            // Emit the trailing content as visible syntax
+        if !ends_with_para_break
+            && (self.last_byte_offset < doc_byte_len || self.last_char_offset < doc_char_len)
+        {
+            // Emit the trailing content as visible syntax (only if not creating synthetic para)
             if self.last_byte_offset < doc_byte_len {
                 let trailing = &self.source[self.last_byte_offset..];
                 if !trailing.is_empty() {
···
             }
         }
 
-        // Add any remaining accumulated data for the last paragraph
+        // Add any remaining accumulated data for the last paragraph FIRST
         // (content that wasn't followed by a paragraph boundary)
         if !self.current_para.offset_maps.is_empty()
             || !self.current_para.syntax_spans.is_empty()
···
                 .push(std::mem::take(&mut self.current_para.syntax_spans));
             self.refs_by_para
                 .push(std::mem::take(&mut self.ref_collector.refs));
+        }
+
+        // Now create a synthetic trailing paragraph if needed
+        if ends_with_para_break {
+            // Get the trailing content we reserved (the final newline)
+            let trailing_content = &self.source[trailing_emit_end..];
+            let trailing_char_len = trailing_content.chars().count();
+
+            let trailing_start_char = self.last_char_offset;
+            let trailing_start_byte = self.last_byte_offset;
+            let trailing_end_char = trailing_start_char + trailing_char_len;
+            let trailing_end_byte = self.source.len();
+
+            // Create paragraph range that includes the trailing content
+            self.paragraphs.ranges.push((
+                trailing_start_byte..trailing_end_byte,
+                trailing_start_char..trailing_end_char,
+            ));
+
+            // Start a new HTML segment for this trailing paragraph
+            self.writer.new_segment();
+            let node_id = self.gen_node_id();
+
+            // Write the actual trailing content plus ZWSP for cursor positioning
+            write!(&mut self.writer, "<span id=\"{}\">", node_id)?;
+            escape_html(&mut self.writer, trailing_content)?;
+            self.write("\u{200B}</span>")?;
+
+            // Record offset mapping for the trailing content
+            let mapping = OffsetMapping {
+                byte_range: trailing_start_byte..trailing_end_byte,
+                char_range: trailing_start_char..trailing_end_char,
+                node_id,
+                char_offset_in_node: 0,
+                child_index: None,
+                utf16_len: trailing_char_len + 1, // Content + ZWSP
+            };
+
+            // Create offset_maps/syntax_spans/refs for this trailing paragraph
+            self.offset_maps_by_para.push(vec![mapping]);
+            self.syntax_spans_by_para.push(vec![]);
+            self.refs_by_para.push(vec![]);
         }
 
         // Get HTML segments from writer

crates/weaver-editor-core/src/writer/state.rs

···
     pub ranges: Vec<(Range<usize>, Range<usize>)>,
     /// Start of current paragraph: (byte_offset, char_offset)
     pub current_start: Option<(usize, usize)>,
+    /// Pre-gap position for paragraph start (captured before gap emission).
+    /// This ensures the paragraph's char_range includes leading whitespace.
+    pub pre_gap_start: Option<(usize, usize)>,
     /// List nesting depth (suppress paragraph boundaries inside lists)
     pub list_depth: usize,
     /// In footnote definition (suppress inner paragraph boundaries)

crates/weaver-editor-core/src/writer/tags.rs

···
         match tag {
             // HTML blocks get their own paragraph to try and corral them better
             Tag::HtmlBlock => {
-                // Record paragraph start for boundary tracking
-                // Skip if inside a list or footnote def - they own their paragraph boundary
+                // Record paragraph start for boundary tracking.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                // Skip if inside a list or footnote def - they own their paragraph boundary.
                 if self.paragraphs.list_depth == 0 && !self.paragraphs.in_footnote_def {
-                    self.paragraphs.current_start =
-                        Some((self.last_byte_offset, self.last_char_offset));
+                    self.paragraphs.current_start = self
+                        .paragraphs
+                        .pre_gap_start
+                        .take()
+                        .or(Some((self.last_byte_offset, self.last_char_offset)));
                 }
                 let node_id = self.gen_node_id();
 
···
                 // Handle wrapper before block
                 self.emit_wrapper_start()?;
 
-                // Record paragraph start for boundary tracking
-                // Skip if inside a list or footnote def - they own their paragraph boundary
+                // Record paragraph start for boundary tracking.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                // Skip if inside a list or footnote def - they own their paragraph boundary.
                 if self.paragraphs.list_depth == 0 && !self.paragraphs.in_footnote_def {
-                    self.paragraphs.current_start =
-                        Some((self.last_byte_offset, self.last_char_offset));
+                    self.paragraphs.current_start = self
+                        .paragraphs
+                        .pre_gap_start
+                        .take()
+                        .or(Some((self.last_byte_offset, self.last_char_offset)));
                 }
 
                 let node_id = self.gen_node_id();
···
                 // 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.paragraphs.current_start =
-                    Some((self.last_byte_offset, self.last_char_offset));
+                // Record paragraph start for boundary tracking.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                // Treat headings as paragraph-level blocks.
+                self.paragraphs.current_start = self
+                    .paragraphs
+                    .pre_gap_start
+                    .take()
+                    .or(Some((self.last_byte_offset, self.last_char_offset)));
 
                 if !self.end_newline {
                     self.write_newline()?;
···
             Tag::CodeBlock(info) => {
                 self.emit_wrapper_start()?;
 
-                // Track code block as paragraph-level block
-                self.paragraphs.current_start =
-                    Some((self.last_byte_offset, self.last_char_offset));
+                // Track code block as paragraph-level block.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                self.paragraphs.current_start = self
+                    .paragraphs
+                    .pre_gap_start
+                    .take()
+                    .or(Some((self.last_byte_offset, self.last_char_offset)));
 
                 if !self.end_newline {
                     self.write_newline()?;
···
             }
             Tag::List(Some(1)) => {
                 self.emit_wrapper_start()?;
-                // Track list as paragraph-level block
-                self.paragraphs.current_start =
-                    Some((self.last_byte_offset, self.last_char_offset));
+                // Track list as paragraph-level block.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                self.paragraphs.current_start = self
+                    .paragraphs
+                    .pre_gap_start
+                    .take()
+                    .or(Some((self.last_byte_offset, self.last_char_offset)));
                 self.paragraphs.list_depth += 1;
                 if self.end_newline {
                     self.write("<ol>")
···
             }
             Tag::List(Some(start)) => {
                 self.emit_wrapper_start()?;
-                // Track list as paragraph-level block
-                self.paragraphs.current_start =
-                    Some((self.last_byte_offset, self.last_char_offset));
+                // Track list as paragraph-level block.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                self.paragraphs.current_start = self
+                    .paragraphs
+                    .pre_gap_start
+                    .take()
+                    .or(Some((self.last_byte_offset, self.last_char_offset)));
                 self.paragraphs.list_depth += 1;
                 if self.end_newline {
                     self.write("<ol start=\"")?;
···
             }
             Tag::List(None) => {
                 self.emit_wrapper_start()?;
-                // Track list as paragraph-level block
-                self.paragraphs.current_start =
-                    Some((self.last_byte_offset, self.last_char_offset));
+                // Track list as paragraph-level block.
+                // Use pre_gap_start if available to include leading whitespace in char_range.
+                self.paragraphs.current_start = self
+                    .paragraphs
+                    .pre_gap_start
+                    .take()
+                    .or(Some((self.last_byte_offset, self.last_char_offset)));
                 self.paragraphs.list_depth += 1;
                 if self.end_newline {
                     self.write("<ul>")

crates/weaver-renderer/src/lib.rs

···
 pub mod math;
 #[cfg(feature = "pckt")]
 pub mod pckt;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(all(not(target_family = "wasm"), feature = "syntax-highlighting"))]
 pub mod static_site;
 pub mod theme;
 pub mod types;

crates/weaver-renderer/src/static_site.rs

···
         Ok(())
     }
 
+    #[cfg(feature = "syntax-css")]
     async fn generate_css_files(&self) -> Result<(), miette::Report> {
         use crate::css::{generate_base_css, generate_syntax_css};
 
···
             .into_diagnostic()?;
 
         Ok(())
+    }
+
+    #[cfg(not(feature = "syntax-css"))]
+    async fn generate_css_files(&self) -> Result<(), miette::Report> {
+        Err(miette::miette!(
+            "CSS generation requires the 'syntax-css' feature"
+        ))
     }
 
     async fn generate_default_index(&self) -> Result<(), miette::Report> {

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

···
+#[cfg(feature = "syntax-css")]
 use crate::css::{generate_base_css, generate_syntax_css};
 use crate::static_site::context::{KaTeXSource, StaticSiteContext};
 use crate::theme::default_resolved_theme;
···
                 .await
                 .into_diagnostic()?;
         }
+        #[cfg(feature = "syntax-css")]
         CssMode::Inline => {
             let default_theme = default_resolved_theme();
             let theme = context.theme.as_deref().unwrap_or(&default_theme);
···
                 .await
                 .into_diagnostic()?;
             writer.write_all(b"  </style>\n").await.into_diagnostic()?;
+        }
+        #[cfg(not(feature = "syntax-css"))]
+        CssMode::Inline => {
+            // CSS generation not available without syntax-css feature
+            return Err(miette::miette!(
+                "Inline CSS mode requires the 'syntax-css' feature"
+            ));
         }
     }
 

docs/graph-data.json

···
       "node_type": "goal",
       "title": "Refactor EditorDocument to wrap LoroTextBuffer and impl TextBuffer+UndoManager",
       "description": null,
-      "status": "pending",
+      "status": "completed",
       "created_at": "2026-01-06T16:00:43.381698744-05:00",
-      "updated_at": "2026-01-06T16:00:43.381698744-05:00",
+      "updated_at": "2026-01-06T19:36:25.522798888-05:00",
       "metadata_json": "{\"confidence\":90,\"prompt\":\"User: refactor EditorDocument struct (rename it) to wrap LoroTextBuffer and implement EditorDocument trait. Replace EditInfo signal with Signal<()>. Migrate callers to trait methods. Remove LoroTextAdapter later.\"}"
     },
     {
···
       "status": "pending",
       "created_at": "2026-01-06T19:26:35.964103095-05:00",
       "updated_at": "2026-01-06T19:26:35.964103095-05:00",
+      "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 189,
+      "change_id": "15ebf616-39db-49ec-927d-88620156a8a0",
+      "node_type": "observation",
+      "title": "Bug: double-enter paragraph creation moves cursor to wrong position - jumps back to top of previous paragraph instead of landing in new one. Likely offset mapping or paragraph insertion issue.",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-07T09:26:20.476799309-05:00",
+      "updated_at": "2026-01-07T09:26:20.476799309-05:00",
+      "metadata_json": "{\"confidence\":90}"
+    },
+    {
+      "id": 190,
+      "change_id": "1b36bbd6-f50e-405b-b1cf-3b5718d0f132",
+      "node_type": "action",
+      "title": "Fixing cursor jump bug in new paragraph creation - restore_cursor_position not called for new paragraph elements",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-07T11:59:37.640443792-05:00",
+      "updated_at": "2026-01-07T11:59:37.640443792-05:00",
+      "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 191,
+      "change_id": "dd1da1bc-c368-426f-ac90-1be30eb8b091",
+      "node_type": "outcome",
+      "title": "Fixed cursor jump bug - restore_cursor_position now called for newly created paragraph elements in dom_sync.rs:615-622",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-07T12:04:06.226305951-05:00",
+      "updated_at": "2026-01-07T12:04:06.226305951-05:00",
       "metadata_json": "{\"confidence\":95}"
     }
   ],
···
       "weight": 1.0,
       "rationale": "Loading logic extraction part of component.rs split",
       "created_at": "2026-01-06T19:26:48.871648902-05:00"
+    },
+    {
+      "id": 192,
+      "from_node_id": 189,
+      "to_node_id": 190,
+      "from_change_id": "15ebf616-39db-49ec-927d-88620156a8a0",
+      "to_change_id": "1b36bbd6-f50e-405b-b1cf-3b5718d0f132",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Bug report led to fix implementation",
+      "created_at": "2026-01-07T11:59:54.175808294-05:00"
+    },
+    {
+      "id": 193,
+      "from_node_id": 190,
+      "to_node_id": 191,
+      "from_change_id": "1b36bbd6-f50e-405b-b1cf-3b5718d0f132",
+      "to_change_id": "dd1da1bc-c368-426f-ac90-1be30eb8b091",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Action resulted in fix",
+      "created_at": "2026-01-07T12:04:10.057504275-05:00"
     }
   ]
 }