collab working in worker

crates/weaver-app/public/editor_worker.js

···
 
     let WASM_VECTOR_LEN = 0;
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_(arg0, arg1) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_(arg0, arg1);
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2);
     }
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_(arg0, arg1);
     }
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2);
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1) {
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent______1_(arg0, arg1, arg2) {
···
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_CloseEvent__CloseEvent_____(arg0, arg1, arg2) {
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_CloseEvent__CloseEvent_____(arg0, arg1, arg2);
-    }
-
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2, arg3) {
···
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent______1_);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_70089f6cfcc0d4b7 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 391, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+        imports.wbg.__wbindgen_cast_82f5386d361eee3f = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 441, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 442, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____);
             return ret;
         };

crates/weaver-app/public/embed_worker.js

···
 
     let WASM_VECTOR_LEN = 0;
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
-    }
-
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2) {
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
···
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_28fcab414066dd47 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [Externref], shim_idx: 2277, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
+        imports.wbg.__wbindgen_cast_b44cc294b43af732 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1192, function: Function { arguments: [], shim_idx: 1193, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_80e60da953ba3dd9 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 310, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 311, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+        imports.wbg.__wbindgen_cast_c8f3d1634b3b2a31 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 335, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 336, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_a731521d4dc80277 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1194, function: Function { arguments: [], shim_idx: 1195, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______);
+        imports.wbg.__wbindgen_cast_e60e2a067b8a256d = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1452, function: Function { arguments: [], shim_idx: 1453, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________1_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_e0273882c29884ec = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1454, function: Function { arguments: [], shim_idx: 1455, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________1_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_);
+        imports.wbg.__wbindgen_cast_e76354026ca30a8f = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2274, function: Function { arguments: [Externref], shim_idx: 2275, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
             return ret;
         };
         imports.wbg.__wbindgen_init_externref_table = function() {

crates/weaver-app/src/collab_context.rs

···
 //! the CollabCoordinator component for display in the editor debug panel.
 
 use dioxus::prelude::*;
+use jacquard::smol_str::SmolStr;
 
 /// Debug state for the collab session, displayed in editor debug panel.
 #[derive(Clone, Default)]
 pub struct CollabDebugState {
     /// Our node ID
-    pub node_id: Option<String>,
+    pub node_id: Option<SmolStr>,
     /// Our relay URL
-    pub relay_url: Option<String>,
+    pub relay_url: Option<SmolStr>,
     /// URI of our published session record
     pub session_record_uri: Option<String>,
     /// Number of discovered peers
···
     /// Whether we've joined the gossip swarm
     pub is_joined: bool,
     /// Last error message
-    pub last_error: Option<String>,
+    pub last_error: Option<SmolStr>,
 }
 
 /// Hook to get the collab debug state signal.

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

···
             .map(|a| a.with_range(range))
     }
 
-    /// Look up an action for the given key and modifiers, with the current range applied.
-    #[allow(dead_code)]
-    pub fn lookup_key(&self, key: Key, modifiers: Modifiers, range: Range) -> Option<EditorAction> {
-        self.lookup(KeyCombo::with_modifiers(key, modifiers), range)
-    }
-
     /// Add or replace a keybinding.
     #[allow(dead_code)]
     pub fn bind(&mut self, combo: KeyCombo, action: EditorAction) {

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

···
 use dioxus::prelude::*;
 
 #[cfg(target_arch = "wasm32")]
+use jacquard::smol_str::{format_smolstr, SmolStr};
+#[cfg(target_arch = "wasm32")]
 use jacquard::types::string::AtUri;
 
 use weaver_common::transport::PresenceSnapshot;
···
     Initializing,
     /// Creating session record on PDS
     CreatingSession {
-        node_id: String,
-        relay_url: Option<String>,
+        node_id: SmolStr,
+        relay_url: Option<SmolStr>,
     },
     /// Active collab session
     Active { session_uri: AtUri<'static> },
     /// Error state
-    Error(String),
+    Error(SmolStr),
 }
 
 /// Coordinator component that bridges worker and PDS.
···
 
             // Initialize worker with current document snapshot
             let snapshot = doc.export_snapshot();
-            let draft_key = resource_uri.clone(); // Use resource URI as the key
+            let draft_key: SmolStr = resource_uri.clone().into(); // Use resource URI as the key
             spawn(async move {
                 if let Some(ref mut sink) = *worker_sink.write() {
                     if let Err(e) = sink
···
                                 let uri = match AtUri::new(&resource_uri) {
                                     Ok(u) => u.into_static(),
                                     Err(e) => {
-                                        let err = format!("Invalid resource URI: {e}");
+                                        let err = format_smolstr!("Invalid resource URI: {e}");
                                         debug_state
                                             .with_mut(|ds| ds.last_error = Some(err.clone()));
                                         state.set(CoordinatorState::Error(err));
···
                                 let strong_ref = match fetcher.confirm_record_ref(&uri).await {
                                     Ok(r) => r,
                                     Err(e) => {
-                                        let err = format!("Failed to get resource ref: {e}");
+                                        let err = format_smolstr!("Failed to get resource ref: {e}");
                                         debug_state
                                             .with_mut(|ds| ds.last_error = Some(err.clone()));
                                         state.set(CoordinatorState::Error(err));
···
                                         });
                                     }
                                     Err(e) => {
-                                        let err = format!("Failed to create session: {e}");
+                                        let err = format_smolstr!("Failed to create session: {e}");
                                         debug_state
                                             .with_mut(|ds| ds.last_error = Some(err.clone()));
                                         state.set(CoordinatorState::Error(err));
···
                             let fetcher = fetcher.clone();
 
                             // Get our profile info and send BroadcastJoin
-                            let (our_did, our_display_name) = match fetcher.current_did().await {
+                            let (our_did, our_display_name): (SmolStr, SmolStr) = match fetcher.current_did().await {
                                 Some(did) => {
-                                    let display_name = match fetcher.fetch_profile(&did.clone().into()).await {
+                                    let display_name: SmolStr = match fetcher.fetch_profile(&did.clone().into()).await {
                                         Ok(profile) => {
                                             match &profile.inner {
                                                 ProfileDataViewInner::ProfileView(p) => {
-                                                    p.display_name.as_ref().map(|s| s.to_string()).unwrap_or_else(|| did.to_string())
+                                                    p.display_name.as_ref().map(|s| s.as_ref().into()).unwrap_or_else(|| did.as_ref().into())
                                                 }
                                                 ProfileDataViewInner::ProfileViewDetailed(p) => {
-                                                    p.display_name.as_ref().map(|s| s.to_string()).unwrap_or_else(|| did.to_string())
+                                                    p.display_name.as_ref().map(|s| s.as_ref().into()).unwrap_or_else(|| did.as_ref().into())
                                                 }
                                                 ProfileDataViewInner::TangledProfileView(p) => {
-                                                    p.handle.to_string()
+                                                    p.handle.as_ref().into()
                                                 }
-                                                _ => did.to_string(),
+                                                _ => did.as_ref().into(),
                                             }
                                         }
-                                        Err(_) => did.to_string(),
+                                        Err(_) => did.as_ref().into(),
                                     };
-                                    (did.to_string(), display_name)
+                                    (did.as_ref().into(), display_name)
                                 }
                                 None => {
                                     tracing::warn!("CollabCoordinator: no current DID for Join message");
-                                    ("unknown".to_string(), "Anonymous".to_string())
+                                    ("unknown".into(), "Anonymous".into())
                                 }
                             };
 
···
                         Ok(peers) => {
                             debug_state.with_mut(|ds| ds.discovered_peers = peers.len());
                             if !peers.is_empty() {
-                                let peer_ids: Vec<String> =
+                                let peer_ids: Vec<SmolStr> =
                                     peers.into_iter().map(|p| p.node_id).collect();
 
                                 if let Some(ref mut s) = *worker_sink.write() {

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

···
 use jacquard::IntoStatic;
 use jacquard::cowstr::ToCowStr;
 use jacquard::identity::resolver::IdentityResolver;
-use jacquard::smol_str::SmolStr;
+use jacquard::smol_str::{SmolStr, ToSmolStr};
 use jacquard::types::aturi::AtUri;
 use jacquard::types::blob::BlobRef;
 use jacquard::types::ident::AtIdentifier;
···
                     let _ = sink
                         .send(WorkerInput::Init {
                             snapshot,
-                            draft_key,
+                            draft_key: draft_key.into(),
                         })
                         .await;
                 }
···
                     };
 
                     let cursor_offset = doc.cursor.read().offset;
-                    let editing_uri = doc.entry_ref().map(|r| r.uri.to_string());
-                    let editing_cid = doc.entry_ref().map(|r| r.cid.to_string());
+                    let editing_uri = doc.entry_ref().map(|r| r.uri.to_smolstr());
+                    let editing_cid = doc.entry_ref().map(|r| r.cid.to_smolstr());
 
                     let sink_clone = worker_sink.clone();
 

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

···
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use gloo_storage::{LocalStorage, Storage};
 use jacquard::IntoStatic;
+use jacquard::smol_str::{SmolStr, ToSmolStr};
 use jacquard::types::string::{AtUri, Cid};
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
 use loro::cursor::Cursor;
···
 
     /// Entry title (for debugging/display in drafts list)
     #[serde(default)]
-    pub title: String,
+    pub title: SmolStr,
 
     /// Base64-encoded CRDT snapshot (contains ALL fields including embeds)
     #[serde(default, skip_serializing_if = "Option::is_none")]
···
 
     /// AT-URI if editing an existing entry (None for new entries)
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub editing_uri: Option<String>,
+    pub editing_uri: Option<SmolStr>,
 
     /// CID of the entry if editing an existing entry
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub editing_cid: Option<String>,
+    pub editing_cid: Option<SmolStr>,
 }
 
 /// Build the full storage key from a draft key.
···
 
     let snapshot = EditorSnapshot {
         content: doc.content(),
-        title: doc.title(),
+        title: doc.title().into(),
         snapshot: snapshot_b64,
         cursor: doc.loro_cursor().cloned(),
         cursor_offset: doc.cursor.read().offset,
-        editing_uri: doc.entry_ref().map(|r| r.uri.to_string()),
-        editing_cid: doc.entry_ref().map(|r| r.cid.to_string()),
+        editing_uri: doc.entry_ref().map(|r| r.uri.to_smolstr()),
+        editing_cid: doc.entry_ref().map(|r| r.cid.to_smolstr()),
     };
 
     let write_start = crate::perf::now();
···
                     // Try to load just the metadata
                     if let Ok(snapshot) = LocalStorage::get::<EditorSnapshot>(&key) {
                         let draft_key = key.strip_prefix(DRAFT_KEY_PREFIX).unwrap_or(&key);
-                        drafts.push((draft_key.to_string(), snapshot.title, snapshot.editing_uri));
+                        drafts.push((
+                            draft_key.to_string(),
+                            snapshot.title.to_string(),
+                            snapshot.editing_uri.map(|s| s.to_string()),
+                        ));
                     }
                 }
             }

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

···
     }
 }
 
-/// Extract (authority, rkey) from a canonical draft key (synthetic AT-URI).
-///
-/// Parses `at://{authority}/sh.weaver.edit.draft/{rkey}` and returns the components.
-/// Authority can be a DID or handle.
-#[allow(dead_code)]
-pub fn parse_draft_key(
-    draft_key: &str,
-) -> Option<(jacquard::types::ident::AtIdentifier<'static>, String)> {
-    let uri = AtUri::new(draft_key).ok()?;
-    let authority = uri.authority().clone().into_static();
-    let rkey = uri.rkey()?.0.as_str().to_string();
-    Some((authority, rkey))
-}
-
 /// Result of a sync operation.
 #[derive(Clone, Debug)]
 pub enum SyncResult {
···
     },
     /// No changes to sync
     NoChanges,
-}
-
-/// Find the edit root for an entry using constellation backlinks.
-///
-/// Queries constellation for `sh.weaver.edit.root` records that reference
-/// the given entry URI via the `.doc.value.entry.uri` path.
-#[allow(dead_code)]
-pub async fn find_edit_root_for_entry(
-    fetcher: &Fetcher,
-    entry_uri: &AtUri<'_>,
-) -> Result<Option<RecordId<'static>>, WeaverError> {
-    let constellation_url = Url::parse(CONSTELLATION_URL)
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid constellation URL: {}", e)))?;
-
-    let query = GetBacklinksQuery {
-        subject: Uri::At(entry_uri.clone().into_static()),
-        source: format_smolstr!("{}:doc.value.entry.uri", ROOT_NSID).into(),
-        cursor: None,
-        did: vec![],
-        limit: 1,
-    };
-
-    let response = fetcher
-        .client
-        .xrpc(constellation_url)
-        .send(&query)
-        .await
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Constellation query failed: {}", e)))?;
-
-    let output = response.into_output().map_err(|e| {
-        WeaverError::InvalidNotebook(format!("Failed to parse constellation response: {}", e))
-    })?;
-
-    Ok(output.records.into_iter().next().map(|r| r.into_static()))
 }
 
 /// Find ALL edit.root records across collaborators for an entry.
···
 }
 
 /// Find all diffs for a root record using constellation backlinks.
-#[allow(dead_code)]
 pub async fn find_diffs_for_root(
     fetcher: &Fetcher,
     root_uri: &AtUri<'_>,
···
     fetcher: &Fetcher,
     entry_uri: &AtUri<'_>,
 ) -> Result<Option<PdsEditState>, WeaverError> {
-    // Find the edit root for this entry
-    let root_id = match find_edit_root_for_entry(fetcher, entry_uri).await? {
+    // Find the edit root for this entry (take first if multiple exist)
+    let root_id = match find_all_edit_roots_for_entry(fetcher, entry_uri)
+        .await?
+        .into_iter()
+        .next()
+    {
         Some(id) => id,
         None => return Ok(None),
     };

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

···
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use jacquard::smol_str::format_smolstr;
 
+use jacquard::smol_str::SmolStr;
+
 /// Input messages to the editor worker.
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum WorkerInput {
···
         /// Full Loro snapshot bytes
         snapshot: Vec<u8>,
         /// Draft key for storage
-        draft_key: String,
+        draft_key: SmolStr,
     },
     /// Apply incremental Loro updates to the shadow document.
     ApplyUpdates {
···
         /// Current cursor position (for snapshot metadata)
         cursor_offset: usize,
         /// Editing URI if editing existing entry
-        editing_uri: Option<String>,
+        editing_uri: Option<SmolStr>,
         /// Editing CID if editing existing entry
-        editing_cid: Option<String>,
+        editing_cid: Option<SmolStr>,
     },
     /// Start collab session (worker will spawn CollabNode)
     StartCollab {
         /// blake3 hash of resource URI (32 bytes)
         topic: [u8; 32],
         /// Bootstrap peer node IDs (z-base32 strings)
-        bootstrap_peers: Vec<String>,
+        bootstrap_peers: Vec<SmolStr>,
     },
     /// Loro updates from local edits (forward to gossip)
     BroadcastUpdate {
···
     /// New peers discovered by main thread
     AddPeers {
         /// Node ID strings
-        peers: Vec<String>,
+        peers: Vec<SmolStr>,
     },
     /// Announce ourselves to peers (sent after AddPeers)
     BroadcastJoin {
         /// Our DID
-        did: String,
+        did: SmolStr,
         /// Our display name
-        display_name: String,
+        display_name: SmolStr,
     },
     /// Local cursor position changed
     BroadcastCursor {
···
     /// Snapshot export completed.
     Snapshot {
         /// Draft key for storage
-        draft_key: String,
+        draft_key: SmolStr,
         /// Base64-encoded Loro snapshot
         b64_snapshot: String,
         /// Human-readable content (for debugging)
         content: String,
         /// Entry title
-        title: String,
+        title: SmolStr,
         /// Cursor offset
         cursor_offset: usize,
         /// Editing URI
-        editing_uri: Option<String>,
+        editing_uri: Option<SmolStr>,
         /// Editing CID
-        editing_cid: Option<String>,
+        editing_cid: Option<SmolStr>,
         /// Export timing in ms
         export_ms: f64,
         /// Encode timing in ms
         encode_ms: f64,
     },
     /// Error occurred.
-    Error { message: String },
+    Error { message: SmolStr },
     /// Collab node ready, here's info for session record
     CollabReady {
         /// Node ID (z-base32 string)
-        node_id: String,
+        node_id: SmolStr,
         /// Relay URL for browser connectivity
-        relay_url: Option<String>,
+        relay_url: Option<SmolStr>,
     },
     /// Collab session joined successfully
     CollabJoined,
···
     use super::*;
     use futures_util::sink::SinkExt;
     use futures_util::stream::StreamExt;
-    use gloo_worker::reactor::{reactor, ReactorScope};
+    use gloo_worker::reactor::{ReactorScope, reactor};
     use weaver_common::transport::CollaboratorInfo;
 
     #[cfg(feature = "collab-worker")]
+    use jacquard::smol_str::ToSmolStr;
+    #[cfg(feature = "collab-worker")]
     use std::sync::Arc;
     #[cfg(feature = "collab-worker")]
     use weaver_common::transport::{
···
     #[reactor]
     pub async fn EditorReactor(mut scope: ReactorScope<WorkerInput, WorkerOutput>) {
         let mut doc: Option<loro::LoroDoc> = None;
-        let mut draft_key = String::new();
+        let mut draft_key = SmolStr::default();
 
         // Collab state (only used when collab-worker feature enabled)
         #[cfg(feature = "collab-worker")]
···
                             }
                         }
                         CollabEvent::PresenceChanged(snapshot) => {
-                            if let Err(e) = scope.send(WorkerOutput::PresenceUpdate(snapshot)).await {
-                                tracing::error!("Failed to send PresenceUpdate to coordinator: {e}");
+                            if let Err(e) = scope.send(WorkerOutput::PresenceUpdate(snapshot)).await
+                            {
+                                tracing::error!(
+                                    "Failed to send PresenceUpdate to coordinator: {e}"
+                                );
                             }
                         }
                         CollabEvent::PeerConnected => {
···
                     // Fall through to message handling below
                     tracing::debug!(?msg, "Worker: received message");
                     match msg {
-                WorkerInput::Init {
-                    snapshot,
-                    draft_key: key,
-                } => {
-                    let new_doc = loro::LoroDoc::new();
-                    if !snapshot.is_empty() {
-                        if let Err(e) = new_doc.import(&snapshot) {
-                            if let Err(send_err) = scope
-                                .send(WorkerOutput::Error {
-                                    message: format_smolstr!("Failed to import snapshot: {e}").to_string(),
-                                })
-                                .await
-                            {
-                                tracing::error!("Failed to send Error to coordinator: {send_err}");
+                        WorkerInput::Init {
+                            snapshot,
+                            draft_key: key,
+                        } => {
+                            let new_doc = loro::LoroDoc::new();
+                            if !snapshot.is_empty() {
+                                if let Err(e) = new_doc.import(&snapshot) {
+                                    if let Err(send_err) = scope
+                                        .send(WorkerOutput::Error {
+                                            message: format_smolstr!(
+                                                "Failed to import snapshot: {e}"
+                                            ),
+                                        })
+                                        .await
+                                    {
+                                        tracing::error!(
+                                            "Failed to send Error to coordinator: {send_err}"
+                                        );
+                                    }
+                                    continue;
+                                }
+                            }
+                            doc = Some(new_doc);
+                            draft_key = key;
+                            if let Err(e) = scope.send(WorkerOutput::Ready).await {
+                                tracing::error!("Failed to send Ready to coordinator: {e}");
                             }
-                            continue;
                         }
-                    }
-                    doc = Some(new_doc);
-                    draft_key = key;
-                    if let Err(e) = scope.send(WorkerOutput::Ready).await {
-                        tracing::error!("Failed to send Ready to coordinator: {e}");
-                    }
-                }
 
-                WorkerInput::ApplyUpdates { updates } => {
-                    if let Some(ref doc) = doc {
-                        if let Err(e) = doc.import(&updates) {
-                            tracing::warn!("Worker failed to import updates: {e}");
+                        WorkerInput::ApplyUpdates { updates } => {
+                            if let Some(ref doc) = doc {
+                                if let Err(e) = doc.import(&updates) {
+                                    tracing::warn!("Worker failed to import updates: {e}");
+                                }
+                            }
                         }
-                    }
-                }
 
-                WorkerInput::ExportSnapshot {
-                    cursor_offset,
-                    editing_uri,
-                    editing_cid,
-                } => {
-                    let Some(ref doc) = doc else {
-                        if let Err(e) = scope
-                            .send(WorkerOutput::Error {
-                                message: "No document initialized".into(),
-                            })
-                            .await
-                        {
-                            tracing::error!("Failed to send Error to coordinator: {e}");
-                        }
-                        continue;
-                    };
+                        WorkerInput::ExportSnapshot {
+                            cursor_offset,
+                            editing_uri,
+                            editing_cid,
+                        } => {
+                            let Some(ref doc) = doc else {
+                                if let Err(e) = scope
+                                    .send(WorkerOutput::Error {
+                                        message: "No document initialized".into(),
+                                    })
+                                    .await
+                                {
+                                    tracing::error!("Failed to send Error to coordinator: {e}");
+                                }
+                                continue;
+                            };
 
-                    let export_start = crate::perf::now();
-                    let snapshot_bytes = match doc.export(loro::ExportMode::Snapshot) {
-                        Ok(bytes) => bytes,
-                        Err(e) => {
-                            if let Err(send_err) = scope
-                                .send(WorkerOutput::Error {
-                                    message: format_smolstr!("Export failed: {e}").to_string(),
+                            let export_start = crate::perf::now();
+                            let snapshot_bytes = match doc.export(loro::ExportMode::Snapshot) {
+                                Ok(bytes) => bytes,
+                                Err(e) => {
+                                    if let Err(send_err) = scope
+                                        .send(WorkerOutput::Error {
+                                            message: format_smolstr!("Export failed: {e}"),
+                                        })
+                                        .await
+                                    {
+                                        tracing::error!(
+                                            "Failed to send Error to coordinator: {send_err}"
+                                        );
+                                    }
+                                    continue;
+                                }
+                            };
+                            let export_ms = crate::perf::now() - export_start;
+
+                            let encode_start = crate::perf::now();
+                            let b64_snapshot = BASE64.encode(&snapshot_bytes);
+                            let encode_ms = crate::perf::now() - encode_start;
+
+                            let content = doc.get_text("content").to_string();
+                            let title: SmolStr = doc.get_text("title").to_string().into();
+
+                            if let Err(e) = scope
+                                .send(WorkerOutput::Snapshot {
+                                    draft_key: draft_key.clone(),
+                                    b64_snapshot,
+                                    content,
+                                    title,
+                                    cursor_offset,
+                                    editing_uri,
+                                    editing_cid,
+                                    export_ms,
+                                    encode_ms,
                                 })
                                 .await
                             {
-                                tracing::error!("Failed to send Error to coordinator: {send_err}");
+                                tracing::error!("Failed to send Snapshot to coordinator: {e}");
                             }
-                            continue;
                         }
-                    };
-                    let export_ms = crate::perf::now() - export_start;
 
-                    let encode_start = crate::perf::now();
-                    let b64_snapshot = BASE64.encode(&snapshot_bytes);
-                    let encode_ms = crate::perf::now() - encode_start;
-
-                    let content = doc.get_text("content").to_string();
-                    let title = doc.get_text("title").to_string();
+                        // ============================================================
+                        // Collab handlers - full impl when collab-worker feature enabled
+                        // ============================================================
+                        #[cfg(feature = "collab-worker")]
+                        WorkerInput::StartCollab {
+                            topic,
+                            bootstrap_peers,
+                        } => {
+                            // Spawn CollabNode
+                            let node = match CollabNode::spawn(None).await {
+                                Ok(n) => n,
+                                Err(e) => {
+                                    if let Err(send_err) = scope
+                                        .send(WorkerOutput::Error {
+                                            message: format_smolstr!(
+                                                "Failed to spawn CollabNode: {e}"
+                                            ),
+                                        })
+                                        .await
+                                    {
+                                        tracing::error!(
+                                            "Failed to send Error to coordinator: {send_err}"
+                                        );
+                                    }
+                                    continue;
+                                }
+                            };
 
-                    if let Err(e) = scope
-                        .send(WorkerOutput::Snapshot {
-                            draft_key: draft_key.clone(),
-                            b64_snapshot,
-                            content,
-                            title,
-                            cursor_offset,
-                            editing_uri,
-                            editing_cid,
-                            export_ms,
-                            encode_ms,
-                        })
-                        .await
-                    {
-                        tracing::error!("Failed to send Snapshot to coordinator: {e}");
-                    }
-                }
+                            // Wait for relay connection
+                            let relay_url = node.wait_for_relay().await;
+                            let node_id = node.node_id_string();
 
-                // ============================================================
-                // Collab handlers - full impl when collab-worker feature enabled
-                // ============================================================
-                #[cfg(feature = "collab-worker")]
-                WorkerInput::StartCollab {
-                    topic,
-                    bootstrap_peers,
-                } => {
-                    // Spawn CollabNode
-                    let node = match CollabNode::spawn(None).await {
-                        Ok(n) => n,
-                        Err(e) => {
-                            if let Err(send_err) = scope
-                                .send(WorkerOutput::Error {
-                                    message: format_smolstr!("Failed to spawn CollabNode: {e}").to_string(),
+                            // Send ready so main thread can create session record
+                            if let Err(e) = scope
+                                .send(WorkerOutput::CollabReady {
+                                    node_id,
+                                    relay_url: Some(relay_url),
                                 })
                                 .await
                             {
-                                tracing::error!("Failed to send Error to coordinator: {send_err}");
+                                tracing::error!("Failed to send CollabReady to coordinator: {e}");
                             }
-                            continue;
-                        }
-                    };
 
-                    // Wait for relay connection
-                    let relay_url = node.wait_for_relay().await;
-                    let node_id = node.node_id_string();
+                            collab_node = Some(node.clone());
 
-                    // Send ready so main thread can create session record
-                    if let Err(e) = scope
-                        .send(WorkerOutput::CollabReady {
-                            node_id,
-                            relay_url: Some(relay_url),
-                        })
-                        .await
-                    {
-                        tracing::error!("Failed to send CollabReady to coordinator: {e}");
-                    }
+                            // Parse bootstrap peers
+                            let peers: Vec<_> = bootstrap_peers
+                                .iter()
+                                .filter_map(|s| parse_node_id(s).ok())
+                                .collect();
 
-                    collab_node = Some(node.clone());
+                            // Join gossip session
+                            let topic_id = TopicId::from_bytes(topic);
+                            match CollabSession::join(node, topic_id, peers).await {
+                                Ok((session, mut events)) => {
+                                    let session = Arc::new(session);
+                                    collab_session = Some(session.clone());
+                                    if let Err(e) = scope.send(WorkerOutput::CollabJoined).await {
+                                        tracing::error!(
+                                            "Failed to send CollabJoined to coordinator: {e}"
+                                        );
+                                    }
 
-                    // Parse bootstrap peers
-                    let peers: Vec<_> = bootstrap_peers
-                        .iter()
-                        .filter_map(|s| parse_node_id(s).ok())
-                        .collect();
+                                    // NOTE: Don't broadcast Join here - wait for BroadcastJoin message
+                                    // after peers have been added via AddPeers
 
-                    // Join gossip session
-                    let topic_id = TopicId::from_bytes(topic);
-                    match CollabSession::join(node, topic_id, peers).await {
-                        Ok((session, mut events)) => {
-                            let session = Arc::new(session);
-                            collab_session = Some(session.clone());
-                            if let Err(e) = scope.send(WorkerOutput::CollabJoined).await {
-                                tracing::error!("Failed to send CollabJoined to coordinator: {e}");
-                            }
+                                    // Create channel for events from spawned task
+                                    let (event_tx, event_rx) =
+                                        tokio::sync::mpsc::unbounded_channel();
+                                    collab_event_rx = Some(event_rx);
 
-                            // NOTE: Don't broadcast Join here - wait for BroadcastJoin message
-                            // after peers have been added via AddPeers
-
-                            // Create channel for events from spawned task
-                            let (event_tx, event_rx) = tokio::sync::mpsc::unbounded_channel();
-                            collab_event_rx = Some(event_rx);
+                                    // Spawn event handler task that sends via channel
+                                    wasm_bindgen_futures::spawn_local(async move {
+                                        let mut presence = PresenceTracker::new();
 
-                            // Spawn event handler task that sends via channel
-                            wasm_bindgen_futures::spawn_local(async move {
-                                let mut presence = PresenceTracker::new();
-
-                                while let Some(Ok(event)) = events.next().await {
-                                    match event {
-                                        SessionEvent::Message { from, message } => {
-                                            match message {
-                                                CollabMessage::LoroUpdate { data, .. } => {
-                                                    if event_tx.send(CollabEvent::RemoteUpdates { data }).is_err() {
-                                                        tracing::warn!("Collab event channel closed");
-                                                        return;
-                                                    }
-                                                }
-                                                CollabMessage::Join { did, display_name } => {
-                                                    tracing::info!(%from, %did, %display_name, "Received Join message");
-                                                    presence.add_collaborator(from, did, display_name);
-                                                    if event_tx.send(CollabEvent::PresenceChanged(
-                                                        presence_to_snapshot(&presence),
-                                                    )).is_err() {
-                                                        tracing::warn!("Collab event channel closed");
-                                                        return;
+                                        while let Some(Ok(event)) = events.next().await {
+                                            match event {
+                                                SessionEvent::Message { from, message } => {
+                                                    match message {
+                                                        CollabMessage::LoroUpdate {
+                                                            data, ..
+                                                        } => {
+                                                            if event_tx
+                                                                .send(CollabEvent::RemoteUpdates {
+                                                                    data,
+                                                                })
+                                                                .is_err()
+                                                            {
+                                                                tracing::warn!(
+                                                                    "Collab event channel closed"
+                                                                );
+                                                                return;
+                                                            }
+                                                        }
+                                                        CollabMessage::Join {
+                                                            did,
+                                                            display_name,
+                                                        } => {
+                                                            tracing::info!(%from, %did, %display_name, "Received Join message");
+                                                            presence.add_collaborator(
+                                                                from,
+                                                                did,
+                                                                display_name,
+                                                            );
+                                                            if event_tx
+                                                                .send(CollabEvent::PresenceChanged(
+                                                                    presence_to_snapshot(&presence),
+                                                                ))
+                                                                .is_err()
+                                                            {
+                                                                tracing::warn!(
+                                                                    "Collab event channel closed"
+                                                                );
+                                                                return;
+                                                            }
+                                                        }
+                                                        CollabMessage::Leave { .. } => {
+                                                            presence.remove_collaborator(&from);
+                                                            if event_tx
+                                                                .send(CollabEvent::PresenceChanged(
+                                                                    presence_to_snapshot(&presence),
+                                                                ))
+                                                                .is_err()
+                                                            {
+                                                                tracing::warn!(
+                                                                    "Collab event channel closed"
+                                                                );
+                                                                return;
+                                                            }
+                                                        }
+                                                        CollabMessage::Cursor {
+                                                            position,
+                                                            selection,
+                                                            ..
+                                                        } => {
+                                                            // Note: cursor updates require the collaborator to exist
+                                                            // (added via Join message)
+                                                            let exists = presence.contains(&from);
+                                                            tracing::debug!(%from, position, ?selection, exists, "Received Cursor message");
+                                                            presence.update_cursor(
+                                                                &from, position, selection,
+                                                            );
+                                                            if event_tx
+                                                                .send(CollabEvent::PresenceChanged(
+                                                                    presence_to_snapshot(&presence),
+                                                                ))
+                                                                .is_err()
+                                                            {
+                                                                tracing::warn!(
+                                                                    "Collab event channel closed"
+                                                                );
+                                                                return;
+                                                            }
+                                                        }
+                                                        _ => {}
                                                     }
                                                 }
-                                                CollabMessage::Leave { .. } => {
-                                                    presence.remove_collaborator(&from);
-                                                    if event_tx.send(CollabEvent::PresenceChanged(
-                                                        presence_to_snapshot(&presence),
-                                                    )).is_err() {
-                                                        tracing::warn!("Collab event channel closed");
+                                                SessionEvent::PeerJoined(peer) => {
+                                                    tracing::info!(%peer, "PeerJoined - notifying coordinator");
+                                                    // Notify coordinator so it can send BroadcastJoin
+                                                    // Don't add to presence yet - wait for their Join message
+                                                    if event_tx
+                                                        .send(CollabEvent::PeerConnected)
+                                                        .is_err()
+                                                    {
+                                                        tracing::warn!(
+                                                            "Collab event channel closed"
+                                                        );
                                                         return;
                                                     }
                                                 }
-                                                CollabMessage::Cursor {
-                                                    position,
-                                                    selection,
-                                                    ..
-                                                } => {
-                                                    // Note: cursor updates require the collaborator to exist
-                                                    // (added via Join message)
-                                                    let exists = presence.contains(&from);
-                                                    tracing::debug!(%from, position, ?selection, exists, "Received Cursor message");
-                                                    presence.update_cursor(&from, position, selection);
-                                                    if event_tx.send(CollabEvent::PresenceChanged(
-                                                        presence_to_snapshot(&presence),
-                                                    )).is_err() {
-                                                        tracing::warn!("Collab event channel closed");
+                                                SessionEvent::PeerLeft(peer) => {
+                                                    presence.remove_collaborator(&peer);
+                                                    if event_tx
+                                                        .send(CollabEvent::PresenceChanged(
+                                                            presence_to_snapshot(&presence),
+                                                        ))
+                                                        .is_err()
+                                                    {
+                                                        tracing::warn!(
+                                                            "Collab event channel closed"
+                                                        );
                                                         return;
                                                     }
                                                 }
-                                                _ => {}
-                                            }
-                                        }
-                                        SessionEvent::PeerJoined(peer) => {
-                                            tracing::info!(%peer, "PeerJoined - notifying coordinator");
-                                            // Notify coordinator so it can send BroadcastJoin
-                                            // Don't add to presence yet - wait for their Join message
-                                            if event_tx.send(CollabEvent::PeerConnected).is_err() {
-                                                tracing::warn!("Collab event channel closed");
-                                                return;
-                                            }
-                                        }
-                                        SessionEvent::PeerLeft(peer) => {
-                                            presence.remove_collaborator(&peer);
-                                            if event_tx.send(CollabEvent::PresenceChanged(
-                                                presence_to_snapshot(&presence),
-                                            )).is_err() {
-                                                tracing::warn!("Collab event channel closed");
-                                                return;
+                                                SessionEvent::Joined => {}
                                             }
                                         }
-                                        SessionEvent::Joined => {}
+                                    });
+                                }
+                                Err(e) => {
+                                    if let Err(send_err) = scope
+                                        .send(WorkerOutput::Error {
+                                            message: format_smolstr!("Failed to join session: {e}"),
+                                        })
+                                        .await
+                                    {
+                                        tracing::error!(
+                                            "Failed to send Error to coordinator: {send_err}"
+                                        );
                                     }
                                 }
-                            });
-                        }
-                        Err(e) => {
-                            if let Err(send_err) = scope
-                                .send(WorkerOutput::Error {
-                                    message: format_smolstr!("Failed to join session: {e}").to_string(),
-                                })
-                                .await
-                            {
-                                tracing::error!("Failed to send Error to coordinator: {send_err}");
                             }
                         }
-                    }
-                }
 
-                #[cfg(feature = "collab-worker")]
-                WorkerInput::BroadcastUpdate { data } => {
-                    if let Some(ref session) = collab_session {
-                        let msg = CollabMessage::LoroUpdate {
-                            data,
-                            version: vec![],
-                        };
-                        if let Err(e) = session.broadcast(&msg).await {
-                            tracing::warn!("Broadcast failed: {e}");
+                        #[cfg(feature = "collab-worker")]
+                        WorkerInput::BroadcastUpdate { data } => {
+                            if let Some(ref session) = collab_session {
+                                let msg = CollabMessage::LoroUpdate {
+                                    data,
+                                    version: vec![],
+                                };
+                                if let Err(e) = session.broadcast(&msg).await {
+                                    tracing::warn!("Broadcast failed: {e}");
+                                }
+                            }
                         }
-                    }
-                }
 
-                #[cfg(feature = "collab-worker")]
-                WorkerInput::BroadcastCursor { position, selection } => {
-                    if let Some(ref session) = collab_session {
-                        tracing::debug!(position, ?selection, "Worker: broadcasting cursor");
-                        let msg = CollabMessage::Cursor {
+                        #[cfg(feature = "collab-worker")]
+                        WorkerInput::BroadcastCursor {
                             position,
                             selection,
-                            color: OUR_COLOR,
-                        };
-                        if let Err(e) = session.broadcast(&msg).await {
-                            tracing::warn!("Cursor broadcast failed: {e}");
+                        } => {
+                            if let Some(ref session) = collab_session {
+                                tracing::debug!(
+                                    position,
+                                    ?selection,
+                                    "Worker: broadcasting cursor"
+                                );
+                                let msg = CollabMessage::Cursor {
+                                    position,
+                                    selection,
+                                    color: OUR_COLOR,
+                                };
+                                if let Err(e) = session.broadcast(&msg).await {
+                                    tracing::warn!("Cursor broadcast failed: {e}");
+                                }
+                            } else {
+                                tracing::debug!(
+                                    position,
+                                    ?selection,
+                                    "Worker: BroadcastCursor but no session"
+                                );
+                            }
                         }
-                    } else {
-                        tracing::debug!(position, ?selection, "Worker: BroadcastCursor but no session");
-                    }
-                }
 
-                #[cfg(feature = "collab-worker")]
-                WorkerInput::AddPeers { peers } => {
-                    tracing::info!(count = peers.len(), "Worker: received AddPeers");
-                    if let Some(ref session) = collab_session {
-                        let peer_ids: Vec<_> = peers
+                        #[cfg(feature = "collab-worker")]
+                        WorkerInput::AddPeers { peers } => {
+                            tracing::info!(count = peers.len(), "Worker: received AddPeers");
+                            if let Some(ref session) = collab_session {
+                                let peer_ids: Vec<_> = peers
                             .iter()
                             .filter_map(|s| {
                                 match parse_node_id(s) {
···
                                 }
                             })
                             .collect();
-                        tracing::info!(parsed_count = peer_ids.len(), "Worker: joining peers");
-                        if let Err(e) = session.join_peers(peer_ids).await {
-                            tracing::warn!("Failed to add peers: {e}");
+                                tracing::info!(
+                                    parsed_count = peer_ids.len(),
+                                    "Worker: joining peers"
+                                );
+                                if let Err(e) = session.join_peers(peer_ids).await {
+                                    tracing::warn!("Failed to add peers: {e}");
+                                }
+                            } else {
+                                tracing::warn!("Worker: AddPeers but no collab_session");
+                            }
                         }
-                    } else {
-                        tracing::warn!("Worker: AddPeers but no collab_session");
-                    }
-                }
 
-                #[cfg(feature = "collab-worker")]
-                WorkerInput::BroadcastJoin { did, display_name } => {
-                    if let Some(ref session) = collab_session {
-                        let join_msg = CollabMessage::Join { did, display_name };
-                        if let Err(e) = session.broadcast(&join_msg).await {
-                            tracing::warn!("Failed to broadcast Join: {e}");
+                        #[cfg(feature = "collab-worker")]
+                        WorkerInput::BroadcastJoin { did, display_name } => {
+                            if let Some(ref session) = collab_session {
+                                let join_msg = CollabMessage::Join { did, display_name };
+                                if let Err(e) = session.broadcast(&join_msg).await {
+                                    tracing::warn!("Failed to broadcast Join: {e}");
+                                }
+                            }
                         }
-                    }
-                }
 
-                #[cfg(feature = "collab-worker")]
-                WorkerInput::StopCollab => {
-                    collab_session = None;
-                    collab_node = None;
-                    collab_event_rx = None;
-                    if let Err(e) = scope.send(WorkerOutput::CollabStopped).await {
-                        tracing::error!("Failed to send CollabStopped to coordinator: {e}");
-                    }
-                }
-
+                        #[cfg(feature = "collab-worker")]
+                        WorkerInput::StopCollab => {
+                            collab_session = None;
+                            collab_node = None;
+                            collab_event_rx = None;
+                            if let Err(e) = scope.send(WorkerOutput::CollabStopped).await {
+                                tracing::error!("Failed to send CollabStopped to coordinator: {e}");
+                            }
+                        }
                     } // end match msg
                 } // end RaceResult::CoordinatorMsg(Some(msg))
             } // end match race_result
···
                 let Some(msg) = scope.next().await else { break };
                 tracing::debug!(?msg, "Worker: received message");
                 match msg {
-                    WorkerInput::Init { snapshot, draft_key: key } => {
+                    WorkerInput::Init {
+                        snapshot,
+                        draft_key: key,
+                    } => {
                         let new_doc = loro::LoroDoc::new();
                         if !snapshot.is_empty() {
                             if let Err(e) = new_doc.import(&snapshot) {
                                 if let Err(send_err) = scope
                                     .send(WorkerOutput::Error {
-                                        message: format_smolstr!("Failed to import snapshot: {e}").to_string(),
+                                        message: format_smolstr!("Failed to import snapshot: {e}"),
                                     })
                                     .await
                                 {
-                                    tracing::error!("Failed to send Error to coordinator: {send_err}");
+                                    tracing::error!(
+                                        "Failed to send Error to coordinator: {send_err}"
+                                    );
                                 }
                                 continue;
                             }
···
                             }
                         }
                     }
-                    WorkerInput::ExportSnapshot { cursor_offset, editing_uri, editing_cid } => {
+                    WorkerInput::ExportSnapshot {
+                        cursor_offset,
+                        editing_uri,
+                        editing_cid,
+                    } => {
                         let Some(ref doc) = doc else {
-                            if let Err(e) = scope.send(WorkerOutput::Error { message: "No document initialized".into() }).await {
+                            if let Err(e) = scope
+                                .send(WorkerOutput::Error {
+                                    message: "No document initialized".into(),
+                                })
+                                .await
+                            {
                                 tracing::error!("Failed to send Error to coordinator: {e}");
                             }
                             continue;
···
                         let snapshot_bytes = match doc.export(loro::ExportMode::Snapshot) {
                             Ok(bytes) => bytes,
                             Err(e) => {
-                                if let Err(send_err) = scope.send(WorkerOutput::Error { message: format_smolstr!("Export failed: {e}").to_string() }).await {
-                                    tracing::error!("Failed to send Error to coordinator: {send_err}");
+                                if let Err(send_err) = scope
+                                    .send(WorkerOutput::Error {
+                                        message: format_smolstr!("Export failed: {e}"),
+                                    })
+                                    .await
+                                {
+                                    tracing::error!(
+                                        "Failed to send Error to coordinator: {send_err}"
+                                    );
                                 }
                                 continue;
                             }
···
                         let b64_snapshot = BASE64.encode(&snapshot_bytes);
                         let encode_ms = crate::perf::now() - encode_start;
                         let content = doc.get_text("content").to_string();
-                        let title = doc.get_text("title").to_string();
-                        if let Err(e) = scope.send(WorkerOutput::Snapshot {
-                            draft_key: draft_key.clone(), b64_snapshot, content, title,
-                            cursor_offset, editing_uri, editing_cid, export_ms, encode_ms,
-                        }).await {
+                        let title: SmolStr = doc.get_text("title").to_string().into();
+                        if let Err(e) = scope
+                            .send(WorkerOutput::Snapshot {
+                                draft_key: draft_key.clone(),
+                                b64_snapshot,
+                                content,
+                                title,
+                                cursor_offset,
+                                editing_uri,
+                                editing_cid,
+                                export_ms,
+                                encode_ms,
+                            })
+                            .await
+                        {
                             tracing::error!("Failed to send Snapshot to coordinator: {e}");
                         }
                     }
                     // Collab stubs for non-collab-worker build
                     WorkerInput::StartCollab { .. } => {
-                        if let Err(e) = scope.send(WorkerOutput::Error { message: "Collab not enabled".into() }).await {
+                        if let Err(e) = scope
+                            .send(WorkerOutput::Error {
+                                message: "Collab not enabled".into(),
+                            })
+                            .await
+                        {
                             tracing::error!("Failed to send Error to coordinator: {e}");
                         }
                     }
···
         let collaborators = tracker
             .collaborators()
             .map(|c| CollaboratorInfo {
-                node_id: c.node_id.to_string(),
+                node_id: c.node_id.to_smolstr(),
                 did: c.did.clone(),
                 display_name: c.display_name.clone(),
                 color: c.color,
···
     use super::*;
     use crate::cache_impl;
     use gloo_worker::{HandlerId, Worker, WorkerScope};
+    use jacquard::IntoStatic;
     use jacquard::client::UnauthenticatedSession;
     use jacquard::identity::JacquardResolver;
     use jacquard::prelude::*;
     use jacquard::types::string::AtUri;
-    use jacquard::IntoStatic;
     use std::time::Duration;
 
     /// Embed worker with persistent cache.
···
                         let at_uri = match AtUri::new_owned(uri_str.clone()) {
                             Ok(u) => u,
                             Err(e) => {
-                                errors.insert(uri_str, format_smolstr!("Invalid AT URI: {e}").to_string());
+                                errors.insert(uri_str, format!("Invalid AT URI: {e}"));
                                 continue;
                             }
                         };
···
                                     results.insert(uri_str, html);
                                 }
                                 Err(e) => {
-                                    errors.insert(uri_str, format_smolstr!("{:?}", e).to_string());
+                                    errors.insert(uri_str, format!("{:?}", e));
                                 }
                             }
                         }

crates/weaver-app/src/components/entry.rs

···
 use std::sync::Arc;
 use weaver_api::sh_weaver::notebook::{BookEntryView, EntryView, entry};
 
-// #[component]
-// pub fn EntryPage(
-//     ident: ReadSignal<AtIdentifier<'static>>,
-//     book_title: ReadSignal<SmolStr>,
-//     title: ReadSignal<SmolStr>,
-// ) -> Element {
-//     rsx! {
-//         {std::iter::once(rsx! {Entry {ident, book_title, title}})}
-//     }
-// }
-
 #[component]
 pub fn EntryPage(
     ident: ReadSignal<AtIdentifier<'static>>,
···
     // Use read() instead of read_unchecked() for proper reactive tracking
     match &*entry.read() {
         Some((book_entry_view, entry_record)) => {
-            if let Some(embeds) = &entry_record.embeds {
-                if let Some(_images) = &embeds.images {
-                    // Register blob mappings with service worker (client-side only)
-                    // #[cfg(all(
-                    //     target_family = "wasm",
-                    //     target_os = "unknown",
-                    //     not(feature = "fullstack-server")
-                    // ))]
-                    // {
-                    //     let fetcher = fetcher.clone();
-                    //     let images = _images.clone().into_static();
-                    //     spawn(async move {
-                    //         let images = images.clone();
-                    //         let fetcher = fetcher.clone();
-                    //         let _ = crate::service_worker::register_entry_blobs(
-                    //             &ident(),
-                    //             book_title().as_str(),
-                    //             &_images,
-                    //             &fetcher,
-                    //         )
-                    //         .await;
-                    //     });
-                    // }
-                }
-            }
             rsx! { EntryPageView {
                 book_entry_view: book_entry_view.clone(),
                 entry_record: entry_record.clone(),
···
         let truncated: String = cleaned.chars().take(max_len - 3).collect();
         format!("{}...", truncated)
     }
-}
-
-/// Truncate markdown content for preview (preserves markdown syntax)
-/// Takes first few paragraphs up to max_chars, truncating at paragraph boundary
-fn truncate_markdown_preview(content: &str, max_chars: usize, max_paragraphs: usize) -> String {
-    let mut result = String::new();
-    let mut char_count = 0;
-    let mut para_count = 0;
-    let mut in_code_block = false;
-
-    for line in content.lines() {
-        // Track code blocks to avoid breaking them
-        if line.trim().starts_with("```") {
-            in_code_block = !in_code_block;
-            // Skip code blocks in preview entirely
-            if in_code_block {
-                continue;
-            }
-        }
-
-        if in_code_block {
-            continue;
-        }
-
-        // Skip headings, images in preview
-        let trimmed = line.trim();
-        if trimmed.starts_with('#') || trimmed.starts_with('!') {
-            continue;
-        }
-
-        // Empty line = paragraph boundary
-        if trimmed.is_empty() {
-            if !result.is_empty() && !result.ends_with("\n\n") {
-                para_count += 1;
-                if para_count >= max_paragraphs || char_count >= max_chars {
-                    break;
-                }
-                result.push_str("\n\n");
-            }
-            continue;
-        }
-
-        // Check if adding this line would exceed limit
-        if char_count + line.len() > max_chars && !result.is_empty() {
-            break;
-        }
-
-        if !result.is_empty() && !result.ends_with('\n') {
-            result.push('\n');
-        }
-        result.push_str(line);
-        char_count += line.len();
-    }
-
-    result.trim().to_string()
 }
 
 /// OpenGraph and Twitter Card meta tags for entries

crates/weaver-app/src/components/identity.rs

···
     });
 
     // Extract pinned URIs from profile (only Weaver ProfileView has pinned)
+    // Returns (Vec for ordering, HashSet for O(1) lookups)
     let pinned_uris = use_memo(move || {
         use jacquard::IntoStatic;
-        use jacquard::types::aturi::AtUri;
         use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 
         let Some(prof) = profile.read().as_ref().cloned() else {
-            return Vec::<AtUri<'static>>::new();
+            return (Vec::<String>::new(), HashSet::<String>::new());
         };
 
         match &prof.inner {
-            ProfileDataViewInner::ProfileView(p) => p
-                .pinned
-                .as_ref()
-                .map(|pins| pins.iter().map(|r| r.uri.clone().into_static()).collect())
-                .unwrap_or_default(),
-            _ => Vec::new(),
+            ProfileDataViewInner::ProfileView(p) => {
+                let uris: Vec<String> = p
+                    .pinned
+                    .as_ref()
+                    .map(|pins| pins.iter().map(|r| r.uri.as_ref().to_string()).collect())
+                    .unwrap_or_default();
+                let set: HashSet<String> = uris.iter().cloned().collect();
+                (uris, set)
+            }
+            _ => (Vec::new(), HashSet::new()),
         }
     });
 
···
     });
 
     // Helper to check if a URI is pinned
-    fn is_pinned(uri: &str, pinned: &[jacquard::types::aturi::AtUri<'static>]) -> bool {
-        pinned.iter().any(|p| p.as_ref() == uri)
+    fn is_pinned(uri: &str, pinned_set: &HashSet<String>) -> bool {
+        pinned_set.contains(uri)
     }
 
     // Build pinned items (matching notebooks/entries against pinned URIs)
···
         let nbs = notebooks.read();
         let standalone = standalone_entries.read();
         let ents = all_entries.read();
-        let pinned = pinned_uris.read();
+        let (pinned_vec, pinned_set) = &*pinned_uris.read();
 
         let mut items: Vec<ProfileTimelineItem> = Vec::new();
 
···
         if let Some(nbs) = nbs.as_ref() {
             if let Some(all_ents) = ents.as_ref() {
                 for (notebook, entry_refs) in nbs {
-                    if is_pinned(notebook.uri.as_ref(), &pinned) {
+                    if is_pinned(notebook.uri.as_ref(), pinned_set) {
                         let sort_date = entry_refs
                             .iter()
                             .filter_map(|r| {
···
 
         // Check standalone entries
         for (view, entry) in standalone.iter() {
-            if is_pinned(view.uri.as_ref(), &pinned) {
+            if is_pinned(view.uri.as_ref(), pinned_set) {
                 items.push(ProfileTimelineItem::StandaloneEntry {
                     entry_view: view.clone(),
                     entry: entry.clone(),
···
                 ProfileTimelineItem::Notebook { notebook, .. } => notebook.uri.as_ref(),
                 ProfileTimelineItem::StandaloneEntry { entry_view, .. } => entry_view.uri.as_ref(),
             };
-            pinned
+            pinned_vec
                 .iter()
-                .position(|p| p.as_ref() == uri)
+                .position(|p| p == uri)
                 .unwrap_or(usize::MAX)
         });
 
···
         let nbs = notebooks.read();
         let standalone = standalone_entries.read();
         let ents = all_entries.read();
-        let pinned = pinned_uris.read();
+        let (_pinned_vec, pinned_set) = &*pinned_uris.read();
 
         let mut items: Vec<ProfileTimelineItem> = Vec::new();
 
···
         if let Some(nbs) = nbs.as_ref() {
             if let Some(all_ents) = ents.as_ref() {
                 for (notebook, entry_refs) in nbs {
-                    if !is_pinned(notebook.uri.as_ref(), &pinned) {
+                    if !is_pinned(notebook.uri.as_ref(), pinned_set) {
                         let sort_date = entry_refs
                             .iter()
                             .filter_map(|r| {
···
 
         // Add standalone entries (excluding pinned)
         for (view, entry) in standalone.iter() {
-            if !is_pinned(view.uri.as_ref(), &pinned) {
+            if !is_pinned(view.uri.as_ref(), pinned_set) {
                 items.push(ProfileTimelineItem::StandaloneEntry {
                     entry_view: view.clone(),
                     entry: entry.clone(),
···
 }
 
 #[component]
+fn NotebookEntryPreview(
+    book_entry_view: weaver_api::sh_weaver::notebook::BookEntryView<'static>,
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+    #[props(default)] extra_class: Option<&'static str>,
+) -> Element {
+    use jacquard::{IntoStatic, from_data};
+    use weaver_api::sh_weaver::notebook::entry::Entry;
+
+    let entry_view = &book_entry_view.entry;
+
+    let entry_title = entry_view.title.as_ref()
+        .map(|t| t.as_ref())
+        .unwrap_or("Untitled");
+
+    let entry_path = entry_view.path
+        .as_ref()
+        .map(|p| p.as_ref().to_string())
+        .unwrap_or_else(|| entry_title.to_string());
+
+    let parsed_entry = from_data::<Entry>(&entry_view.record).ok();
+
+    let preview_html = parsed_entry.as_ref().map(|entry| {
+        let parser = markdown_weaver::Parser::new(&entry.content);
+        let mut html_buf = String::new();
+        markdown_weaver::html::push_html(&mut html_buf, parser);
+        html_buf
+    });
+
+    let created_at = parsed_entry.as_ref()
+        .map(|entry| entry.created_at.as_ref().format("%B %d, %Y").to_string());
+
+    let entry_uri = entry_view.uri.clone().into_static();
+
+    let class_name = if let Some(extra) = extra_class {
+        format!("notebook-entry-preview {}", extra)
+    } else {
+        "notebook-entry-preview".to_string()
+    };
+
+    rsx! {
+        div { class: "{class_name}",
+            div { class: "entry-preview-header",
+                Link {
+                    to: Route::EntryPage {
+                        ident: ident.clone(),
+                        book_title: book_title.clone(),
+                        title: entry_path.clone().into()
+                    },
+                    class: "entry-preview-title-link",
+                    div { class: "entry-preview-title", "{entry_title}" }
+                }
+                if let Some(ref date) = created_at {
+                    div { class: "entry-preview-date", "{date}" }
+                }
+                crate::components::EntryActions {
+                    entry_uri,
+                    entry_cid: entry_view.cid.clone().into_static(),
+                    entry_title: entry_title.to_string(),
+                    in_notebook: true,
+                    notebook_title: Some(book_title.clone()),
+                    permissions: entry_view.permissions.clone()
+                }
+            }
+            if let Some(ref html) = preview_html {
+                Link {
+                    to: Route::EntryPage {
+                        ident: ident.clone(),
+                        book_title: book_title.clone(),
+                        title: entry_path.clone().into()
+                    },
+                    class: "entry-preview-content-link",
+                    div { class: "entry-preview-content", dangerous_inner_html: "{html}" }
+                }
+            }
+        }
+    }
+}
+
+#[component]
 pub fn NotebookCard(
     notebook: NotebookView<'static>,
     entry_refs: Vec<StrongRef<'static>>,
···
                             if entry_list.len() <= 5 {
                                 // Show all entries if 5 or fewer
                                 rsx! {
-                                    for  entry_view in entry_list.iter() {
-                                        {
-                                            let entry_title = entry_view.entry.title.as_ref()
-                                                .map(|t| t.as_ref())
-                                                .unwrap_or("Untitled");
-
-                                            // Get path from view, fallback to title
-                                            let entry_path = entry_view.entry.path
-                                                .as_ref()
-                                                .map(|p| p.as_ref().to_string())
-                                                .unwrap_or_else(|| entry_title.to_string());
-
-                                            // Parse entry for created_at and preview
-                                            let parsed_entry = from_data::<Entry>(&entry_view.entry.record).ok();
-
-                                            let preview_html = parsed_entry.as_ref().map(|entry| {
-                                                let parser = markdown_weaver::Parser::new(&entry.content);
-                                                let mut html_buf = String::new();
-                                                markdown_weaver::html::push_html(&mut html_buf, parser);
-                                                html_buf
-                                            });
-
-                                            let created_at = parsed_entry.as_ref()
-                                                .map(|entry| entry.created_at.as_ref().format("%B %d, %Y").to_string());
-
-                                            let entry_uri = entry_view.entry.uri.clone().into_static();
-
-                                            rsx! {
-                                                div { class: "notebook-entry-preview",
-                                                    div { class: "entry-preview-header",
-                                                        Link {
-                                                            to: Route::EntryPage {
-                                                                ident: ident.clone(),
-                                                                book_title: book_title.clone(),
-                                                                title: entry_path.clone().into()
-                                                            },
-                                                            class: "entry-preview-title-link",
-                                                            div { class: "entry-preview-title", "{entry_title}" }
-                                                        }
-                                                        if let Some(ref date) = created_at {
-                                                            div { class: "entry-preview-date", "{date}" }
-                                                        }
-                                                        // EntryActions handles visibility via permissions
-                                                        crate::components::EntryActions {
-                                                            entry_uri,
-                                                            entry_cid: entry_view.entry.cid.clone().into_static(),
-                                                            entry_title: entry_title.to_string(),
-                                                            in_notebook: true,
-                                                            notebook_title: Some(book_title.clone()),
-                                                            permissions: entry_view.entry.permissions.clone()
-                                                        }
-                                                    }
-                                                    if let Some(ref html) = preview_html {
-                                                        Link {
-                                                            to: Route::EntryPage {
-                                                                ident: ident.clone(),
-                                                                book_title: book_title.clone(),
-                                                                title: entry_path.clone().into()
-                                                            },
-                                                            class: "entry-preview-content-link",
-                                                            div { class: "entry-preview-content", dangerous_inner_html: "{html}" }
-                                                        }
-                                                    }
-                                                }
-                                            }
+                                    for entry_view in entry_list.iter() {
+                                        NotebookEntryPreview {
+                                            book_entry_view: entry_view.clone(),
+                                            ident: ident.clone(),
+                                            book_title: book_title.clone(),
                                         }
                                     }
                                 }
···
                                 // Show first, interstitial, and last
                                 rsx! {
                                     if let Some(first_entry) = entry_list.first() {
-                                        {
-                                            let entry_title = first_entry.entry.title.as_ref()
-                                                .map(|t| t.as_ref())
-                                                .unwrap_or("Untitled");
-
-                                            // Get path from view, fallback to title
-                                            let entry_path = first_entry.entry.path
-                                                .as_ref()
-                                                .map(|p| p.as_ref().to_string())
-                                                .unwrap_or_else(|| entry_title.to_string());
-
-                                            // Parse entry for created_at and preview
-                                            let parsed_entry = from_data::<Entry>(&first_entry.entry.record).ok();
-
-                                            let preview_html = parsed_entry.as_ref().map(|entry| {
-                                                let parser = markdown_weaver::Parser::new(&entry.content);
-                                                let mut html_buf = String::new();
-                                                markdown_weaver::html::push_html(&mut html_buf, parser);
-                                                html_buf
-                                            });
-
-                                            let created_at = parsed_entry.as_ref()
-                                                .map(|entry| entry.created_at.as_ref().format("%B %d, %Y").to_string());
-
-                                            let entry_uri = first_entry.entry.uri.clone().into_static();
-
-                                            rsx! {
-                                                div { class: "notebook-entry-preview notebook-entry-preview-first",
-                                                    div { class: "entry-preview-header",
-                                                        Link {
-                                                            to: Route::EntryPage {
-                                                                ident: ident.clone(),
-                                                                book_title: book_title.clone(),
-                                                                title: entry_path.clone().into()
-                                                            },
-                                                            class: "entry-preview-title-link",
-                                                            div { class: "entry-preview-title", "{entry_title}" }
-                                                        }
-                                                        if let Some(ref date) = created_at {
-                                                            div { class: "entry-preview-date", "{date}" }
-                                                        }
-                                                        // EntryActions handles visibility via permissions
-                                                        crate::components::EntryActions {
-                                                            entry_uri,
-                                                            entry_cid: first_entry.entry.cid.clone().into_static(),
-                                                            entry_title: entry_title.to_string(),
-                                                            in_notebook: true,
-                                                            notebook_title: Some(book_title.clone()),
-                                                            permissions: first_entry.entry.permissions.clone()
-                                                        }
-                                                    }
-                                                    if let Some(ref html) = preview_html {
-                                                        Link {
-                                                            to: Route::EntryPage {
-                                                                ident: ident.clone(),
-                                                                book_title: book_title.clone(),
-                                                                title: entry_path.clone().into()
-                                                            },
-                                                            class: "entry-preview-content-link",
-                                                            div { class: "entry-preview-content", dangerous_inner_html: "{html}" }
-                                                        }
-                                                    }
-                                                }
-                                            }
+                                        NotebookEntryPreview {
+                                            book_entry_view: first_entry.clone(),
+                                            ident: ident.clone(),
+                                            book_title: book_title.clone(),
+                                            extra_class: "notebook-entry-preview-first",
                                         }
                                     }
 
···
                                     }
 
                                     if let Some(last_entry) = entry_list.last() {
-                                        {
-                                            let entry_title = last_entry.entry.title.as_ref()
-                                                .map(|t| t.as_ref())
-                                                .unwrap_or("Untitled");
-
-                                            // Get path from view, fallback to title
-                                            let entry_path = last_entry.entry.path
-                                                .as_ref()
-                                                .map(|p| p.as_ref().to_string())
-                                                .unwrap_or_else(|| entry_title.to_string());
-
-                                            // Parse entry for created_at and preview
-                                            let parsed_entry = from_data::<Entry>(&last_entry.entry.record).ok();
-
-                                            let preview_html = parsed_entry.as_ref().map(|entry| {
-                                                let parser = markdown_weaver::Parser::new(&entry.content);
-                                                let mut html_buf = String::new();
-                                                markdown_weaver::html::push_html(&mut html_buf, parser);
-                                                html_buf
-                                            });
-
-                                            let created_at = parsed_entry.as_ref()
-                                                .map(|entry| entry.created_at.as_ref().format("%B %d, %Y").to_string());
-
-                                            let entry_uri = last_entry.entry.uri.clone().into_static();
-
-                                            rsx! {
-                                                div { class: "notebook-entry-preview notebook-entry-preview-last",
-                                                    div { class: "entry-preview-header",
-                                                        Link {
-                                                            to: Route::EntryPage {
-                                                                ident: ident.clone(),
-                                                                book_title: book_title.clone(),
-                                                                title: entry_path.clone().into()
-                                                            },
-                                                            class: "entry-preview-title-link",
-                                                            div { class: "entry-preview-title", "{entry_title}" }
-                                                        }
-                                                        if let Some(ref date) = created_at {
-                                                            div { class: "entry-preview-date", "{date}" }
-                                                        }
-                                                        // EntryActions handles visibility via permissions
-                                                        crate::components::EntryActions {
-                                                            entry_uri,
-                                                            entry_cid: last_entry.entry.cid.clone().into_static(),
-                                                            entry_title: entry_title.to_string(),
-                                                            in_notebook: true,
-                                                            notebook_title: Some(book_title.clone()),
-                                                            permissions: last_entry.entry.permissions.clone()
-                                                        }
-                                                    }
-                                                    if let Some(ref html) = preview_html {
-                                                        Link {
-                                                            to: Route::EntryPage {
-                                                                ident: ident.clone(),
-                                                                book_title: book_title.clone(),
-                                                                title: entry_path.clone().into()
-                                                            },
-                                                            class: "entry-preview-content-link",
-                                                            div { class: "entry-preview-content", dangerous_inner_html: "{html}" }
-                                                        }
-                                                    }
-                                                }
-                                            }
+                                        NotebookEntryPreview {
+                                            book_entry_view: last_entry.clone(),
+                                            ident: ident.clone(),
+                                            book_title: book_title.clone(),
+                                            extra_class: "notebook-entry-preview-last",
                                         }
                                     }
                                 }

crates/weaver-app/src/data.rs

···
                                         .await
                                         .ok();
                                     }
-                                    #[cfg(all(target_family = "wasm", target_os = "unknown",))]
-                                    {
-                                        tracing::info!("Registering standalone entry blobs");
-                                        let _ =
-                                            crate::service_worker::register_standalone_entry_blobs(
-                                                &ident,
-                                                at_uri.rkey().unwrap().0.as_str(),
-                                                images,
-                                                &fetcher,
-                                            )
-                                            .await;
-                                    }
                                 }
                             }
                         }

crates/weaver-app/src/og/mod.rs

···
 
 use crate::cache_impl::{Cache, new_cache};
 use askama::Template;
-use jacquard::smol_str::SmolStr;
-use jacquard::smol_str::format_smolstr;
+use jacquard::smol_str::{SmolStr, ToSmolStr, format_smolstr};
 use std::sync::OnceLock;
 use std::time::Duration;
 
···
 #[derive(Debug)]
 pub enum OgError {
     NotFound,
-    FetchError(String),
-    RenderError(String),
-    TemplateError(String),
+    FetchError(SmolStr),
+    RenderError(SmolStr),
+    TemplateError(SmolStr),
 }
 
 impl std::fmt::Display for OgError {
···
 pub struct TextOnlyTemplate {
     pub title_lines: Vec<String>,
     pub content_lines: Vec<String>,
-    pub notebook_title: String,
-    pub author_handle: String,
+    pub notebook_title: SmolStr,
+    pub author_handle: SmolStr,
 }
 
 /// Hero image template (full-bleed image with overlay)
···
 pub struct HeroImageTemplate {
     pub hero_image_data: String,
     pub title_lines: Vec<String>,
-    pub notebook_title: String,
-    pub author_handle: String,
+    pub notebook_title: SmolStr,
+    pub author_handle: SmolStr,
 }
 
 /// Notebook index template
···
 #[template(path = "og_notebook.svg", escape = "none")]
 pub struct NotebookTemplate {
     pub title_lines: Vec<String>,
-    pub author_handle: String,
+    pub author_handle: SmolStr,
     pub entry_count: usize,
     pub entry_titles: Vec<String>,
 }
···
 pub struct ProfileTemplate {
     pub avatar_data: Option<String>,
     pub display_name_lines: Vec<String>,
-    pub handle: String,
+    pub handle: SmolStr,
     pub bio_lines: Vec<String>,
     pub notebook_count: usize,
 }
···
     pub banner_image_data: String,
     pub avatar_data: Option<String>,
     pub display_name_lines: Vec<String>,
-    pub handle: String,
+    pub handle: SmolStr,
     pub bio_lines: Vec<String>,
     pub notebook_count: usize,
 }
···
     };
 
     let tree = usvg::Tree::from_str(svg, &options)
-        .map_err(|e| OgError::RenderError(format!("Failed to parse SVG: {}", e)))?;
+        .map_err(|e| OgError::RenderError(format_smolstr!("Failed to parse SVG: {}", e)))?;
 
     let mut pixmap = tiny_skia::Pixmap::new(OG_WIDTH, OG_HEIGHT)
-        .ok_or_else(|| OgError::RenderError("Failed to create pixmap".to_string()))?;
+        .ok_or_else(|| OgError::RenderError("Failed to create pixmap".to_smolstr()))?;
 
     resvg::render(&tree, tiny_skia::Transform::default(), &mut pixmap.as_mut());
 
     pixmap
         .encode_png()
-        .map_err(|e| OgError::RenderError(format!("Failed to encode PNG: {}", e)))
+        .map_err(|e| OgError::RenderError(format_smolstr!("Failed to encode PNG: {}", e)))
 }
 
 /// Generate a text-only OG image
···
     let template = TextOnlyTemplate {
         title_lines,
         content_lines,
-        notebook_title: notebook_title.to_string(),
-        author_handle: author_handle.to_string(),
+        notebook_title: notebook_title.to_smolstr(),
+        author_handle: author_handle.to_smolstr(),
     };
 
     let svg = template
         .render()
-        .map_err(|e| OgError::TemplateError(e.to_string()))?;
+        .map_err(|e| OgError::TemplateError(e.to_smolstr()))?;
 
     render_svg_to_png(&svg)
 }
···
     let template = HeroImageTemplate {
         hero_image_data: hero_image_data.to_string(),
         title_lines,
-        notebook_title: notebook_title.to_string(),
-        author_handle: author_handle.to_string(),
+        notebook_title: notebook_title.to_smolstr(),
+        author_handle: author_handle.to_smolstr(),
     };
 
     let svg = template
         .render()
-        .map_err(|e| OgError::TemplateError(e.to_string()))?;
+        .map_err(|e| OgError::TemplateError(e.to_smolstr()))?;
 
     render_svg_to_png(&svg)
 }
···
 
     let template = NotebookTemplate {
         title_lines,
-        author_handle: author_handle.to_string(),
+        author_handle: author_handle.to_smolstr(),
         entry_count,
         entry_titles,
     };
 
     let svg = template
         .render()
-        .map_err(|e| OgError::TemplateError(e.to_string()))?;
+        .map_err(|e| OgError::TemplateError(e.to_smolstr()))?;
 
     render_svg_to_png(&svg)
 }
···
     let template = ProfileTemplate {
         avatar_data,
         display_name_lines,
-        handle: handle.to_string(),
+        handle: handle.to_smolstr(),
         bio_lines,
         notebook_count,
     };
 
     let svg = template
         .render()
-        .map_err(|e| OgError::TemplateError(e.to_string()))?;
+        .map_err(|e| OgError::TemplateError(e.to_smolstr()))?;
 
     render_svg_to_png(&svg)
 }
···
         banner_image_data,
         avatar_data,
         display_name_lines,
-        handle: handle.to_string(),
+        handle: handle.to_smolstr(),
         bio_lines,
         notebook_count,
     };
 
     let svg = template
         .render()
-        .map_err(|e| OgError::TemplateError(e.to_string()))?;
+        .map_err(|e| OgError::TemplateError(e.to_smolstr()))?;
 
     render_svg_to_png(&svg)
 }
···
 
     let svg = template
         .render()
-        .map_err(|e| OgError::TemplateError(e.to_string()))?;
+        .map_err(|e| OgError::TemplateError(e.to_smolstr()))?;
 
     render_svg_to_png(&svg)
 }

crates/weaver-common/src/agent.rs

···
 use jacquard::types::string::{AtUri, Did, RecordKey, Rkey};
 use jacquard::types::tid::Tid;
 use jacquard::types::uri::Uri;
+use jacquard::smol_str::SmolStr;
 use jacquard::url::Url;
 use jacquard::{CowStr, IntoStatic};
 use mime_sniffer::MimeTypeSniffer;
···
 
                 peers.push(SessionPeer {
                     did: record_id.did.into_static(),
-                    node_id: session_record.value.node_id.to_string(),
+                    node_id: session_record.value.node_id.as_ref().into(),
                     relay_url: session_record
                         .value
                         .relay_url
-                        .map(|u| u.as_str().to_string()),
+                        .map(|u| u.as_ref().into()),
                     created_at: session_record.value.created_at,
                     expires_at: session_record.value.expires_at,
                 });
···
     /// The peer's DID.
     pub did: Did<'a>,
     /// The peer's iroh NodeId (z-base32 encoded).
-    pub node_id: String,
+    pub node_id: SmolStr,
     /// Optional relay URL for browser clients.
-    pub relay_url: Option<String>,
+    pub relay_url: Option<SmolStr>,
     /// When the session was created.
     pub created_at: jacquard::types::string::Datetime,
     /// When the session expires (if set).

crates/weaver-common/src/transport/messages.rs

···
 //! Wire protocol for collaborative editing messages.
 
+use jacquard::smol_str::SmolStr;
 use serde::{Deserialize, Serialize};
 
 /// Messages exchanged between collaborators over gossip.
···
     /// Collaborator joined the session
     Join {
         /// DID of the joining user
-        did: String,
+        did: SmolStr,
         /// Display name for presence UI
-        display_name: String,
+        display_name: SmolStr,
     },
 
     /// Collaborator left the session
     Leave {
         /// DID of the leaving user
-        did: String,
+        did: SmolStr,
     },
 
     /// Request sync from peers (late joiner)
···
     #[test]
     fn test_roundtrip_join() {
         let msg = CollabMessage::Join {
-            did: "did:plc:abc123".to_string(),
-            display_name: "Alice".to_string(),
+            did: "did:plc:abc123".into(),
+            display_name: "Alice".into(),
         };
         let bytes = msg.to_bytes().unwrap();
         let decoded = CollabMessage::from_bytes(&bytes).unwrap();

crates/weaver-common/src/transport/node.rs

···
 use iroh::EndpointId;
 use iroh::SecretKey;
 use iroh_gossip::net::{GOSSIP_ALPN, Gossip};
+use jacquard::smol_str::{SmolStr, ToSmolStr};
 use miette::Diagnostic;
 use std::sync::Arc;
 
···
     }
 
     /// Get the node ID as a z-base32 string for storage in AT Protocol records.
-    pub fn node_id_string(&self) -> String {
-        self.endpoint.id().to_string()
+    pub fn node_id_string(&self) -> SmolStr {
+        self.endpoint.id().to_smolstr()
     }
 
     /// Get a reference to the gossip handler for joining topics.
···
     ///
     /// This should be published in session records so other peers can connect
     /// via relay (essential for browser-to-browser connections).
-    pub fn relay_url(&self) -> Option<String> {
+    pub fn relay_url(&self) -> Option<SmolStr> {
         self.endpoint
             .addr()
             .relay_urls()
             .next()
-            .map(|url| url.to_string())
+            .map(|url| url.to_smolstr())
     }
 
     /// Get the full node address including relay info.
···
     ///
     /// Waits indefinitely for relay - browser clients require relay URLs
     /// for peer discovery. Returns the relay URL once connected.
-    pub async fn wait_for_relay(&self) -> String {
+    pub async fn wait_for_relay(&self) -> SmolStr {
         self.endpoint.online().await;
         // After online(), relay_url should always be Some for browser clients
         self.relay_url()

crates/weaver-common/src/transport/presence.rs

···
 use std::collections::HashMap;
 
 use iroh::EndpointId;
+use jacquard::smol_str::SmolStr;
 use web_time::Instant;
 
 /// A remote collaborator's cursor state.
···
 #[derive(Debug, Clone)]
 pub struct Collaborator {
     /// The collaborator's DID.
-    pub did: String,
+    pub did: SmolStr,
     /// Display name for UI.
-    pub display_name: String,
+    pub display_name: SmolStr,
     /// Assigned colour (RGBA).
     pub color: u32,
     /// Current cursor state.
···
     }
 
     /// Add a collaborator when they join.
-    pub fn add_collaborator(&mut self, node_id: EndpointId, did: String, display_name: String) {
+    pub fn add_collaborator(
+        &mut self,
+        node_id: EndpointId,
+        did: impl Into<SmolStr>,
+        display_name: impl Into<SmolStr>,
+    ) {
         let color = self.assign_color();
         self.collaborators.insert(
             node_id,
             Collaborator {
-                did,
-                display_name,
+                did: did.into(),
+                display_name: display_name.into(),
                 color,
                 cursor: None,
                 node_id,

crates/weaver-common/src/transport/presence_types.rs

···
 //! Presence types for main thread rendering.
 //!
-//! These types use String node IDs instead of EndpointId,
+//! These types use SmolStr node IDs instead of EndpointId,
 //! allowing them to be used without the iroh feature.
 
+use jacquard::smol_str::SmolStr;
 use serde::{Deserialize, Serialize};
 
 /// A remote collaborator's cursor for rendering.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct RemoteCursorInfo {
     /// Node ID as string (z-base32 encoded)
-    pub node_id: String,
+    pub node_id: SmolStr,
     /// Character offset in the document
     pub position: usize,
     /// Selection range (anchor, head) if any
···
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct CollaboratorInfo {
     /// Node ID as string
-    pub node_id: String,
+    pub node_id: SmolStr,
     /// The collaborator's DID
-    pub did: String,
+    pub did: SmolStr,
     /// Display name for UI
-    pub display_name: String,
+    pub display_name: SmolStr,
     /// Assigned colour (RGBA)
     pub color: u32,
     /// Current cursor position (if known)