newline cursor jumping fixed

orual · orual · commit 1f18b2d96530 · 2026-01-07T13:09:05.000-05:00
diff --git a/crates/weaver-editor-browser/src/dom_sync.rs b/crates/weaver-editor-browser/src/dom_sync.rs
@@ -611,10 +611,15 @@ pub fn update_paragraph_dom(
                 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;
+                }
             }
         }
     }
diff --git a/crates/weaver-editor-core/src/writer/events.rs b/crates/weaver-editor-core/src/writer/events.rs
@@ -4,7 +4,7 @@ use core::fmt;
 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;
@@ -58,6 +58,24 @@ where
                 // 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)?;
@@ -79,16 +97,31 @@ where
             // 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() {
@@ -125,7 +158,7 @@ where
             }
         }
 
-        // 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()
@@ -139,6 +172,48 @@ where
                 .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
         let html_segments = self.writer.into_segments();
 
diff --git a/crates/weaver-editor-core/src/writer/state.rs b/crates/weaver-editor-core/src/writer/state.rs
@@ -163,6 +163,9 @@ pub struct ParagraphTracker {
     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)
diff --git a/crates/weaver-editor-core/src/writer/tags.rs b/crates/weaver-editor-core/src/writer/tags.rs
@@ -147,11 +147,15 @@ where
         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();
 
@@ -189,11 +193,15 @@ where
                 // 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();
@@ -273,10 +281,14 @@ where
                 // 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()?;
@@ -435,9 +447,13 @@ where
             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()?;
@@ -511,9 +527,13 @@ where
             }
             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>")
@@ -523,9 +543,13 @@ where
             }
             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=\"")?;
@@ -537,9 +561,13 @@ where
             }
             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>")
diff --git a/crates/weaver-renderer/src/lib.rs b/crates/weaver-renderer/src/lib.rs
@@ -35,7 +35,7 @@ pub mod leaflet;
 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;
diff --git a/crates/weaver-renderer/src/static_site.rs b/crates/weaver-renderer/src/static_site.rs
@@ -231,6 +231,7 @@ where
         Ok(())
     }
 
+    #[cfg(feature = "syntax-css")]
     async fn generate_css_files(&self) -> Result<(), miette::Report> {
         use crate::css::{generate_base_css, generate_syntax_css};
 
@@ -257,6 +258,13 @@ where
         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> {
         let index_path = self.context.destination.join("index.html");
         let mut index_file = crate::utils::create_file(&index_path).await?;
diff --git a/crates/weaver-renderer/src/static_site/document.rs b/crates/weaver-renderer/src/static_site/document.rs
@@ -1,3 +1,4 @@
+#[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;
@@ -97,6 +98,7 @@ pub async fn write_document_head<A: AgentSession>(
                 .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);
@@ -116,6 +118,13 @@ pub async fn write_document_head<A: AgentSession>(
                 .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"
+            ));
+        }
     }
 
     // KaTeX if enabled
diff --git a/docs/graph-data.json b/docs/graph-data.json

Original file line number	Diff line number	Diff line change
`@@ -611,10 +611,15 @@ pub fn update_paragraph_dom(`
`611`	`611`	`let _ = div.set_attribute("data-hash", &new_hash);`
`612`	`612`	`let div_node: &web_sys::Node = div.as_ref();`
`613`	`613`	`let _ = editor.insert_before(div_node, cursor_node.as_ref());`
`614`		`- }`
`615`	`614`
`616`		`- if is_cursor_para {`
`617`		`- cursor_para_updated = true;`
	`615`	`+ if is_cursor_para {`
	`616`	`+ if let Err(e) =`
	`617`	`+ restore_cursor_position(cursor_offset, &new_para.offset_map, None)`
	`618`	`+ {`
	`619`	`+ tracing::warn!("Cursor restore for new paragraph failed: {:?}", e);`
	`620`	`+ }`
	`621`	`+ cursor_para_updated = true;`
	`622`	`+ }`
`618`	`623`	`}`
`619`	`624`	`}`
`620`	`625`	`}`