couple fixes

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

···
 use jacquard::types::{ident::AtIdentifier, string::Rkey};
 use markdown_weaver::{CowStr, EmbedType, Event};
 use markdown_weaver_escape::{StrWrite, escape_html};
+use smol_str::SmolStr;
 
 use crate::render::{EmbedContentProvider, ImageResolver, WikilinkValidator};
 use crate::syntax::{SyntaxSpanInfo, SyntaxType};
···
 #[derive(Clone, Default)]
 pub struct EditorImageResolver {
     /// All resolved images: name -> resolved path info
-    images: HashMap<String, ResolvedImage>,
+    images: HashMap<SmolStr, ResolvedImage>,
 }
 
 impl EditorImageResolver {
···
     }
 
     /// Add a pending image with a data URL for immediate preview.
-    pub fn add_pending(&mut self, name: String, data_url: String) {
-        self.images.insert(name, ResolvedImage::Pending(data_url));
+    pub fn add_pending(&mut self, name: impl Into<SmolStr>, data_url: String) {
+        self.images
+            .insert(name.into(), ResolvedImage::Pending(data_url));
     }
 
     /// Promote a pending image to uploaded (draft) status.
···
         ident: AtIdentifier<'static>,
     ) {
         self.images
-            .insert(name.to_string(), ResolvedImage::Draft { blob_rkey, ident });
+            .insert(SmolStr::new(name), ResolvedImage::Draft { blob_rkey, ident });
     }
 
     /// Add an already-uploaded draft image.
     pub fn add_uploaded(
         &mut self,
-        name: String,
+        name: impl Into<SmolStr>,
         blob_rkey: Rkey<'static>,
         ident: AtIdentifier<'static>,
     ) {
         self.images
-            .insert(name, ResolvedImage::Draft { blob_rkey, ident });
+            .insert(name.into(), ResolvedImage::Draft { blob_rkey, ident });
     }
 
     /// Add a published image.
     pub fn add_published(
         &mut self,
-        name: String,
+        name: impl Into<SmolStr>,
         entry_rkey: Rkey<'static>,
         ident: AtIdentifier<'static>,
     ) {
         self.images
-            .insert(name, ResolvedImage::Published { entry_rkey, ident });
+            .insert(name.into(), ResolvedImage::Published { entry_rkey, ident });
     }
 
     /// Check if an image is pending upload.

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

···
     entry_index: Option<&'a weaver_common::EntryIndex>,
 
     // === Misc ===
-    numbers: HashMap<String, usize>,
+    numbers: HashMap<SmolStr, usize>,
     pending_blockquote_range: Option<Range<usize>>,
     ref_collector: weaver_common::RefCollector,
 }

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

···
 #[derive(Debug, Clone, Default)]
 pub struct FootnoteContext {
     /// Maps footnote name -> (syntax_span_index, char_start)
-    pub ref_spans: HashMap<String, (usize, usize)>,
+    pub ref_spans: HashMap<SmolStr, (usize, usize)>,
     /// Current footnote def being processed: (name, span_idx, char_start)
-    pub current_def: Option<(String, usize, usize)>,
+    pub current_def: Option<(SmolStr, usize, usize)>,
 }
 
 /// UTF-16 offset checkpoints for incremental tracking.

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

···
 
 use markdown_weaver::{Alignment, BlockQuoteKind, CodeBlockKind, EmbedType, Event, LinkType, Tag};
 use markdown_weaver_escape::{StrWrite, escape_href, escape_html, escape_html_body_text};
+use smol_str::ToSmolStr;
 
 use crate::offset_map::OffsetMapping;
 use crate::render::{EmbedContentProvider, ImageResolver, WikilinkValidator};
···
                         let lang_opt = if lang.is_empty() {
                             None
                         } else {
-                            Some(smol_str::SmolStr::new(lang))
+                            Some(lang.to_smolstr())
                         };
                         // Start buffering
                         self.code_block.buffer = Some((lang_opt, String::new()));
···
                 self.write("</span>")?;
 
                 // Store the definition info (no longer tracking syntax spans for hide/show)
-                self.footnotes.current_def = Some((name.to_string(), 0, char_start));
+                self.footnotes.current_def = Some((name.to_smolstr(), 0, char_start));
 
                 // Record offset mapping for the prefix
                 self.record_mapping(