some further cleanup

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

···
 //! The main MarkdownEditor component.
 
-#[allow(unused_imports)]
 use super::actions::{
-    EditorAction, Key, KeyCombo, KeybindingConfig, KeydownResult, Range, execute_action,
-    handle_keydown_with_bindings,
+    EditorAction, KeydownResult, Range, execute_action, handle_keydown_with_bindings,
 };
-use super::document::{CompositionState, LoadedDocState, SignalEditorDocument};
+use super::document::SignalEditorDocument;
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 use super::dom_sync::update_paragraph_dom;
-use super::dom_sync::{sync_cursor_from_dom, sync_cursor_from_dom_with_direction};
-#[allow(unused_imports)]
-use super::publish::{LoadedEntry, PublishButton, load_entry_for_editing};
+use super::publish::PublishButton;
 use super::remote_cursors::RemoteCursors;
 use super::storage;
-use super::sync::{SyncStatus, load_and_merge_document};
+use super::sync::{LoadEditorResult, SyncStatus, load_editor_state};
 use super::toolbar::EditorToolbar;
 use crate::auth::AuthState;
 use crate::components::collab::CollaboratorAvatars;
-use crate::components::editor::ReportButton;
 use crate::components::editor::collab::CollabCoordinator;
+use crate::components::editor::{LoadedDocState, ReportButton};
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
 use jacquard::IntoStatic;
-use jacquard::cowstr::ToCowStr;
-use jacquard::identity::resolver::IdentityResolver;
-use jacquard::smol_str::{SmolStr, ToSmolStr};
-use jacquard::types::aturi::AtUri;
+use jacquard::smol_str::SmolStr;
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 use jacquard::types::blob::BlobRef;
-use jacquard::types::ident::AtIdentifier;
-use weaver_api::sh_weaver::embed::images::Image;
-use weaver_common::WeaverExt;
-#[allow(unused_imports)]
-use weaver_editor_browser::{BeforeInputContext, BeforeInputResult};
-use weaver_editor_browser::{handle_copy, handle_cut, handle_paste};
-use weaver_editor_browser::{platform, update_syntax_visibility};
-use weaver_editor_core::EditorDocument;
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+use weaver_editor_browser::{BeforeInputContext, BeforeInputResult, update_syntax_visibility};
+use weaver_editor_browser::{
+    handle_compositionend, handle_compositionstart, handle_compositionupdate, handle_copy,
+    handle_cut, handle_paste, platform, sync_cursor_and_visibility,
+};
 use weaver_editor_core::EditorImageResolver;
-#[allow(unused_imports)]
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 use weaver_editor_core::InputType;
 use weaver_editor_core::ParagraphRender;
 use weaver_editor_core::SnapDirection;
 use weaver_editor_core::apply_formatting;
 
-/// Result of loading document state.
-enum LoadResult {
-    /// Document state loaded (may be merged from PDS + localStorage)
-    Loaded(LoadedDocState),
-    /// Loading failed
-    Failed(String),
-    /// Still loading
-    #[allow(dead_code)]
-    Loading,
-}
-
 /// Wrapper component that handles loading document state before rendering the editor.
 ///
 /// Loads and merges state from:
···
         let target_notebook = target_notebook.clone();
 
         async move {
-            // Resolve target_notebook to a URI if provided
-            let notebook_uri: Option<SmolStr> = if let Some(ref title) = target_notebook {
-                if let Some(did) = fetcher.current_did().await {
-                    let ident = jacquard::types::ident::AtIdentifier::Did(did);
-                    match fetcher.get_notebook(ident, title.clone()).await {
-                        Ok(Some(notebook_data)) => Some(notebook_data.0.uri.to_smolstr()),
-                        Ok(None) | Err(_) => {
-                            tracing::debug!("Could not resolve notebook '{}' to URI", title);
-                            None
-                        }
-                    }
-                } else {
-                    None
-                }
-            } else {
-                None
-            };
-
-            match load_and_merge_document(&fetcher, &draft_key, entry_uri.as_ref()).await {
-                Ok(Some(mut state)) => {
-                    tracing::debug!("Loaded merged document state");
-                    // If we resolved a notebook URI and state doesn't have one, use it
-                    if state.notebook_uri.is_none() {
-                        state.notebook_uri = notebook_uri;
-                    }
-                    return LoadResult::Loaded(state);
-                }
-                Ok(None) => {
-                    // No existing state - check if we need to load entry content
-                    if let Some(ref uri) = entry_uri {
-                        // Check that this entry belongs to the current user
-                        if let Some(current_did) = fetcher.current_did().await {
-                            let entry_authority = uri.authority();
-                            let is_own_entry = match entry_authority {
-                                AtIdentifier::Did(did) => did == &current_did,
-                                AtIdentifier::Handle(handle) => {
-                                    match fetcher.client.resolve_handle(handle).await {
-                                        Ok(resolved_did) => resolved_did == current_did,
-                                        Err(_) => false,
-                                    }
-                                }
-                            };
-                            if !is_own_entry {
-                                tracing::warn!(
-                                    "Cannot edit entry belonging to another user: {}",
-                                    entry_authority
-                                );
-                                return LoadResult::Failed(
-                                    "You can only edit your own entries".to_string(),
-                                );
-                            }
-                        }
-                        match load_entry_for_editing(&fetcher, uri).await {
-                            Ok(loaded) => {
-                                // Create LoadedDocState from entry
-                                let doc = loro::LoroDoc::new();
-                                let content = doc.get_text("content");
-                                let title = doc.get_text("title");
-                                let path = doc.get_text("path");
-                                let tags = doc.get_list("tags");
-
-                                content.insert(0, loaded.entry.content.as_ref()).ok();
-                                title.insert(0, loaded.entry.title.as_ref()).ok();
-                                path.insert(0, loaded.entry.path.as_ref()).ok();
-                                if let Some(ref entry_tags) = loaded.entry.tags {
-                                    for tag in entry_tags {
-                                        let tag_str: &str = tag.as_ref();
-                                        tags.push(tag_str).ok();
-                                    }
-                                }
-
-                                // Restore existing embeds from the entry
-                                if let Some(ref embeds) = loaded.entry.embeds {
-                                    let embeds_map = doc.get_map("embeds");
-
-                                    // Restore images
-                                    if let Some(ref images) = embeds.images {
-                                        let images_list = embeds_map
-                                            .get_or_create_container(
-                                                "images",
-                                                loro::LoroList::new(),
-                                            )
-                                            .expect("images list");
-                                        for image in &images.images {
-                                            // Serialize image to JSON and add to list
-                                            // No publishedBlobUri since these are already published
-                                            let json = serde_json::to_value(image)
-                                                .expect("Image serializes");
-                                            images_list.push(json).ok();
-                                        }
-                                    }
-
-                                    // Restore record embeds
-                                    if let Some(ref records) = embeds.records {
-                                        let records_list = embeds_map
-                                            .get_or_create_container(
-                                                "records",
-                                                loro::LoroList::new(),
-                                            )
-                                            .expect("records list");
-                                        for record in &records.records {
-                                            let json = serde_json::to_value(record)
-                                                .expect("RecordEmbed serializes");
-                                            records_list.push(json).ok();
-                                        }
-                                    }
-                                }
-
-                                doc.commit();
-
-                                // Pre-warm blob cache for images
-                                #[cfg(feature = "fullstack-server")]
-                                if let Some(ref embeds) = loaded.entry.embeds {
-                                    if let Some(ref images) = embeds.images {
-                                        let ident: &str = match uri.authority() {
-                                            AtIdentifier::Did(d) => d.as_ref(),
-                                            AtIdentifier::Handle(h) => h.as_ref(),
-                                        };
-                                        for image in &images.images {
-                                            let cid = image.image.blob().cid();
-                                            let name = image.name.as_ref().map(|n| n.as_ref());
-                                            if let Err(e) = crate::data::cache_blob(
-                                                ident.into(),
-                                                cid.as_ref().into(),
-                                                name.map(|n| n.into()),
-                                            )
-                                            .await
-                                            {
-                                                tracing::warn!(
-                                                    "Failed to pre-warm blob cache for {}: {}",
-                                                    cid,
-                                                    e
-                                                );
-                                            }
-                                        }
-                                    }
-                                }
-
-                                // Pre-fetch embeds for initial render
-                                let mut resolved_content =
-                                    weaver_common::ResolvedContent::default();
-                                if let Some(ref embeds) = loaded.entry.embeds {
-                                    if let Some(ref records) = embeds.records {
-                                        for record in &records.records {
-                                            // name is the key used in markdown, fallback to record.uri
-                                            let key_uri = if let Some(ref name) = record.name {
-                                                match jacquard::types::string::AtUri::new(
-                                                    name.as_ref(),
-                                                ) {
-                                                    Ok(uri) => uri.into_static(),
-                                                    Err(_) => continue,
-                                                }
-                                            } else {
-                                                record.record.uri.clone().into_static()
-                                            };
-
-                                            match weaver_renderer::atproto::fetch_and_render(
-                                                &record.record.uri,
-                                                &fetcher,
-                                            )
-                                            .await
-                                            {
-                                                Ok(html) => {
-                                                    resolved_content.add_embed(key_uri, html, None);
-                                                }
-                                                Err(e) => {
-                                                    tracing::warn!(
-                                                        "Failed to pre-fetch embed {}: {}",
-                                                        record.record.uri,
-                                                        e
-                                                    );
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                                if resolved_content.embed_content.is_empty() {
-                                    use weaver_common::{ExtractedRef, collect_refs_from_markdown};
-
-                                    let text = doc.get_text("content");
-                                    let markdown = text.to_string();
-
-                                    if !markdown.is_empty() {
-                                        tracing::debug!(
-                                            "Falling back to markdown parsing for embeds"
-                                        );
-                                        let refs = collect_refs_from_markdown(&markdown);
-
-                                        for extracted in refs {
-                                            if let ExtractedRef::AtEmbed { uri, .. } = extracted {
-                                                let key_uri = match AtUri::new(&uri) {
-                                                    Ok(u) => u.into_static(),
-                                                    Err(_) => continue,
-                                                };
-
-                                                match weaver_renderer::atproto::fetch_and_render(
-                                                    &key_uri, &fetcher,
-                                                )
-                                                .await
-                                                {
-                                                    Ok(html) => {
-                                                        tracing::debug!(
-                                                            "Pre-fetched embed from markdown: {}",
-                                                            uri
-                                                        );
-                                                        resolved_content
-                                                            .add_embed(key_uri, html, None);
-                                                    }
-                                                    Err(e) => {
-                                                        tracing::warn!(
-                                                            "Failed to pre-fetch embed {}: {}",
-                                                            uri,
-                                                            e
-                                                        );
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-
-                                return LoadResult::Loaded(LoadedDocState {
-                                    doc,
-                                    entry_ref: Some(loaded.entry_ref),
-                                    edit_root: None,
-                                    last_diff: None,
-                                    synced_version: None, // Fresh from entry, never synced
-                                    last_seen_diffs: std::collections::HashMap::new(),
-                                    resolved_content,
-                                    notebook_uri: notebook_uri.clone(),
-                                });
-                            }
-                            Err(e) => {
-                                tracing::error!("Failed to load entry: {}", e);
-                                return LoadResult::Failed(e.to_string());
-                            }
-                        }
-                    }
-
-                    // New document with initial content
-                    let doc = loro::LoroDoc::new();
-                    if let Some(ref content) = initial_content {
-                        let text = doc.get_text("content");
-                        text.insert(0, content).ok();
-                        doc.commit();
-                    }
-
-                    LoadResult::Loaded(LoadedDocState {
-                        doc,
-                        entry_ref: None,
-                        edit_root: None,
-                        last_diff: None,
-                        synced_version: None, // New doc, never synced
-                        last_seen_diffs: std::collections::HashMap::new(),
-                        resolved_content: weaver_common::ResolvedContent::default(),
-                        notebook_uri,
-                    })
-                }
-                Err(e) => {
-                    tracing::error!("Failed to load document state: {}", e);
-                    LoadResult::Failed(e.to_string())
-                }
-            }
+            load_editor_state(
+                &fetcher,
+                &draft_key,
+                entry_uri.as_ref(),
+                initial_content.as_deref(),
+                target_notebook.as_deref(),
+            )
+            .await
         }
     });
 
     match &*load_resource.read() {
-        Some(LoadResult::Loaded(state)) => {
+        Some(LoadEditorResult::Loaded(state)) => {
             rsx! {
                 MarkdownEditorInner {
                     key: "{draft_key_for_render}",
···
                 }
             }
         }
-        Some(LoadResult::Failed(err)) => {
+        Some(LoadEditorResult::Failed(err)) => {
             rsx! {
                 div { class: "editor-error",
                     "Failed to load: {err}"
                 }
             }
         }
-        Some(LoadResult::Loading) | None => {
+        None => {
             rsx! {
                 div { class: "editor-loading",
                     "Loading..."
···
         let cursor_para_updated =
             update_paragraph_dom(editor_id, &prev, &new_paras, cursor_offset, false);
 
-        // Only restore cursor if we actually re-rendered the paragraph it's in
-        // if cursor_para_updated {
-        //     use wasm_bindgen::JsCast;
-        //     use wasm_bindgen::prelude::*;
-
-        //     // Read and consume pending snap direction
-        //     let snap_direction = doc_for_dom.pending_snap.write().take();
-
-        //     // Use requestAnimationFrame to wait for browser paint
-        //     if let Some(window) = web_sys::window() {
-        //         let closure = Closure::once(move || {
-        //             if let Err(e) = super::cursor::restore_cursor_position(
-        //                 cursor_offset,
-        //                 &map,
-        //                 editor_id,
-        //                 snap_direction,
-        //             ) {
-        //                 tracing::warn!("Cursor restoration failed: {:?}", e);
-        //             }
-        //         });
-
-        //         let _ = window.request_animation_frame(closure.as_ref().unchecked_ref());
-        //         closure.forget();
-        //     }
-        // }
-
         // Store for next comparison AND for event handlers (write-only, no reactive read)
         cached_paragraphs.set(new_paras.clone());
 
···
 
                         Timeout::new(20, move || {
                             let paras = paras();
-                            sync_cursor_from_dom(&mut doc_for_timeout, editor_id, &paras);
+                            weaver_editor_browser::sync_cursor_from_dom(
+                                &mut doc_for_timeout,
+                                editor_id,
+                                &paras,
+                                None,
+                            );
                         })
                         .forget(); // One-shot timer, runs and cleans up
                     }
···
                                         "onkeyup navigation - syncing cursor from DOM"
                                     );
                                     let paras = cached_paragraphs();
-                                    if let Some(dir) = direction_hint {
-                                        sync_cursor_from_dom_with_direction(&mut doc, editor_id, &paras, Some(dir));
-                                    } else {
-                                        sync_cursor_from_dom(&mut doc, editor_id, &paras);
-                                    }
                                     let spans = syntax_spans();
-                                    let cursor_offset = doc.cursor.read().offset;
-                                    let selection = *doc.selection.read();
-                                    update_syntax_visibility(
-                                        cursor_offset,
-                                        selection.as_ref(),
-                                        &spans,
-                                        &paras,
+                                    sync_cursor_and_visibility(
+                                        &mut doc, editor_id, &paras, &spans, direction_hint,
                                     );
                                 }
                             }
···
                             move |_evt| {
                                 tracing::debug!("onselect fired - syncing cursor from DOM");
                                 let paras = cached_paragraphs();
-                                sync_cursor_from_dom(&mut doc, editor_id, &paras);
                                 let spans = syntax_spans();
-                                let cursor_offset = doc.cursor.read().offset;
-                                let selection = *doc.selection.read();
-                                update_syntax_visibility(
-                                    cursor_offset,
-                                    selection.as_ref(),
-                                    &spans,
-                                    &paras,
-                                );
+                                sync_cursor_and_visibility(&mut doc, editor_id, &paras, &spans, None);
                             }
                         },
 
···
                             move |_evt| {
                                 tracing::debug!("onselectstart fired - syncing cursor from DOM");
                                 let paras = cached_paragraphs();
-                                sync_cursor_from_dom(&mut doc, editor_id, &paras);
                                 let spans = syntax_spans();
-                                let cursor_offset = doc.cursor.read().offset;
-                                let selection = *doc.selection.read();
-                                update_syntax_visibility(
-                                    cursor_offset,
-                                    selection.as_ref(),
-                                    &spans,
-                                    &paras,
-                                );
+                                sync_cursor_and_visibility(&mut doc, editor_id, &paras, &spans, None);
                             }
                         },
 
···
                             move |_evt| {
                                 tracing::debug!("onselectionchange fired - syncing cursor from DOM");
                                 let paras = cached_paragraphs();
-                                sync_cursor_from_dom(&mut doc, editor_id, &paras);
                                 let spans = syntax_spans();
-                                let cursor_offset = doc.cursor.read().offset;
-                                let selection = *doc.selection.read();
-                                update_syntax_visibility(
-                                    cursor_offset,
-                                    selection.as_ref(),
-                                    &spans,
-                                    &paras,
-                                );
+                                sync_cursor_and_visibility(&mut doc, editor_id, &paras, &spans, None);
                             }
                         },
 
···
                                     }
                                 }
 
-                                sync_cursor_from_dom(&mut doc, editor_id, &paras);
-                                let cursor_offset = doc.cursor.read().offset;
-                                let selection = *doc.selection.read();
-                                update_syntax_visibility(cursor_offset, selection.as_ref(), &spans, &paras);
+                                sync_cursor_and_visibility(&mut doc, editor_id, &paras, &spans, None);
                             }
                         },
 
···
                         oncompositionstart: {
                             let mut doc = document.clone();
                             move |evt: CompositionEvent| {
-                                let data = evt.data().data();
-                                tracing::trace!(
-                                    data = %data,
-                                    "compositionstart"
-                                );
-                                // Delete selection if present (composition replaces it)
-                                let sel = doc.selection.write().take();
-                                if let Some(sel) = sel {
-                                    let (start, end) =
-                                        (sel.anchor.min(sel.head), sel.anchor.max(sel.head));
-                                    tracing::trace!(
-                                        start,
-                                        end,
-                                        "compositionstart: deleting selection"
-                                    );
-                                    let _ = doc.remove_tracked(start, end.saturating_sub(start));
-                                    doc.cursor.write().offset = start;
-                                }
-
-                                let cursor_offset = doc.cursor.read().offset;
-                                tracing::trace!(
-                                    cursor = cursor_offset,
-                                    "compositionstart: setting composition state"
-                                );
-                                doc.composition.set(Some(CompositionState {
-                                    start_offset: cursor_offset,
-                                    text: data,
-                                }));
+                                handle_compositionstart(evt, &mut doc);
                             }
                         },
 
                         oncompositionupdate: {
                             let mut doc = document.clone();
                             move |evt: CompositionEvent| {
-                                let data = evt.data().data();
-                                tracing::trace!(
-                                    data = %data,
-                                    "compositionupdate"
-                                );
-                                let mut comp_guard = doc.composition.write();
-                                if let Some(ref mut comp) = *comp_guard {
-                                    comp.text = data;
-                                } else {
-                                    tracing::debug!("compositionupdate without active composition state");
-                                }
+                                handle_compositionupdate(evt, &mut doc);
                             }
                         },
 
                         oncompositionend: {
                             let mut doc = document.clone();
                             move |evt: CompositionEvent| {
-                                let final_text = evt.data().data();
-                                tracing::trace!(
-                                    data = %final_text,
-                                    "compositionend"
-                                );
-                                // Record when composition ended for Safari timing workaround
-                                doc.composition_ended_at.set(Some(web_time::Instant::now()));
-
-                                let comp = doc.composition.write().take();
-                                if let Some(comp) = comp {
-                                    tracing::debug!(
-                                        start_offset = comp.start_offset,
-                                        final_text = %final_text,
-                                        chars = final_text.chars().count(),
-                                        "compositionend: inserting text"
-                                    );
-
-                                    if !final_text.is_empty() {
-                                        let mut delete_start = comp.start_offset;
-                                        while delete_start > 0 {
-                                            match doc.char_at(delete_start - 1) {
-                                                Some('\u{200C}') | Some('\u{200B}') => delete_start -= 1,
-                                                _ => break,
-                                            }
-                                        }
-
-                                        let cursor_offset = doc.cursor.read().offset;
-                                        let zw_count = 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.write().offset = delete_start + final_text.chars().count();
-                                        } else if cursor_offset == doc.len_chars() {
-                                            // Fast path: append at end
-                                            let _ = doc.push_tracked(&final_text);
-                                            doc.cursor.write().offset = comp.start_offset + final_text.chars().count();
-                                        } else {
-                                            let _ = doc.insert_tracked(cursor_offset, &final_text);
-                                            doc.cursor.write().offset = comp.start_offset + final_text.chars().count();
-                                        }
-                                    }
-                                } else {
-                                    tracing::debug!("compositionend without active composition state");
-                                }
+                                handle_compositionend(evt, &mut doc);
                             }
                         },
                         }
···
                     on_image: {
                         let mut doc = document.clone();
                         move |uploaded: super::image_upload::UploadedImage| {
-                            // Build data URL for immediate preview
-                            use base64::{Engine, engine::general_purpose::STANDARD};
-                            let data_url = format!(
-                                "data:{};base64,{}",
-                                uploaded.mime_type,
-                                STANDARD.encode(&uploaded.data)
+                            super::image_upload::handle_image_upload(
+                                uploaded,
+                                &mut doc,
+                                &mut image_resolver,
+                                &auth_state,
+                                &fetcher,
                             );
-
-                            // Add to resolver for immediate display
-                            let name = uploaded.name.clone();
-                            image_resolver.with_mut(|resolver| {
-                                resolver.add_pending(name.clone(), data_url);
-                            });
-
-                            // Insert markdown image syntax at cursor
-                            let alt_text = if uploaded.alt.is_empty() {
-                                name.clone()
-                            } else {
-                                uploaded.alt.clone()
-                            };
-
-                            // Check if authenticated and get DID for draft path
-                            let auth = auth_state.read();
-                            let did_for_path = auth.did.clone();
-                            let is_authenticated = auth.is_authenticated();
-                            drop(auth);
-
-                            // Pre-generate TID for the blob rkey (used in draft path and upload)
-                            let blob_tid = jacquard::types::tid::Ticker::new().next(None);
-
-                            // Build markdown with proper draft path if authenticated
-                            let markdown = if let Some(ref did) = did_for_path {
-                                format!("![{}](/image/{}/draft/{}/{})", alt_text, did, blob_tid.as_str(), name)
-                            } else {
-                                // Fallback for unauthenticated - simple path (won't be publishable anyway)
-                                format!("![{}](/image/{})", alt_text, name)
-                            };
-
-                            let pos = doc.cursor.read().offset;
-                            let _ = doc.insert_tracked(pos, &markdown);
-                            doc.cursor.write().offset = pos + markdown.chars().count();
-
-                            // Upload to PDS in background if authenticated
-                            if is_authenticated {
-                                let fetcher = fetcher.clone();
-                                let name_for_upload = name.clone();
-                                let alt_for_upload = alt_text.clone();
-                                let data = uploaded.data.clone();
-                                let mut doc_for_spawn = doc.clone();
-
-                                spawn(async move {
-                                    let client = fetcher.get_client();
-
-                                    // Clone data for cache pre-warming
-                                    let data_for_cache = data.clone();
-
-                                    // Use pre-generated TID as rkey for the blob record
-                                    let rkey = jacquard::types::recordkey::RecordKey::any(blob_tid.as_str())
-                                        .expect("TID is valid record key");
-
-                                    // Upload blob and create temporary PublishedBlob record
-                                    match client.publish_blob(data, &name_for_upload, Some(rkey)).await {
-                                        Ok((strong_ref, published_blob)) => {
-                                            // Get DID from fetcher
-                                            let did = match fetcher.current_did().await {
-                                                Some(d) => d,
-                                                None => {
-                                                    tracing::warn!("No DID available");
-                                                    return;
-                                                }
-                                            };
-
-                                            // Extract rkey from the AT-URI
-                                            let blob_rkey = match strong_ref.uri.rkey() {
-                                                Some(rkey) => rkey.0.clone().into_static(),
-                                                None => {
-                                                    tracing::warn!("No rkey in PublishedBlob URI");
-                                                    return;
-                                                }
-                                            };
-
-                                            let cid = published_blob.upload.blob().cid().clone().into_static();
-
-                                            let name_for_resolver = name_for_upload.clone();
-                                            let image = Image::new()
-                                                .alt(alt_for_upload.to_cowstr())
-                                                .image(published_blob.upload)
-                                                .name(name_for_upload.to_cowstr())
-                                                .build();
-                                            doc_for_spawn.add_image(&image, Some(&strong_ref.uri));
-
-                                            // Promote from pending to uploaded in resolver
-                                            let ident = AtIdentifier::Did(did);
-                                            image_resolver.with_mut(|resolver| {
-                                                resolver.promote_to_uploaded(
-                                                    &name_for_resolver,
-                                                    blob_rkey,
-                                                    ident,
-                                                );
-                                            });
-
-                                            tracing::info!(name = %name_for_resolver, "Image uploaded to PDS");
-
-                                            // Pre-warm server cache with blob bytes
-                                            #[cfg(feature = "fullstack-server")]
-                                            {
-                                                use jacquard::smol_str::ToSmolStr;
-                                                if let Err(e) = crate::data::cache_blob_bytes(
-                                                    cid.to_smolstr(),
-                                                    Some(name_for_resolver.into()),
-                                                    None,
-                                                    data_for_cache.into(),
-                                                ).await {
-                                                    tracing::warn!(error = %e, "Failed to pre-warm blob cache");
-                                                }
-                                            }
-                                        }
-                                        Err(e) => {
-                                            tracing::error!(error = %e, "Failed to upload image");
-                                            // Image stays as data URL - will work for preview but not publish
-                                        }
-                                    }
-                                });
-                            } else {
-                                tracing::debug!(name = %name, "Image added with data URL (not authenticated)");
-                            }
                         }
                     },
                 }

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

···
         self.composition.set(composition);
     }
 
+    fn composition_ended_at(&self) -> Option<web_time::Instant> {
+        *self.composition_ended_at.read()
+    }
+
+    fn set_composition_ended_now(&mut self) {
+        self.composition_ended_at.set(Some(web_time::Instant::now()));
+    }
+
     fn undo(&mut self) -> bool {
         // Sync Loro cursor to current position BEFORE undo
         // so it tracks through the undo operation.

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

···
 //! DOM synchronization for the markdown editor.
 //!
-//! Handles syncing cursor/selection state between the browser DOM and our
-//! internal document model, and updating paragraph DOM elements.
-//!
-//! Most DOM sync logic is in `weaver_editor_browser`. This module provides
-//! thin wrappers that work with `SignalEditorDocument` directly.
-
-#[allow(unused_imports)]
-use super::document::Selection;
-#[allow(unused_imports)]
-use super::document::SignalEditorDocument;
-#[allow(unused_imports)]
-use dioxus::prelude::*;
-use weaver_editor_core::ParagraphRender;
-#[allow(unused_imports)]
-use weaver_editor_core::SnapDirection;
+//! Most DOM sync logic is in `weaver_editor_browser`. This module re-exports
+//! the `update_paragraph_dom` function for use in the editor component.
 
 // Re-export from browser crate.
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-pub use weaver_editor_browser::{dom_position_to_text_offset, update_paragraph_dom};
-
-/// Sync internal cursor and selection state from browser DOM selection.
-///
-/// The optional `direction_hint` is used when snapping cursor from invisible content.
-/// Pass `SnapDirection::Backward` for left/up arrow keys, `SnapDirection::Forward` for right/down.
-#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-pub fn sync_cursor_from_dom(
-    doc: &mut SignalEditorDocument,
-    editor_id: &str,
-    paragraphs: &[ParagraphRender],
-) {
-    sync_cursor_from_dom_with_direction(doc, editor_id, paragraphs, None);
-}
-
-/// Sync cursor with optional direction hint for snapping.
-///
-/// Use this when handling arrow keys to ensure cursor snaps in the expected direction.
-#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-pub fn sync_cursor_from_dom_with_direction(
-    doc: &mut SignalEditorDocument,
-    editor_id: &str,
-    paragraphs: &[ParagraphRender],
-    direction_hint: Option<SnapDirection>,
-) {
-    use wasm_bindgen::JsCast;
-
-    // Early return if paragraphs not yet populated (first render edge case)
-    if paragraphs.is_empty() {
-        return;
-    }
-
-    let window = match web_sys::window() {
-        Some(w) => w,
-        None => return,
-    };
-
-    let dom_document = match window.document() {
-        Some(d) => d,
-        None => return,
-    };
-
-    let editor_element = match dom_document.get_element_by_id(editor_id) {
-        Some(e) => e,
-        None => return,
-    };
-
-    let selection = match window.get_selection() {
-        Ok(Some(sel)) => sel,
-        _ => return,
-    };
-
-    // Get both anchor (selection start) and focus (selection end) positions
-    let anchor_node = match selection.anchor_node() {
-        Some(node) => node,
-        None => return,
-    };
-    let focus_node = match selection.focus_node() {
-        Some(node) => node,
-        None => return,
-    };
-    let anchor_offset = selection.anchor_offset() as usize;
-    let focus_offset = selection.focus_offset() as usize;
-
-    let anchor_rope = dom_position_to_text_offset(
-        &dom_document,
-        &editor_element,
-        &anchor_node,
-        anchor_offset,
-        paragraphs,
-        direction_hint,
-    );
-    let focus_rope = dom_position_to_text_offset(
-        &dom_document,
-        &editor_element,
-        &focus_node,
-        focus_offset,
-        paragraphs,
-        direction_hint,
-    );
-
-    match (anchor_rope, focus_rope) {
-        (Some(anchor), Some(focus)) => {
-            let old_offset = doc.cursor.read().offset;
-            // Warn if cursor is jumping a large distance - likely a bug
-            let jump = if focus > old_offset {
-                focus - old_offset
-            } else {
-                old_offset - focus
-            };
-            if jump > 100 {
-                tracing::warn!(
-                    old_offset,
-                    new_offset = focus,
-                    jump,
-                    "sync_cursor_from_dom: LARGE CURSOR JUMP detected"
-                );
-            }
-            doc.cursor.write().offset = focus;
-            if anchor != focus {
-                doc.selection.set(Some(Selection {
-                    anchor,
-                    head: focus,
-                }));
-            } else {
-                doc.selection.set(None);
-            }
-        }
-        _ => {
-            tracing::warn!("Could not map DOM selection to rope offsets");
-        }
-    }
-}
-
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
-pub fn sync_cursor_from_dom(
-    _document: &mut SignalEditorDocument,
-    _editor_id: &str,
-    _paragraphs: &[ParagraphRender],
-) {
-}
-
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
-pub fn sync_cursor_from_dom_with_direction(
-    _document: &mut SignalEditorDocument,
-    _editor_id: &str,
-    _paragraphs: &[ParagraphRender],
-    _direction_hint: Option<SnapDirection>,
-) {
-}
+pub use weaver_editor_browser::update_paragraph_dom;

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

···
 
 use base64::{Engine, engine::general_purpose::STANDARD};
 use dioxus::prelude::*;
-use jacquard::bytes::Bytes;
+use jacquard::IntoStatic;
+use jacquard::cowstr::ToCowStr;
+use jacquard::types::ident::AtIdentifier;
+use jacquard::{bytes::Bytes, types::tid::Tid};
 use mime_sniffer::MimeTypeSniffer;
+
+use super::document::SignalEditorDocument;
+use crate::auth::AuthState;
+use crate::fetch::Fetcher;
+use weaver_api::sh_weaver::embed::images::Image;
+use weaver_editor_core::{EditorDocument, EditorImageResolver};
 
 use crate::components::{
     button::{Button, ButtonVariant},
···
         }
     }
 }
+
+/// Handle an uploaded image: add to resolver, insert markdown, and upload to PDS.
+///
+/// This is the main handler for when an image is confirmed via the upload dialog.
+/// It:
+/// 1. Creates a data URL for immediate preview
+/// 2. Adds to the image resolver for display
+/// 3. Inserts markdown image syntax at cursor
+/// 4. If authenticated, uploads to PDS in background
+#[allow(clippy::too_many_arguments)]
+pub fn handle_image_upload(
+    uploaded: UploadedImage,
+    doc: &mut SignalEditorDocument,
+    image_resolver: &mut Signal<EditorImageResolver>,
+    auth_state: &Signal<AuthState>,
+    fetcher: &Fetcher,
+) {
+    // Build data URL for immediate preview.
+    let data_url = format!(
+        "data:{};base64,{}",
+        uploaded.mime_type,
+        STANDARD.encode(&uploaded.data)
+    );
+
+    // Add to resolver for immediate display.
+    let name = uploaded.name.clone();
+    image_resolver.with_mut(|resolver| {
+        resolver.add_pending(name.clone(), data_url);
+    });
+
+    // Insert markdown image syntax at cursor.
+    let alt_text = if uploaded.alt.is_empty() {
+        name.clone()
+    } else {
+        uploaded.alt.clone()
+    };
+
+    // Check if authenticated and get DID for draft path.
+    let auth = auth_state.read();
+    let did_for_path = auth.did.clone();
+    let is_authenticated = auth.is_authenticated();
+    drop(auth);
+
+    // Pre-generate TID for the blob rkey (used in draft path and upload).
+    let blob_tid = jacquard::types::tid::Ticker::new().next(None);
+
+    // Build markdown with proper draft path if authenticated.
+    let markdown = if let Some(ref did) = did_for_path {
+        format!(
+            "![{}](/image/{}/draft/{}/{})",
+            alt_text,
+            did,
+            blob_tid.as_str(),
+            name
+        )
+    } else {
+        // Fallback for unauthenticated - simple path (won't be publishable anyway).
+        format!("![{}](/image/{})", alt_text, name)
+    };
+
+    let pos = doc.cursor_offset();
+    doc.insert(pos, &markdown);
+
+    // Upload to PDS in background if authenticated.
+    if is_authenticated {
+        let fetcher = fetcher.clone();
+        let name_for_upload = name.clone();
+        let alt_for_upload = alt_text.clone();
+        let data = uploaded.data.clone();
+        let mut doc_for_spawn = doc.clone();
+        let mut resolver_for_spawn = *image_resolver;
+
+        spawn(async move {
+            upload_image_to_pds(
+                &fetcher,
+                &mut doc_for_spawn,
+                &mut resolver_for_spawn,
+                data,
+                name_for_upload,
+                alt_for_upload,
+                blob_tid,
+            )
+            .await;
+        });
+    } else {
+        tracing::debug!(name = %name, "Image added with data URL (not authenticated)");
+    }
+}
+
+/// Upload image to PDS and update resolver.
+async fn upload_image_to_pds(
+    fetcher: &Fetcher,
+    doc: &mut SignalEditorDocument,
+    image_resolver: &mut Signal<EditorImageResolver>,
+    data: Bytes,
+    name: String,
+    alt: String,
+    blob_tid: Tid,
+) {
+    let client = fetcher.get_client();
+    use weaver_common::WeaverExt;
+
+    // Clone data for cache pre-warming.
+    #[cfg(feature = "fullstack-server")]
+    let data_for_cache = data.clone();
+
+    // Use pre-generated TID as rkey for the blob record.
+    let rkey = jacquard::types::recordkey::RecordKey::any(blob_tid.as_str())
+        .expect("TID is valid record key");
+
+    // Upload blob and create temporary PublishedBlob record.
+    match client.publish_blob(data, &name, Some(rkey)).await {
+        Ok((strong_ref, published_blob)) => {
+            // Get DID from fetcher.
+            let did = match fetcher.current_did().await {
+                Some(d) => d,
+                None => {
+                    tracing::warn!("No DID available");
+                    return;
+                }
+            };
+
+            // Extract rkey from the AT-URI.
+            let blob_rkey = match strong_ref.uri.rkey() {
+                Some(rkey) => rkey.0.clone().into_static(),
+                None => {
+                    tracing::warn!("No rkey in PublishedBlob URI");
+                    return;
+                }
+            };
+
+            let cid = published_blob.upload.blob().cid().clone().into_static();
+
+            let name_for_resolver = name.clone();
+            let image = Image::new()
+                .alt(alt.to_cowstr())
+                .image(published_blob.upload)
+                .name(name.to_cowstr())
+                .build();
+            doc.add_image(&image, Some(&strong_ref.uri));
+
+            // Promote from pending to uploaded in resolver.
+            let ident = AtIdentifier::Did(did);
+            image_resolver.with_mut(|resolver| {
+                resolver.promote_to_uploaded(&name_for_resolver, blob_rkey, ident);
+            });
+
+            tracing::info!(name = %name_for_resolver, "Image uploaded to PDS");
+
+            // Pre-warm server cache with blob bytes.
+            #[cfg(feature = "fullstack-server")]
+            {
+                use jacquard::smol_str::ToSmolStr;
+                if let Err(e) = crate::data::cache_blob_bytes(
+                    cid.to_smolstr(),
+                    Some(name_for_resolver.into()),
+                    None,
+                    data_for_cache.into(),
+                )
+                .await
+                {
+                    tracing::warn!(error = %e, "Failed to pre-warm blob cache");
+                }
+            }
+
+            // Suppress unused variable warning when fullstack-server is disabled.
+            #[cfg(not(feature = "fullstack-server"))]
+            let _ = cid;
+        }
+        Err(e) => {
+            tracing::error!(error = %e, "Failed to upload image");
+            // Image stays as data URL - will work for preview but not publish.
+        }
+    }
+}

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

···
 use std::collections::HashMap;
 
 use super::document::{LoadedDocState, SignalEditorDocument};
+use super::publish::load_entry_for_editing;
 use crate::fetch::Fetcher;
 use jacquard::IntoStatic;
+use jacquard::identity::resolver::IdentityResolver;
 use jacquard::prelude::*;
+use jacquard::smol_str::{SmolStr, ToSmolStr};
 use jacquard::types::ident::AtIdentifier;
 use jacquard::types::string::{AtUri, Cid};
 use loro::LoroDoc;
···
         }
     }
 }
+
+// === Editor state loading ===
+
+/// Result of loading editor state.
+#[derive(Clone)]
+pub enum LoadEditorResult {
+    /// Document state loaded successfully.
+    Loaded(LoadedDocState),
+    /// Loading failed with error message.
+    Failed(String),
+}
+
+/// Load editor state from various sources.
+///
+/// This function handles the complete loading flow:
+/// 1. Resolves notebook title to URI if provided
+/// 2. Tries to load and merge from localStorage + PDS edit state
+/// 3. Falls back to loading entry content if no edit state exists
+/// 4. Creates new document with initial content if nothing exists
+///
+/// # Arguments
+/// - `fetcher`: The fetcher for API calls
+/// - `draft_key`: Unique key for localStorage (entry URI or "new:{tid}")
+/// - `entry_uri`: Optional AT-URI of existing entry to edit
+/// - `initial_content`: Optional initial markdown for new entries
+/// - `target_notebook`: Optional notebook title to resolve to URI
+pub async fn load_editor_state(
+    fetcher: &Fetcher,
+    draft_key: &str,
+    entry_uri: Option<&AtUri<'static>>,
+    initial_content: Option<&str>,
+    target_notebook: Option<&str>,
+) -> LoadEditorResult {
+    // Resolve target_notebook to a URI if provided.
+    let notebook_uri: Option<SmolStr> = if let Some(title) = target_notebook {
+        if let Some(did) = fetcher.current_did().await {
+            let ident = AtIdentifier::Did(did);
+            match fetcher.get_notebook(ident, title.into()).await {
+                Ok(Some(notebook_data)) => Some(notebook_data.0.uri.to_smolstr()),
+                Ok(None) | Err(_) => {
+                    tracing::debug!("Could not resolve notebook '{}' to URI", title);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    match load_and_merge_document(fetcher, draft_key, entry_uri).await {
+        Ok(Some(mut state)) => {
+            tracing::debug!("Loaded merged document state");
+            if state.notebook_uri.is_none() {
+                state.notebook_uri = notebook_uri;
+            }
+            return LoadEditorResult::Loaded(state);
+        }
+        Ok(None) => {
+            // No existing state - check if we need to load entry content.
+            if let Some(uri) = entry_uri {
+                // Check that this entry belongs to the current user.
+                if let Some(current_did) = fetcher.current_did().await {
+                    let entry_authority = uri.authority();
+                    let is_own_entry = match entry_authority {
+                        AtIdentifier::Did(did) => did == &current_did,
+                        AtIdentifier::Handle(handle) => {
+                            match fetcher.client.resolve_handle(handle).await {
+                                Ok(resolved_did) => resolved_did == current_did,
+                                Err(_) => false,
+                            }
+                        }
+                    };
+                    if !is_own_entry {
+                        tracing::warn!(
+                            "Cannot edit entry belonging to another user: {}",
+                            entry_authority
+                        );
+                        return LoadEditorResult::Failed(
+                            "You can only edit your own entries".to_string(),
+                        );
+                    }
+                }
+
+                match load_entry_for_editing(fetcher, uri).await {
+                    Ok(loaded) => {
+                        return LoadEditorResult::Loaded(
+                            create_state_from_entry(fetcher, &loaded, uri, notebook_uri).await,
+                        );
+                    }
+                    Err(e) => {
+                        tracing::error!("Failed to load entry: {}", e);
+                        return LoadEditorResult::Failed(e.to_string());
+                    }
+                }
+            }
+
+            // New document with initial content.
+            let doc = LoroDoc::new();
+            if let Some(content) = initial_content {
+                let text = doc.get_text("content");
+                text.insert(0, content).ok();
+                doc.commit();
+            }
+
+            LoadEditorResult::Loaded(LoadedDocState {
+                doc,
+                entry_ref: None,
+                edit_root: None,
+                last_diff: None,
+                synced_version: None,
+                last_seen_diffs: HashMap::new(),
+                resolved_content: weaver_common::ResolvedContent::default(),
+                notebook_uri,
+            })
+        }
+        Err(e) => {
+            tracing::error!("Failed to load document state: {}", e);
+            LoadEditorResult::Failed(e.to_string())
+        }
+    }
+}
+
+/// Create LoadedDocState from a loaded entry.
+///
+/// Handles:
+/// - Creating LoroDoc and populating with entry data
+/// - Restoring embeds (images and records)
+/// - Pre-warming blob cache (server feature)
+/// - Pre-fetching embed content for initial render
+async fn create_state_from_entry(
+    fetcher: &Fetcher,
+    loaded: &super::publish::LoadedEntry,
+    uri: &AtUri<'_>,
+    notebook_uri: Option<SmolStr>,
+) -> LoadedDocState {
+    let doc = LoroDoc::new();
+    let content = doc.get_text("content");
+    let title = doc.get_text("title");
+    let path = doc.get_text("path");
+    let tags = doc.get_list("tags");
+
+    content.insert(0, loaded.entry.content.as_ref()).ok();
+    title.insert(0, loaded.entry.title.as_ref()).ok();
+    path.insert(0, loaded.entry.path.as_ref()).ok();
+    if let Some(ref entry_tags) = loaded.entry.tags {
+        for tag in entry_tags {
+            let tag_str: &str = tag.as_ref();
+            tags.push(tag_str).ok();
+        }
+    }
+
+    // Restore existing embeds from the entry.
+    if let Some(ref embeds) = loaded.entry.embeds {
+        let embeds_map = doc.get_map("embeds");
+
+        if let Some(ref images) = embeds.images {
+            let images_list = embeds_map
+                .get_or_create_container("images", loro::LoroList::new())
+                .expect("images list");
+            for image in &images.images {
+                let json = serde_json::to_value(image).expect("Image serializes");
+                images_list.push(json).ok();
+            }
+        }
+
+        if let Some(ref records) = embeds.records {
+            let records_list = embeds_map
+                .get_or_create_container("records", loro::LoroList::new())
+                .expect("records list");
+            for record in &records.records {
+                let json = serde_json::to_value(record).expect("RecordEmbed serializes");
+                records_list.push(json).ok();
+            }
+        }
+    }
+
+    doc.commit();
+
+    // Pre-warm blob cache for images.
+    #[cfg(feature = "fullstack-server")]
+    if let Some(ref embeds) = loaded.entry.embeds {
+        if let Some(ref images) = embeds.images {
+            let ident: &str = match uri.authority() {
+                AtIdentifier::Did(d) => d.as_ref(),
+                AtIdentifier::Handle(h) => h.as_ref(),
+            };
+            for image in &images.images {
+                let cid = image.image.blob().cid();
+                let name = image.name.as_ref().map(|n| n.as_ref());
+                if let Err(e) = crate::data::cache_blob(
+                    ident.into(),
+                    cid.as_ref().into(),
+                    name.map(|n| n.into()),
+                )
+                .await
+                {
+                    tracing::warn!("Failed to pre-warm blob cache for {}: {}", cid, e);
+                }
+            }
+        }
+    }
+
+    // Pre-fetch embeds for initial render.
+    let resolved_content = prefetch_embeds_for_entry(fetcher, &doc, &loaded.entry.embeds).await;
+
+    LoadedDocState {
+        doc,
+        entry_ref: Some(loaded.entry_ref.clone()),
+        edit_root: None,
+        last_diff: None,
+        synced_version: None,
+        last_seen_diffs: HashMap::new(),
+        resolved_content,
+        notebook_uri,
+    }
+}
+
+/// Pre-fetch embed content for an entry being loaded.
+async fn prefetch_embeds_for_entry(
+    fetcher: &Fetcher,
+    doc: &LoroDoc,
+    embeds: &Option<weaver_api::sh_weaver::notebook::entry::EntryEmbeds<'_>>,
+) -> weaver_common::ResolvedContent {
+    use weaver_common::{ExtractedRef, collect_refs_from_markdown};
+
+    let mut resolved_content = weaver_common::ResolvedContent::default();
+
+    if let Some(embeds) = embeds {
+        if let Some(ref records) = embeds.records {
+            for record in &records.records {
+                let key_uri = if let Some(ref name) = record.name {
+                    match AtUri::new(name.as_ref()) {
+                        Ok(uri) => uri.into_static(),
+                        Err(_) => continue,
+                    }
+                } else {
+                    record.record.uri.clone().into_static()
+                };
+
+                match weaver_renderer::atproto::fetch_and_render(&record.record.uri, fetcher).await
+                {
+                    Ok(html) => {
+                        resolved_content.add_embed(key_uri, html, None);
+                    }
+                    Err(e) => {
+                        tracing::warn!("Failed to pre-fetch embed {}: {}", record.record.uri, e);
+                    }
+                }
+            }
+        }
+    }
+
+    // Fall back to parsing markdown if no embeds in record.
+    if resolved_content.embed_content.is_empty() {
+        let text = doc.get_text("content");
+        let markdown = text.to_string();
+
+        if !markdown.is_empty() {
+            tracing::debug!("Falling back to markdown parsing for embeds");
+            let refs = collect_refs_from_markdown(&markdown);
+
+            for extracted in refs {
+                if let ExtractedRef::AtEmbed { uri, .. } = extracted {
+                    let key_uri = match AtUri::new(&uri) {
+                        Ok(u) => u.into_static(),
+                        Err(_) => continue,
+                    };
+
+                    match weaver_renderer::atproto::fetch_and_render(&key_uri, fetcher).await {
+                        Ok(html) => {
+                            tracing::debug!("Pre-fetched embed from markdown: {}", uri);
+                            resolved_content.add_embed(key_uri, html, None);
+                        }
+                        Err(e) => {
+                            tracing::warn!("Failed to pre-fetch embed {}: {}", uri, e);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    resolved_content
+}

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

···
     is_valid_cursor_position,
 };
 
+use weaver_editor_core::{EditorDocument, Selection, SyntaxSpanInfo};
+
 use crate::cursor::restore_cursor_position;
+use crate::update_syntax_visibility;
 
 /// Result of syncing cursor from DOM.
 #[derive(Debug, Clone)]
···
     }
 
     None
+}
+
+/// Sync cursor state from DOM to an EditorDocument.
+///
+/// This is a generic version that works with any `EditorDocument` implementation.
+/// It reads the browser's selection state and updates the document's cursor and selection.
+pub fn sync_cursor_from_dom<D: EditorDocument>(
+    doc: &mut D,
+    editor_id: &str,
+    paragraphs: &[ParagraphRender],
+    direction_hint: Option<SnapDirection>,
+) {
+    if let Some(result) = sync_cursor_from_dom_impl(editor_id, paragraphs, direction_hint) {
+        match result {
+            CursorSyncResult::Cursor(offset) => {
+                doc.set_cursor_offset(offset);
+                doc.set_selection(None);
+            }
+            CursorSyncResult::Selection { anchor, head } => {
+                doc.set_cursor_offset(head);
+                if anchor != head {
+                    doc.set_selection(Some(Selection { anchor, head }));
+                } else {
+                    doc.set_selection(None);
+                }
+            }
+            CursorSyncResult::None => {}
+        }
+    }
+}
+
+/// Sync cursor from DOM and update syntax visibility in one call.
+///
+/// This is the common pattern used by most event handlers: sync the cursor
+/// position from the browser's selection, then update which syntax elements
+/// are visible based on the new cursor position.
+///
+/// Use this for: onclick, onselect, onselectstart, onselectionchange, onkeyup.
+pub fn sync_cursor_and_visibility<D: EditorDocument>(
+    doc: &mut D,
+    editor_id: &str,
+    paragraphs: &[ParagraphRender],
+    syntax_spans: &[SyntaxSpanInfo],
+    direction_hint: Option<SnapDirection>,
+) {
+    sync_cursor_from_dom(doc, editor_id, paragraphs, direction_hint);
+    let cursor_offset = doc.cursor_offset();
+    let selection = doc.selection();
+    update_syntax_visibility(cursor_offset, selection.as_ref(), syntax_spans, paragraphs);
 }
 
 /// Update paragraph DOM elements incrementally.

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

···
         false
     }
 }
+
+// === Composition (IME) event handlers ===
+
+/// Handle composition start event.
+///
+/// Clears any existing selection (composition replaces it) and sets up
+/// composition state tracking.
+#[cfg(feature = "dioxus")]
+pub fn handle_compositionstart<D: EditorDocument>(
+    evt: dioxus_core::Event<dioxus_html::CompositionData>,
+    doc: &mut D,
+) {
+    let data = evt.data().data();
+    tracing::trace!(data = %data, "compositionstart");
+
+    // Delete selection if present (composition replaces it).
+    if let Some(sel) = doc.selection() {
+        let (start, end) = (sel.anchor.min(sel.head), sel.anchor.max(sel.head));
+        tracing::trace!(start, end, "compositionstart: deleting selection");
+        doc.delete(start..end);
+        doc.set_cursor_offset(start);
+        doc.set_selection(None);
+    }
+
+    let cursor_offset = doc.cursor_offset();
+    tracing::trace!(cursor = cursor_offset, "compositionstart: setting composition state");
+    doc.set_composition(Some(weaver_editor_core::CompositionState {
+        start_offset: cursor_offset,
+        text: data,
+    }));
+}
+
+/// Handle composition update event.
+///
+/// Updates the composition text as the user types or selects IME suggestions.
+#[cfg(feature = "dioxus")]
+pub fn handle_compositionupdate<D: EditorDocument>(
+    evt: dioxus_core::Event<dioxus_html::CompositionData>,
+    doc: &mut D,
+) {
+    let data = evt.data().data();
+    tracing::trace!(data = %data, "compositionupdate");
+
+    if let Some(mut comp) = doc.composition() {
+        comp.text = data;
+        doc.set_composition(Some(comp));
+    } else {
+        tracing::debug!("compositionupdate without active composition state");
+    }
+}
+
+/// Handle composition end event.
+///
+/// Finalizes the composition by inserting the final text into the document.
+/// Also handles zero-width character cleanup that some IMEs leave behind.
+#[cfg(feature = "dioxus")]
+pub fn handle_compositionend<D: EditorDocument>(
+    evt: dioxus_core::Event<dioxus_html::CompositionData>,
+    doc: &mut D,
+) {
+    let final_text = evt.data().data();
+    tracing::trace!(data = %final_text, "compositionend");
+
+    // Record when composition ended for Safari timing workaround.
+    doc.set_composition_ended_now();
+
+    let comp = doc.composition();
+    doc.set_composition(None);
+
+    if let Some(comp) = comp {
+        tracing::debug!(
+            start_offset = comp.start_offset,
+            final_text = %final_text,
+            chars = final_text.chars().count(),
+            "compositionend: inserting text"
+        );
+
+        if !final_text.is_empty() {
+            // Clean up zero-width characters that IMEs sometimes leave behind.
+            let mut delete_start = comp.start_offset;
+            while delete_start > 0 {
+                match doc.char_at(delete_start - 1) {
+                    Some('\u{200C}') | Some('\u{200B}') => delete_start -= 1,
+                    _ => break,
+                }
+            }
+
+            let cursor_offset = doc.cursor_offset();
+            let zw_count = cursor_offset - delete_start;
+
+            if zw_count > 0 {
+                // Splice: delete zero-width chars and insert new char in one op.
+                doc.replace(delete_start..delete_start + zw_count, &final_text);
+                doc.set_cursor_offset(delete_start + final_text.chars().count());
+            } else if cursor_offset == doc.len_chars() {
+                // Fast path: append at end.
+                doc.push(&final_text);
+                doc.set_cursor_offset(comp.start_offset + final_text.chars().count());
+            } else {
+                // Insert at cursor position.
+                doc.insert(cursor_offset, &final_text);
+                doc.set_cursor_offset(comp.start_offset + final_text.chars().count());
+            }
+        }
+    } else {
+        tracing::debug!("compositionend without active composition state");
+    }
+}

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

···
 
 // DOM sync types
 pub use dom_sync::{
-    BrowserCursorSync, CursorSyncResult, dom_position_to_text_offset, sync_cursor_from_dom_impl,
-    update_paragraph_dom,
+    BrowserCursorSync, CursorSyncResult, dom_position_to_text_offset, sync_cursor_and_visibility,
+    sync_cursor_from_dom, sync_cursor_from_dom_impl, update_paragraph_dom,
 };
 
 // Event handling
···
 pub use clipboard::{BrowserClipboard, write_html_to_clipboard};
 #[cfg(feature = "dioxus")]
 pub use clipboard::{handle_copy, handle_cut, handle_paste};
+
+// Composition (IME) handlers
+#[cfg(feature = "dioxus")]
+pub use events::{handle_compositionend, handle_compositionstart, handle_compositionupdate};

crates/weaver-editor-core/src/document.rs

···
     /// Set the composition state.
     fn set_composition(&mut self, composition: Option<CompositionState>);
 
+    /// Get the timestamp when composition last ended (Safari timing workaround).
+    ///
+    /// Returns None if composition never ended or implementation doesn't track it.
+    fn composition_ended_at(&self) -> Option<web_time::Instant>;
+
+    /// Record that composition ended now (Safari timing workaround).
+    ///
+    /// Implementations that don't need Safari workarounds can make this a no-op.
+    fn set_composition_ended_now(&mut self);
+
     // === Required: Cursor snap hint ===
 
     /// Get the pending snap direction hint.
···
         edit
     }
 
+    /// Append text at end of document.
+    ///
+    /// This is a fast path for appending - delegates to buffer's push()
+    /// which may have an optimized implementation.
+    fn push(&mut self, text: &str) -> EditInfo {
+        let offset = self.buffer().len_chars();
+        let contains_newline = text.contains('\n');
+        let in_block_syntax_zone = self.is_in_block_syntax_zone(offset);
+
+        self.buffer_mut().push(text);
+
+        let inserted_len = text.chars().count();
+        self.set_cursor_offset(offset + inserted_len);
+
+        let edit = EditInfo {
+            edit_char_pos: offset,
+            inserted_len,
+            deleted_len: 0,
+            contains_newline,
+            in_block_syntax_zone,
+            doc_len_after: self.buffer().len_chars(),
+            timestamp: Instant::now(),
+        };
+
+        self.set_last_edit(Some(edit.clone()));
+        edit
+    }
+
     /// Delete the current selection, if any.
     fn delete_selection(&mut self) -> Option<EditInfo> {
         let sel = self.selection()?;
···
     selection: Option<Selection>,
     last_edit: Option<EditInfo>,
     composition: Option<CompositionState>,
+    composition_ended_at: Option<web_time::Instant>,
     pending_snap: Option<crate::SnapDirection>,
 }
 
···
             selection: None,
             last_edit: None,
             composition: None,
+            composition_ended_at: None,
             pending_snap: None,
         }
     }
···
 
     fn set_composition(&mut self, composition: Option<CompositionState>) {
         self.composition = composition;
+    }
+
+    fn composition_ended_at(&self) -> Option<web_time::Instant> {
+        self.composition_ended_at
+    }
+
+    fn set_composition_ended_now(&mut self) {
+        self.composition_ended_at = Some(web_time::Instant::now());
     }
 
     fn pending_snap(&self) -> Option<crate::SnapDirection> {

crates/weaver-editor-core/src/text.rs

···
     /// Insert text at char offset.
     fn insert(&mut self, char_offset: usize, text: &str);
 
+    /// Append text at end.
+    ///
+    /// Default implementation calls insert at len_chars(). Override if
+    /// the underlying buffer has a more efficient append operation.
+    fn push(&mut self, text: &str) {
+        self.insert(self.len_chars(), text);
+    }
+
     /// Delete char range.
     fn delete(&mut self, char_range: Range<usize>);
 
···
             doc_len_after: self.rope.len_chars(),
             timestamp: Instant::now(),
         });
+    }
+
+    // Ropey's insert is O(log n) regardless of position, so push is the same.
+    // Override for consistency with trait.
+    fn push(&mut self, text: &str) {
+        self.insert(self.rope.len_chars(), text);
     }
 
     fn delete(&mut self, char_range: Range<usize>) {

crates/weaver-editor-crdt/src/buffer.rs

···
         });
     }
 
+    fn push(&mut self, text: &str) {
+        let char_offset = self.content.len_unicode();
+        let contains_newline = text.contains('\n');
+        let in_block_syntax_zone = self.is_in_block_syntax_zone(char_offset);
+
+        self.content.push_str(text).ok();
+
+        self.inner.borrow_mut().last_edit = Some(EditInfo {
+            edit_char_pos: char_offset,
+            inserted_len: text.chars().count(),
+            deleted_len: 0,
+            contains_newline,
+            in_block_syntax_zone,
+            doc_len_after: self.content.len_unicode(),
+            timestamp: Instant::now(),
+        });
+    }
+
     fn slice(&self, char_range: Range<usize>) -> Option<SmolStr> {
         if char_range.end > self.content.len_unicode() {
             return None;

docs/graph-data.json

···
       "created_at": "2026-01-06T17:56:50.444969376-05:00",
       "updated_at": "2026-01-06T17:56:50.444969376-05:00",
       "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 184,
+      "change_id": "179b522e-15d2-44e2-8070-ba5323450d39",
+      "node_type": "outcome",
+      "title": "Clipboard handlers moved to browser crate - handle_paste/cut/copy in clipboard.rs with feature-gated dioxus deps (dioxus-core, dioxus-html, dioxus-web), input.rs deleted from app",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-06T18:54:49.482341819-05:00",
+      "updated_at": "2026-01-06T18:54:49.482341819-05:00",
+      "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 185,
+      "change_id": "57abe043-ecbe-409d-8d0e-3ee2597856b9",
+      "node_type": "outcome",
+      "title": "Math click handler moved to browser crate - handle_math_click() and get_math_click_offset() in events.rs, onclick handler in component.rs simplified from ~35 to ~15 lines",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-06T18:54:54.389267509-05:00",
+      "updated_at": "2026-01-06T18:54:54.389267509-05:00",
+      "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 186,
+      "change_id": "0b0c7b27-0bf2-4587-a2a8-34dfc9be3a28",
+      "node_type": "outcome",
+      "title": "Composition handlers moved to browser crate - handle_compositionstart/update/end in events.rs with feature-gated dioxus, added composition_ended_at to EditorDocument trait for Safari workaround, added push() to TextBuffer and EditorDocument traits",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-06T19:07:41.730306306-05:00",
+      "updated_at": "2026-01-06T19:07:41.730306306-05:00",
+      "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 187,
+      "change_id": "f94e4212-4d47-442d-aedc-bdacaf4babd8",
+      "node_type": "outcome",
+      "title": "Image upload extracted: handle_image_upload() and upload_image_to_pds() in image_upload.rs, component on_image handler reduced from ~130 to ~10 lines",
+      "description": null,
+      "status": "pending",
+      "created_at": "2026-01-06T19:18:49.734649882-05:00",
+      "updated_at": "2026-01-06T19:18:49.734649882-05:00",
+      "metadata_json": "{\"confidence\":95}"
+    },
+    {
+      "id": 188,
+      "change_id": "ff80e6e7-36d0-426f-8db4-a64705ce0376",
+      "node_type": "outcome",
+      "title": "Loading logic extracted: load_editor_state(), create_state_from_entry(), prefetch_embeds_for_entry() in sync.rs. MarkdownEditor reduced from ~350 to ~85 lines",
+      "description": null,
+      "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}"
     }
   ],
   "edges": [
···
       "weight": 1.0,
       "rationale": "Action completed",
       "created_at": "2026-01-06T17:56:55.250053755-05:00"
+    },
+    {
+      "id": 187,
+      "from_node_id": 182,
+      "to_node_id": 184,
+      "from_change_id": "7a9e3b35-e3c2-4081-8e62-74da292b1c08",
+      "to_change_id": "179b522e-15d2-44e2-8070-ba5323450d39",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Clipboard handlers extracted as part of component simplification",
+      "created_at": "2026-01-06T18:54:59.446313320-05:00"
+    },
+    {
+      "id": 188,
+      "from_node_id": 182,
+      "to_node_id": 185,
+      "from_change_id": "7a9e3b35-e3c2-4081-8e62-74da292b1c08",
+      "to_change_id": "57abe043-ecbe-409d-8d0e-3ee2597856b9",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Math click handler extracted as part of component simplification",
+      "created_at": "2026-01-06T18:54:59.463812727-05:00"
+    },
+    {
+      "id": 189,
+      "from_node_id": 182,
+      "to_node_id": 186,
+      "from_change_id": "7a9e3b35-e3c2-4081-8e62-74da292b1c08",
+      "to_change_id": "0b0c7b27-0bf2-4587-a2a8-34dfc9be3a28",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Composition handlers extracted as part of component simplification",
+      "created_at": "2026-01-06T19:07:47.591441650-05:00"
+    },
+    {
+      "id": 190,
+      "from_node_id": 186,
+      "to_node_id": 187,
+      "from_change_id": "0b0c7b27-0bf2-4587-a2a8-34dfc9be3a28",
+      "to_change_id": "f94e4212-4d47-442d-aedc-bdacaf4babd8",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Image upload extraction completed",
+      "created_at": "2026-01-06T19:19:01.368609959-05:00"
+    },
+    {
+      "id": 191,
+      "from_node_id": 182,
+      "to_node_id": 188,
+      "from_change_id": "7a9e3b35-e3c2-4081-8e62-74da292b1c08",
+      "to_change_id": "ff80e6e7-36d0-426f-8db4-a64705ce0376",
+      "edge_type": "leads_to",
+      "weight": 1.0,
+      "rationale": "Loading logic extraction part of component.rs split",
+      "created_at": "2026-01-06T19:26:48.871648902-05:00"
     }
   ]
 }