clean up

crates/weaver-app/src/blobcache.rs

···
     IntoStatic,
     bytes::Bytes,
     prelude::*,
-    smol_str::SmolStr,
+    smol_str::{SmolStr, format_smolstr},
     types::{cid::Cid, collection::Collection, ident::AtIdentifier, nsid::Nsid, string::Rkey},
     xrpc::XrpcExt,
 };
···
                     .build(),
             )
             .await
-            .map_err(|e| CapturedError::from_display(format!("Failed to fetch entry: {}", e)))?;
+            .map_err(|e| CapturedError::from_display(format_smolstr!("Failed to fetch entry: {}", e).as_str().to_string()))?;
 
         let record = resp
             .into_output()
-            .map_err(|e| CapturedError::from_display(format!("Failed to parse entry: {}", e)))?;
+            .map_err(|e| CapturedError::from_display(format_smolstr!("Failed to parse entry: {}", e).as_str().to_string()))?;
 
         // Parse the entry
         let entry: Entry = jacquard::from_data(&record.value).map_err(|e| {
-            CapturedError::from_display(format!("Failed to deserialize entry: {}", e))
+            CapturedError::from_display(format_smolstr!("Failed to deserialize entry: {}", e).as_str().to_string())
         })?;
 
         // Find the image by name
···
             })
             .map(|img| img.image.blob().cid().clone().into_static())
             .ok_or_else(|| {
-                CapturedError::from_display(format!("Image '{}' not found in entry", name))
+                CapturedError::from_display(format_smolstr!("Image '{}' not found in entry", name).as_str().to_string())
             })?;
 
         // Check cache first
···
             )
             .await
             .map_err(|e| {
-                CapturedError::from_display(format!("Failed to fetch PublishedBlob: {}", e))
+                CapturedError::from_display(format_smolstr!("Failed to fetch PublishedBlob: {}", e).as_str().to_string())
             })?;
 
         let record = resp.into_output().map_err(|e| {
-            CapturedError::from_display(format!("Failed to parse PublishedBlob: {}", e))
+            CapturedError::from_display(format_smolstr!("Failed to parse PublishedBlob: {}", e).as_str().to_string())
         })?;
 
         // Parse the PublishedBlob
         let published: PublishedBlob = jacquard::from_data(&record.value).map_err(|e| {
-            CapturedError::from_display(format!("Failed to deserialize PublishedBlob: {}", e))
+            CapturedError::from_display(format_smolstr!("Failed to deserialize PublishedBlob: {}", e).as_str().to_string())
         })?;
 
         // Get CID from the upload blob ref
···
         image_name: &str,
     ) -> Result<Bytes> {
         // Try scoped cache key first: {notebook_key}_{image_name}
-        let cache_key: SmolStr = format!("{}_{}", notebook_key, image_name).into();
+        let cache_key = format_smolstr!("{}_{}", notebook_key, image_name);
         if let Some(bytes) = self.get_named(&cache_key) {
             return Ok(bytes);
         }
···
             .get_notebook_by_key(notebook_key)
             .await?
             .ok_or_else(|| {
-                CapturedError::from_display(format!("Notebook '{}' not found", notebook_key))
+                CapturedError::from_display(format_smolstr!("Notebook '{}' not found", notebook_key).as_str().to_string())
             })?;
 
         let (view, entry_refs) = notebook.as_ref();
 
         // Get the DID from the notebook URI for blob fetching
         let notebook_did = jacquard::types::aturi::AtUri::new(view.uri.as_ref())
-            .map_err(|e| CapturedError::from_display(format!("Invalid notebook URI: {}", e)))?
+            .map_err(|e| CapturedError::from_display(format_smolstr!("Invalid notebook URI: {}", e).as_str().to_string()))?
             .authority()
             .clone()
             .into_static();
···
         for entry_ref in entry_refs {
             // Parse the entry URI to get rkey
             let entry_uri = jacquard::types::aturi::AtUri::new(entry_ref.uri.as_ref())
-                .map_err(|e| CapturedError::from_display(format!("Invalid entry URI: {}", e)))?;
+                .map_err(|e| CapturedError::from_display(format_smolstr!("Invalid entry URI: {}", e).as_str().to_string()))?;
             let rkey = entry_uri
                 .rkey()
                 .ok_or_else(|| CapturedError::from_display("Entry URI missing rkey"))?;
···
             }
         }
 
-        Err(CapturedError::from_display(format!(
+        Err(CapturedError::from_display(format_smolstr!(
             "Image '{}' not found in notebook '{}'",
             image_name, notebook_key
-        )))
+        ).as_str().to_string()))
     }
 
     /// Insert bytes directly into cache (for pre-warming after upload)

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

···
 use crate::fetch::Fetcher;
 use jacquard::IntoStatic;
 use jacquard::prelude::*;
-use jacquard::types::collection::Collection;
-use jacquard::types::string::{AtUri, Cid, Datetime, Did, Nsid, RecordKey};
+use jacquard::smol_str::format_smolstr;
+use jacquard::types::string::{AtUri, Cid, Datetime, Did, Nsid};
 use jacquard::types::uri::Uri;
 use reqwest::Url;
 use std::collections::HashSet;
 use weaver_api::com_atproto::repo::list_records::ListRecords;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
 use weaver_api::sh_weaver::collab::{accept::Accept, invite::Invite};
-use weaver_api::sh_weaver::notebook::entry::Entry;
 use weaver_common::WeaverError;
 use weaver_common::constellation::GetBacklinksQuery;
 
 const ACCEPT_NSID: &str = "sh.weaver.collab.accept";
+const INVITE_NSID: &str = "sh.weaver.collab.invite";
 const CONSTELLATION_URL: &str = "https://constellation.microcosm.blue";
 
 /// An invite sent by the current user.
···
     let output = fetcher
         .create_record(invite, None)
         .await
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Failed to create invite: {}", e)))?;
+        .map_err(|e| WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Failed to create invite: {}", e).into()))?;
 
     Ok(output.uri.into_static())
 }
···
     let output = fetcher
         .create_record(accept, None)
         .await
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Failed to accept invite: {}", e)))?;
+        .map_err(|e| WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Failed to accept invite: {}", e).into()))?;
 
     Ok(output.uri.into_static())
 }
···
 
     let request = ListRecords::new()
         .repo(did)
-        .collection(Nsid::raw(Invite::NSID))
+        .collection(Nsid::raw(INVITE_NSID))
         .limit(100)
         .build();
 
     let response = fetcher
         .send(request)
         .await
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Failed to list invites: {}", e)))?;
+        .map_err(|e| WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Failed to list invites: {}", e).into()))?;
 
     let output = response.into_output().map_err(|e| {
-        WeaverError::InvalidNotebook(format!("Failed to parse list response: {}", e))
+        WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Failed to parse list response: {}", e).into())
     })?;
 
     let mut invites = Vec::new();
···
     // Query for sh.weaver.collab.accept records that reference this invite via .invite.uri
     let query = GetBacklinksQuery {
         subject: Uri::At(invite_uri.clone().into_static()),
-        source: format!("{}:invite.uri", ACCEPT_NSID).into(),
+        source: jacquard::smol_str::format_smolstr!("{}:invite.uri", ACCEPT_NSID).into(),
         cursor: None,
         did: vec![],
         limit: 1,
···
         .ok_or_else(|| WeaverError::InvalidNotebook("Not authenticated".into()))?;
 
     let constellation_url = Url::parse(CONSTELLATION_URL)
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid constellation URL: {}", e)))?;
+        .map_err(|e| WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Invalid constellation URL: {}", e).into()))?;
 
     // Query for sh.weaver.collab.invite records where .invitee = current user's DID
     let query = GetBacklinksQuery {
         subject: Uri::Did(did.clone()),
-        source: format!("{}:invitee", Invite::NSID).into(),
+        source: jacquard::smol_str::format_smolstr!("{}:invitee", INVITE_NSID).into(),
         cursor: None,
         did: vec![],
         limit: 100,
···
         .xrpc(constellation_url)
         .send(&query)
         .await
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Constellation query failed: {}", e)))?;
+        .map_err(|e| WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Constellation query failed: {}", e).into()))?;
 
     let output = response.into_output().map_err(|e| {
-        WeaverError::InvalidNotebook(format!("Failed to parse constellation response: {}", e))
+        WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Failed to parse constellation response: {}", e).into())
     })?;
 
     // For each RecordId, fetch the actual record from the inviter's PDS
···
         let inviter_did = record_id.did.into_static();
 
         // Build the AT-URI for the invite record
-        let uri_string = format!(
+        let uri_string = jacquard::smol_str::format_smolstr!(
             "at://{}/{}/{}",
             inviter_did,
-            Invite::NSID,
+            INVITE_NSID,
             record_id.rkey.as_ref()
         );
         let Ok(invite_uri) = AtUri::new(&uri_string) else {
···
     };
 
     let constellation_url = Url::parse(CONSTELLATION_URL)
-        .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid constellation URL: {}", e)))?;
+        .map_err(|e| WeaverError::InvalidNotebook(jacquard::smol_str::format_smolstr!("Invalid constellation URL: {}", e).into()))?;
 
     // Query for all invite records that reference entries with this rkey
     // We search for invites where resource.uri contains the rkey
     // The source pattern matches the JSON path in the invite record
     let query = GetBacklinksQuery {
         subject: Uri::At(resource_uri.clone().into_static()),
-        source: format!("{}:resource.uri", Invite::NSID).into(),
+        source: jacquard::smol_str::format_smolstr!("{}:resource.uri", INVITE_NSID).into(),
         cursor: None,
         did: vec![],
         limit: 100,
···
                 participants.insert(record_id.did.clone().into_static());
 
                 // Now we need to fetch the invite to get the invitee
-                let uri_string = format!(
+                let uri_string = jacquard::smol_str::format_smolstr!(
                     "at://{}/{}/{}",
                     record_id.did,
-                    Invite::NSID,
+                    INVITE_NSID,
                     record_id.rkey.as_ref()
                 );
                 if let Ok(invite_uri) = AtUri::new(&uri_string) {

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

···
 use crate::components::input::Input;
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
+use jacquard::smol_str::format_smolstr;
 use jacquard::types::string::{AtUri, Cid, Handle};
 use jacquard::{IntoStatic, prelude::*};
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
···
             let handle = match Handle::new(&handle) {
                 Ok(h) => h,
                 Err(e) => {
-                    error.set(Some(format!("Invalid handle: {}", e)));
+                    error.set(Some(format_smolstr!("Invalid handle: {}", e).into()));
                     is_sending.set(false);
                     return;
                 }
···
             let invitee_did = match fetcher.resolve_handle(&handle).await {
                 Ok(did) => did,
                 Err(e) => {
-                    error.set(Some(format!("Could not resolve handle: {}", e)));
+                    error.set(Some(format_smolstr!("Could not resolve handle: {}", e).into()));
                     is_sending.set(false);
                     return;
                 }
···
             let cid = match Cid::new(resource_cid.as_bytes()) {
                 Ok(c) => c.into_static(),
                 Err(e) => {
-                    error.set(Some(format!("Invalid CID: {}", e)));
+                    error.set(Some(format_smolstr!("Invalid CID: {}", e).into()));
                     is_sending.set(false);
                     return;
                 }
···
                     on_close.call(());
                 }
                 Err(e) => {
-                    error.set(Some(format!("Failed to send invite: {}", e)));
+                    error.set(Some(format_smolstr!("Failed to send invite: {}", e).into()));
                 }
             }
 

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

···
 use jacquard::bytes::Bytes;
 use jacquard::cowstr::ToCowStr;
 use jacquard::prelude::*;
+use jacquard::smol_str::format_smolstr;
 use jacquard::types::blob::MimeType;
 use jacquard::types::collection::Collection;
 use jacquard::types::ident::AtIdentifier;
···
             };
 
             // Build AT-URI pointing to actual draft record: at://{did}/sh.weaver.edit.draft/{rkey}
-            let canonical_uri = format!("at://{}/{}/{}", did, DRAFT_NSID, rkey);
+            let canonical_uri = format_smolstr!("at://{}/{}/{}", did, DRAFT_NSID, rkey);
 
             DocRef {
                 value: DocRefValue::DraftRef(Box::new(DraftRef {
···
 
     let query = GetBacklinksQuery {
         subject: Uri::At(entry_uri.clone().into_static()),
-        source: format!("{}:doc.value.entry.uri", ROOT_NSID).into(),
+        source: format_smolstr!("{}:doc.value.entry.uri", ROOT_NSID).into(),
         cursor: None,
         did: vec![],
         limit: 1,
···
     // Query for edit.root records from this DID that reference entry_uri
     let query = GetBacklinksQuery {
         subject: Uri::At(entry_uri.clone().into_static()),
-        source: format!("{}:doc.value.entry.uri", ROOT_NSID).into(),
+        source: format_smolstr!("{}:doc.value.entry.uri", ROOT_NSID).into(),
         cursor: None,
         did: all_dids.clone(),
         limit: 10,
···
 
     let query = GetBacklinksQuery {
         subject: Uri::At(draft_uri.clone().into_static()),
-        source: format!("{}:doc.value.draft_key", ROOT_NSID).into(),
+        source: format_smolstr!("{}:doc.value.draft_key", ROOT_NSID).into(),
         cursor: None,
         did: vec![],
         limit: 1,
···
         draft_key.to_string()
     };
 
-    let uri_str = format!("at://{}/{}/{}", did, DRAFT_NSID, rkey);
+    let uri_str = format_smolstr!("at://{}/{}/{}", did, DRAFT_NSID, rkey);
     // Safe to unwrap: we're constructing a valid AT-URI
     AtUri::new(&uri_str).unwrap().into_static()
 }
···
     loop {
         let query = GetBacklinksQuery {
             subject: Uri::At(root_uri.clone().into_static()),
-            source: format!("{}:root.uri", DIFF_NSID).into(),
+            source: format_smolstr!("{}:root.uri", DIFF_NSID).into(),
             cursor: cursor.map(Into::into),
             did: vec![],
             limit: 100,
···
         let root_did = root_id.did.clone();
 
         // Build root URI to look up last seen diff
-        let root_uri = AtUri::new(&format!(
+        let root_uri = AtUri::new(&format_smolstr!(
             "at://{}/{}/{}",
             root_id.did,
             ROOT_NSID,
···
     after_rkey: Option<&str>,
 ) -> Result<Option<PdsEditState>, WeaverError> {
     // Build root URI
-    let root_uri = AtUri::new(&format!(
+    let root_uri = AtUri::new(&format_smolstr!(
         "at://{}/{}/{}",
         root_id.did,
         ROOT_NSID,
···
             }
         }
 
-        let diff_uri = AtUri::new(&format!("at://{}/{}/{}", diff_id.did, DIFF_NSID, rkey_str))
+        let diff_uri = AtUri::new(&format_smolstr!("at://{}/{}/{}", diff_id.did, DIFF_NSID, rkey_str))
             .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid diff URI: {}", e)))?
             .into_static();
 

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

···
 use std::collections::HashMap;
 use weaver_common::transport::PresenceSnapshot;
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use jacquard::smol_str::format_smolstr;
+
 /// Input messages to the editor worker.
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum WorkerInput {
···
                         if let Err(e) = new_doc.import(&snapshot) {
                             if let Err(send_err) = scope
                                 .send(WorkerOutput::Error {
-                                    message: format!("Failed to import snapshot: {e}"),
+                                    message: format_smolstr!("Failed to import snapshot: {e}").to_string(),
                                 })
                                 .await
                             {
···
                         Err(e) => {
                             if let Err(send_err) = scope
                                 .send(WorkerOutput::Error {
-                                    message: format!("Export failed: {e}"),
+                                    message: format_smolstr!("Export failed: {e}").to_string(),
                                 })
                                 .await
                             {
···
                         Err(e) => {
                             if let Err(send_err) = scope
                                 .send(WorkerOutput::Error {
-                                    message: format!("Failed to spawn CollabNode: {e}"),
+                                    message: format_smolstr!("Failed to spawn CollabNode: {e}").to_string(),
                                 })
                                 .await
                             {
···
                         Err(e) => {
                             if let Err(send_err) = scope
                                 .send(WorkerOutput::Error {
-                                    message: format!("Failed to join session: {e}"),
+                                    message: format_smolstr!("Failed to join session: {e}").to_string(),
                                 })
                                 .await
                             {
···
                             if let Err(e) = new_doc.import(&snapshot) {
                                 if let Err(send_err) = scope
                                     .send(WorkerOutput::Error {
-                                        message: format!("Failed to import snapshot: {e}"),
+                                        message: format_smolstr!("Failed to import snapshot: {e}").to_string(),
                                     })
                                     .await
                                 {
···
                         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!("Export failed: {e}") }).await {
+                                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}");
                                 }
                                 continue;
···
                         let at_uri = match AtUri::new_owned(uri_str.clone()) {
                             Ok(u) => u,
                             Err(e) => {
-                                errors.insert(uri_str, format!("Invalid AT URI: {e}"));
+                                errors.insert(uri_str, format_smolstr!("Invalid AT URI: {e}").to_string());
                                 continue;
                             }
                         };
···
                                     results.insert(uri_str, html);
                                 }
                                 Err(e) => {
-                                    errors.insert(uri_str, format!("{:?}", e));
+                                    errors.insert(uri_str, format_smolstr!("{:?}", e).to_string());
                                 }
                             }
                         }

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

···
     if cleaned.len() <= max_len {
         cleaned
     } else {
-        format!("{}...", &cleaned[..max_len - 3])
+        // Use char boundary-safe truncation to avoid panic on multibyte chars
+        let truncated: String = cleaned.chars().take(max_len - 3).collect();
+        format!("{}...", truncated)
     }
 }
 

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

···
                             if let Some(new_collection_str) = data.type_discriminator() {
                                 let new_collection = Nsid::new(new_collection_str).ok();
                                 if let Some(new_collection) = new_collection {
-                                    // Create new record
+                                    // Create new record first - if this fails, user keeps their old record
+                                    // If delete fails after, user has duplicates (recoverable) rather than data loss
                                     let create_req = CreateRecord::new()
                                         .repo(AtIdentifier::Did(did.clone()))
                                         .collection(new_collection)
···
                                     match fetcher.send(create_req).await {
                                         Ok(response) => {
                                             if let Ok(create_output) = response.into_output() {
-                                                // Delete old record
+                                                // Delete old record after successful create
                                                 if let (Some(old_collection_str), Some(old_rkey)) = (uri.collection(), uri.rkey()) {
                                                     let old_collection = Nsid::new(old_collection_str.as_str()).ok();
                                                     if let Some(old_collection) = old_collection {

crates/weaver-app/src/data.rs

···
 #[allow(unused_imports)]
 use jacquard::{
     prelude::IdentityResolver,
-    smol_str::SmolStr,
+    smol_str::{SmolStr, format_smolstr},
     types::{cid::Cid, string::AtIdentifier},
 };
 #[allow(unused_imports)]
···
 ) -> Result<()> {
     let cid = Cid::new_owned(cid.as_bytes())?;
     let cache_key = match (&notebook, &name) {
-        (Some(nb), Some(n)) => Some(SmolStr::new(format!("{}_{}", nb, n))),
+        (Some(nb), Some(n)) => Some(format_smolstr!("{}_{}", nb, n)),
         (None, Some(n)) => Some(n.clone()),
         _ => None,
     };

crates/weaver-app/src/fetch.rs

···
 use jacquard::types::string::Nsid;
 use jacquard::xrpc::XrpcResponse;
 use jacquard::xrpc::*;
-use jacquard::{smol_str::SmolStr, types::ident::AtIdentifier};
+use jacquard::{smol_str::{SmolStr, format_smolstr}, types::ident::AtIdentifier};
 use serde::{Deserialize, Serialize};
 use std::future::Future;
 use std::{sync::Arc, time::Duration};
···
 
         for ufos_record in records {
             // Construct URI
-            let uri_str = format!(
+            let uri_str = format_smolstr!(
                 "at://{}/{}/{}",
                 ufos_record.did, ufos_record.collection, ufos_record.rkey
             );
             let uri = AtUri::new_owned(uri_str)
-                .map_err(|e| dioxus::CapturedError::from_display(format!("Invalid URI: {}", e)))?;
+                .map_err(|e| dioxus::CapturedError::from_display(format_smolstr!("Invalid URI: {}", e).as_str()))?;
             match client.view_notebook(&uri).await {
                 Ok((notebook, entries)) => {
                     let ident = uri.authority().clone().into_static();
···
         // Try to find notebook context via constellation
         let entry_uri = entry_view.uri.clone();
         let at_uri = AtUri::new(entry_uri.as_ref()).map_err(|e| {
-            dioxus::CapturedError::from_display(format!("Invalid entry URI: {}", e))
+            dioxus::CapturedError::from_display(format_smolstr!("Invalid entry URI: {}", e).as_str())
         })?;
 
         let (total, first_notebook) = client
···
         let notebook_context = if total == 1 {
             if let Some(notebook_id) = first_notebook {
                 // Construct notebook URI from RecordId
-                let notebook_uri_str = format!(
+                let notebook_uri_str = format_smolstr!(
                     "at://{}/{}/{}",
                     notebook_id.did.as_str(),
                     notebook_id.collection.as_str(),
                     notebook_id.rkey.0.as_str()
                 );
                 let notebook_uri = AtUri::new_owned(notebook_uri_str).map_err(|e| {
-                    dioxus::CapturedError::from_display(format!("Invalid notebook URI: {}", e))
+                    dioxus::CapturedError::from_display(format_smolstr!("Invalid notebook URI: {}", e).as_str())
                 })?;
 
                 // Fetch notebook and find entry position
···
         // Check if entry is in multiple notebooks - if so, clear prev/next
         let entry_uri = book_entry_view.entry.uri.clone();
         let at_uri = AtUri::new(entry_uri.as_ref()).map_err(|e| {
-            dioxus::CapturedError::from_display(format!("Invalid entry URI: {}", e))
+            dioxus::CapturedError::from_display(format_smolstr!("Invalid entry URI: {}", e).as_str())
         })?;
 
         let (total, _) = client

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 std::sync::OnceLock;
 use std::time::Duration;
 
 /// Cache for generated OG images
 /// Key: "{ident}/{book}/{entry}/{cid}" - includes CID for invalidation
-static OG_CACHE: OnceLock<Cache<String, Vec<u8>>> = OnceLock::new();
+static OG_CACHE: OnceLock<Cache<SmolStr, Vec<u8>>> = OnceLock::new();
 
-fn get_cache() -> &'static Cache<String, Vec<u8>> {
+fn get_cache() -> &'static Cache<SmolStr, Vec<u8>> {
     OG_CACHE.get_or_init(|| {
         // Cache up to 1000 images for 1 hour
         new_cache(1000, Duration::from_secs(3600))
···
 }
 
 /// Generate cache key from entry identifiers
-pub fn cache_key(ident: &str, book: &str, entry: &str, cid: &str) -> String {
-    format!("{}/{}/{}/{}", ident, book, entry, cid)
+pub fn cache_key(ident: &str, book: &str, entry: &str, cid: &str) -> SmolStr {
+    format_smolstr!("{}/{}/{}/{}", ident, book, entry, cid)
 }
 
 /// Try to get a cached OG image
-pub fn get_cached(key: &str) -> Option<Vec<u8>> {
-    get_cache().get(&key.to_string())
+pub fn get_cached(key: &SmolStr) -> Option<Vec<u8>> {
+    get_cache().get(key)
 }
 
 /// Store an OG image in the cache
-pub fn cache_image(key: String, image: Vec<u8>) {
+pub fn cache_image(key: SmolStr, image: Vec<u8>) {
     get_cache().insert(key, image);
 }
 
···
 }
 
 /// Generate cache key for notebook OG images
-pub fn notebook_cache_key(ident: &str, book: &str, cid: &str) -> String {
-    format!("notebook/{}/{}/{}", ident, book, cid)
+pub fn notebook_cache_key(ident: &str, book: &str, cid: &str) -> SmolStr {
+    format_smolstr!("notebook/{}/{}/{}", ident, book, cid)
 }
 
 /// Generate cache key for profile OG images
-pub fn profile_cache_key(ident: &str, cid: &str) -> String {
-    format!("profile/{}/{}", ident, cid)
+pub fn profile_cache_key(ident: &str, cid: &str) -> SmolStr {
+    format_smolstr!("profile/{}/{}", ident, cid)
 }
 
 /// Generate a notebook index OG image

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

···
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
 use std::sync::Arc;
 
+#[cfg(all(feature = "fullstack-server", feature = "server"))]
+use jacquard::smol_str::ToSmolStr;
+
 // Route: /og/{ident}/{book_title}/{entry_title} - OpenGraph image for entry
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
 #[get("/og/{ident}/{book_title}/{entry_title}", fetcher: Extension<Arc<fetch::Fetcher>>)]
···
 
     // Use book_title from URL - it's the notebook slug/title
     // TODO: Could fetch actual notebook record to get display title
-    let notebook_title_str: String = book_title.to_string();
+    let notebook_title_str: &str = book_title.as_ref();
 
     let author_handle = book_entry
         .entry
         .authors
         .first()
         .map(|a| match &a.record.inner {
-            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
-            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
-            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_string(),
-            _ => "unknown".to_string(),
+            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref(),
+            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref(),
+            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref(),
+            _ => "unknown",
         })
-        .unwrap_or_else(|| "unknown".to_string());
+        .unwrap_or("unknown");
 
     // Check for hero image in embeds
     let hero_image_data = if let Some(ref embeds) = entry.embeds {
···
         .authors
         .first()
         .map(|a| match &a.record.inner {
-            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
-            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
-            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_string(),
-            _ => "unknown".to_string(),
+            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref(),
+            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref(),
+            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref(),
+            _ => "unknown",
         })
-        .unwrap_or_else(|| "unknown".to_string());
+        .unwrap_or("unknown");
 
     // Fetch entries to get entry titles and count
     let entries_result = fetcher
···
         ProfileDataViewInner::ProfileView(p) => (
             p.display_name
                 .as_ref()
-                .map(|n| n.as_ref().to_string())
+                .map(|n| n.as_ref())
                 .unwrap_or_default(),
-            p.handle.as_ref().to_string(),
+            p.handle.as_ref(),
             p.description
                 .as_ref()
-                .map(|d| d.as_ref().to_string())
+                .map(|d| d.as_ref())
                 .unwrap_or_default(),
-            p.avatar.as_ref().map(|u| u.as_ref().to_string()),
-            None::<String>,
-            p.did.as_ref().to_string(),
+            p.avatar.as_ref().map(|u| u.as_ref()),
+            None::<&str>,
+            p.did.as_ref(),
         ),
         ProfileDataViewInner::ProfileViewDetailed(p) => (
             p.display_name
                 .as_ref()
-                .map(|n| n.as_ref().to_string())
+                .map(|n| n.as_ref())
                 .unwrap_or_default(),
-            p.handle.as_ref().to_string(),
+            p.handle.as_ref(),
             p.description
                 .as_ref()
-                .map(|d| d.as_ref().to_string())
+                .map(|d| d.as_ref())
                 .unwrap_or_default(),
-            p.avatar.as_ref().map(|u| u.as_ref().to_string()),
-            p.banner.as_ref().map(|u| u.as_ref().to_string()),
-            p.did.as_ref().to_string(),
-        ),
-        ProfileDataViewInner::TangledProfileView(p) => (
-            String::new(),
-            p.handle.as_ref().to_string(),
-            String::new(),
-            None,
-            None,
-            p.did.as_ref().to_string(),
+            p.avatar.as_ref().map(|u| u.as_ref()),
+            p.banner.as_ref().map(|u| u.as_ref()),
+            p.did.as_ref(),
         ),
+        ProfileDataViewInner::TangledProfileView(p) => {
+            ("", p.handle.as_ref(), "", None, None, p.did.as_ref())
+        }
         _ => return Ok((StatusCode::NOT_FOUND, "Profile type not supported").into_response()),
     };
 
···
     let notebook_count = notebooks_result.map(|n| n.len()).unwrap_or(0);
 
     // Fetch avatar as base64 if available
-    let avatar_data = if let Some(ref url) = avatar_url {
+    let avatar_data = if let Some(url) = avatar_url {
         match reqwest::get(url).await {
             Ok(response) if response.status().is_success() => {
                 let content_type = response
···
                     .get("content-type")
                     .and_then(|v| v.to_str().ok())
                     .unwrap_or("image/jpeg")
-                    .to_string();
+                    .to_smolstr();
                 match response.bytes().await {
                     Ok(bytes) => {
                         use base64::Engine;
···
     };
 
     // Check for banner and generate appropriate template
-    let png_bytes = if let Some(ref banner_url) = banner_url {
+    let png_bytes = if let Some(banner_url) = banner_url {
         // Fetch banner image
         let banner_data = match reqwest::get(banner_url).await {
             Ok(response) if response.status().is_success() => {
···
                     .get("content-type")
                     .and_then(|v| v.to_str().ok())
                     .unwrap_or("image/jpeg")
-                    .to_string();
+                    .to_smolstr();
                 match response.bytes().await {
                     Ok(bytes) => {
                         use base64::Engine;

crates/weaver-app/src/record_utils.rs

···
 use dioxus::prelude::*;
 use jacquard::bytes::Bytes;
 use jacquard::common::{Data, IntoStatic};
+use jacquard::smol_str::{SmolStr, format_smolstr};
 use jacquard::types::LexiconStringType;
 use jacquard::types::string::AtprotoStr;
 use jacquard_lexicon::validation::{
···
     match string_type {
         LexiconStringType::Datetime => Datetime::from_str(text)
             .map(AtprotoStr::Datetime)
-            .map_err(|e| format!("Invalid datetime: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid datetime: {}", e).to_string()),
         LexiconStringType::Did => Did::new(text)
             .map(|v| AtprotoStr::Did(v.into_static()))
-            .map_err(|e| format!("Invalid DID: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid DID: {}", e).to_string()),
         LexiconStringType::Handle => Handle::new(text)
             .map(|v| AtprotoStr::Handle(v.into_static()))
-            .map_err(|e| format!("Invalid handle: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid handle: {}", e).to_string()),
         LexiconStringType::AtUri => AtUri::new(text)
             .map(|v| AtprotoStr::AtUri(v.into_static()))
-            .map_err(|e| format!("Invalid AT-URI: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid AT-URI: {}", e).to_string()),
         LexiconStringType::AtIdentifier => AtIdentifier::new(text)
             .map(|v| AtprotoStr::AtIdentifier(v.into_static()))
-            .map_err(|e| format!("Invalid identifier: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid identifier: {}", e).to_string()),
         LexiconStringType::Nsid => Nsid::new(text)
             .map(|v| AtprotoStr::Nsid(v.into_static()))
-            .map_err(|e| format!("Invalid NSID: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid NSID: {}", e).to_string()),
         LexiconStringType::Tid => Tid::new(text)
             .map(|v| AtprotoStr::Tid(v.into_static()))
-            .map_err(|e| format!("Invalid TID: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid TID: {}", e).to_string()),
         LexiconStringType::RecordKey => Rkey::new(text)
             .map(|rk| AtprotoStr::RecordKey(RecordKey::from(rk)))
-            .map_err(|e| format!("Invalid record key: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid record key: {}", e).to_string()),
         LexiconStringType::Cid => Cid::new(text.as_bytes())
             .map(|v| AtprotoStr::Cid(v.into_static()))
-            .map_err(|_| "Invalid CID".to_string()),
+            .map_err(|_| SmolStr::new_inline("Invalid CID").to_string()),
         LexiconStringType::Language => Language::new(text)
             .map(AtprotoStr::Language)
-            .map_err(|e| format!("Invalid language: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid language: {}", e).to_string()),
         LexiconStringType::Uri(_) => Uri::new(text)
             .map(|u| AtprotoStr::Uri(u.into_static()))
-            .map_err(|e| format!("Invalid URI: {}", e)),
+            .map_err(|e| format_smolstr!("Invalid URI: {}", e).to_string()),
         LexiconStringType::String => {
             // Plain strings: use smart inference
             use jacquard::types::value::parsing;

crates/weaver-app/src/service_worker.rs

···
 use wasm_bindgen_futures::JsFuture;
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use web_sys::{RegistrationOptions, ServiceWorkerContainer, Window};
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use jacquard::smol_str::format_smolstr;
 
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 pub async fn register_service_worker() -> Result<(), JsValue> {
···
             let cid = image.image.blob().cid();
 
             if let Some(name) = &image.name {
-                let blob_url = format!(
+                let blob_url = format_smolstr!(
                     "{}xrpc/com.atproto.sync.getBlob?did={}&cid={}",
                     pds_url.as_str(),
                     did.as_ref(),
···
             let cid = image.image.blob().cid();
 
             if let Some(name) = &image.name {
-                let blob_url = format!(
+                let blob_url = format_smolstr!(
                     "{}xrpc/com.atproto.sync.getBlob?did={}&cid={}",
                     pds_url.as_str(),
                     did.as_ref(),
···
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 fn send_blob_mappings(
     notebook: &str,
-    mappings: std::collections::HashMap<String, String>,
+    mappings: std::collections::HashMap<String, jacquard::smol_str::SmolStr>,
 ) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("no window"))?;
     let navigator = window.navigator();
···
     // Convert HashMap to JS Object
     let blobs_obj = js_sys::Object::new();
     for (name, url) in mappings {
-        js_sys::Reflect::set(&blobs_obj, &name.into(), &url.into())?;
+        js_sys::Reflect::set(&blobs_obj, &name.into(), &url.as_str().into())?;
     }
     js_sys::Reflect::set(&msg, &"blobs".into(), &blobs_obj)?;
 
···
 fn send_blob_rkey_mappings(
     rkey: &str,
     ident: &str,
-    mappings: std::collections::HashMap<String, String>,
+    mappings: std::collections::HashMap<String, jacquard::smol_str::SmolStr>,
 ) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("no window"))?;
     let navigator = window.navigator();
···
     // Convert HashMap to JS Object
     let blobs_obj = js_sys::Object::new();
     for (name, url) in mappings {
-        js_sys::Reflect::set(&blobs_obj, &name.into(), &url.into())?;
+        js_sys::Reflect::set(&blobs_obj, &name.into(), &url.as_str().into())?;
     }
     js_sys::Reflect::set(&msg, &"blobs".into(), &blobs_obj)?;
 
···
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub fn send_blob_mappings(
     _notebook: &str,
-    _mappings: std::collections::HashMap<String, String>,
+    _mappings: std::collections::HashMap<String, jacquard::smol_str::SmolStr>,
 ) -> Result<(), String> {
     Ok(())
 }

crates/weaver-app/src/views/drafts.rs

···
 use crate::components::editor::{delete_draft, list_drafts};
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
-use jacquard::smol_str::SmolStr;
+use jacquard::smol_str::{SmolStr, format_smolstr};
 use jacquard::types::ident::AtIdentifier;
 use std::collections::HashSet;
 
···
                 div { class: "drafts-list",
                     for draft in merged_drafts() {
                         {
-                            let key_for_delete = format!("new:{}", draft.rkey);
+                            let key_for_delete = format_smolstr!("new:{}", draft.rkey).to_string();
                             let is_edit_draft = draft.editing_uri.is_some();
                             let display_title = if draft.title.is_empty() {
                                 "Untitled".to_string()
···
 
     // Construct AT-URI for the entry
     let entry_uri =
-        use_memo(move || format!("at://{}/sh.weaver.notebook.entry/{}", ident(), rkey()));
+        use_memo(move || format_smolstr!("at://{}/sh.weaver.notebook.entry/{}", ident(), rkey()).to_string());
 
     rsx! {
         EditorCss {}
···
 
     // Construct AT-URI for the entry
     let entry_uri =
-        use_memo(move || format!("at://{}/sh.weaver.notebook.entry/{}", ident(), rkey()));
+        use_memo(move || format_smolstr!("at://{}/sh.weaver.notebook.entry/{}", ident(), rkey()).to_string());
 
     // Fetch notebook entries for wikilink validation
     let (_entries_resource, entries_memo) = use_notebook_entries(ident, book_title);
···
                 let path = book_entry.entry.path.as_ref().map(|p| p.as_str()).unwrap_or("");
                 if !title.is_empty() || !path.is_empty() {
                     // Build canonical URL: /{ident}/{book}/{path}
-                    let canonical_url = format!("/{}/{}/{}", ident_str, book, path);
+                    let canonical_url = format_smolstr!("/{}/{}/{}", ident_str, book, path).to_string();
                     index.add_entry(title, path, canonical_url);
                 }
             }

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

···
 #![allow(non_snake_case)]
 
 use dioxus::prelude::*;
-use jacquard::smol_str::{SmolStr, ToSmolStr};
+use jacquard::smol_str::{SmolStr, ToSmolStr, format_smolstr};
 use jacquard::types::string::AtIdentifier;
 
 use crate::components::NotebookCss;
···
                 .authors
                 .first()
                 .map(|a| match &a.record.inner {
-                    ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
-                    ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
-                    ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_string(),
-                    _ => "unknown".to_string(),
+                    ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_smolstr(),
+                    ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_smolstr(),
+                    ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_smolstr(),
+                    _ => "unknown".into(),
                 })
-                .unwrap_or_else(|| "unknown".to_string());
+                .unwrap_or_else(|| "unknown".into());
 
             let base = if crate::env::WEAVER_APP_ENV == "dev" {
-                format!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
+                format_smolstr!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
             } else {
-                crate::env::WEAVER_APP_HOST.to_string()
+                SmolStr::new_static(crate::env::WEAVER_APP_HOST)
             };
-            let canonical_url = format!("{}/{}/e/{}", base, ident(), rkey());
+            let canonical_url = format_smolstr!("{}/{}/e/{}", base, ident(), rkey());
             let description = extract_preview(&entry_record.content, 160);
 
             let entry_signal = use_signal(|| data.entry.clone());
···
                         title: title.to_string(),
                         description: description.clone(),
                         image_url: String::new(),
-                        canonical_url: canonical_url.clone(),
-                        author_handle: author_handle.clone(),
+                        canonical_url: canonical_url.to_string(),
+                        author_handle: author_handle.to_string(),
                         book_title: Some(book_title.to_string()),
                     }
                     document::Link { rel: "stylesheet", href: ENTRY_CSS }
···
                         title: title.to_string(),
                         description: description.clone(),
                         image_url: String::new(),
-                        canonical_url: canonical_url.clone(),
-                        author_handle: author_handle.clone(),
+                        canonical_url: canonical_url.to_string(),
+                        author_handle: author_handle.to_string(),
                     }
                     document::Link { rel: "stylesheet", href: ENTRY_CSS }
                     DefaultNotebookCss {}
···
             let entry_path = entry_view
                 .path
                 .as_ref()
-                .map(|p| p.as_ref().to_string())
-                .unwrap_or_else(|| title.to_string());
+                .map(|p| p.as_ref().to_smolstr())
+                .unwrap_or_else(|| title.into());
 
             tracing::info!("Entry: {entry_path} - {title}");
 
···
                 .authors
                 .first()
                 .map(|a| match &a.record.inner {
-                    ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
-                    ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
-                    ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_string(),
-                    _ => "unknown".to_string(),
+                    ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_smolstr(),
+                    ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_smolstr(),
+                    ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_smolstr(),
+                    _ => "unknown".into(),
                 })
-                .unwrap_or_else(|| "unknown".to_string());
+                .unwrap_or_else(|| "unknown".into());
 
             let base = if crate::env::WEAVER_APP_ENV == "dev" {
-                format!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
+                format_smolstr!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
             } else {
-                crate::env::WEAVER_APP_HOST.to_string()
+                SmolStr::new_static(crate::env::WEAVER_APP_HOST)
             };
-            let canonical_url = format!("{}/{}/{}/e/{}", base, ident(), book_title(), rkey());
-            let og_image_url = format!(
+            let canonical_url = format_smolstr!("{}/{}/{}/e/{}", base, ident(), book_title(), rkey());
+            let og_image_url = format_smolstr!(
                 "{}/og/{}/{}/{}.png",
                 base,
                 ident(),
···
                 EntryOgMeta {
                     title: title.to_string(),
                     description: description,
-                    image_url: og_image_url,
-                    canonical_url: canonical_url,
-                    author_handle: author_handle,
+                    image_url: og_image_url.to_string(),
+                    canonical_url: canonical_url.to_string(),
+                    author_handle: author_handle.to_string(),
                     book_title: Some(book_title().to_string()),
                 }
                 document::Link { rel: "stylesheet", href: ENTRY_CSS }

crates/weaver-app/src/views/home.rs

···
     data,
 };
 use dioxus::prelude::*;
-use jacquard::smol_str::SmolStr;
+use jacquard::smol_str::{SmolStr, format_smolstr};
 use jacquard::types::ident::AtIdentifier;
 use jacquard::types::string::Did;
 
···
 #[component]
 pub fn SiteOgMeta() -> Element {
     let base = if crate::env::WEAVER_APP_ENV == "dev" {
-        format!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
+        format_smolstr!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
     } else {
-        crate::env::WEAVER_APP_HOST.to_string()
+        SmolStr::new_static(crate::env::WEAVER_APP_HOST)
     };
 
     let title = "Weaver";
     let description = "Share your words, your way.";
-    let image_url = format!("{}/og/site.png", base);
+    let image_url = format_smolstr!("{}/og/site.png", base);
     let canonical_url = base;
 
     rsx! {

crates/weaver-app/src/views/notebook.rs

···
 };
 use dioxus::prelude::*;
 use jacquard::{
-    smol_str::{SmolStr, ToSmolStr},
+    smol_str::{SmolStr, ToSmolStr, format_smolstr},
     types::ident::AtIdentifier,
 };
 
···
                     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
                     notebook_view.authors.first()
                         .map(|a| match &a.record.inner {
-                            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_string(),
-                            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_string(),
-                            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_string(),
-                            _ => "unknown".to_string(),
+                            ProfileDataViewInner::ProfileView(p) => p.handle.as_ref().to_smolstr(),
+                            ProfileDataViewInner::ProfileViewDetailed(p) => p.handle.as_ref().to_smolstr(),
+                            ProfileDataViewInner::TangledProfileView(p) => p.handle.as_ref().to_smolstr(),
+                            _ => "unknown".into(),
                         })
-                        .unwrap_or_else(|| "unknown".to_string())
+                        .unwrap_or_else(|| "unknown".into())
                 };
 
                 // NotebookView doesn't expose description directly, use empty for now
                 let og_description = String::new();
 
                 let base = if crate::env::WEAVER_APP_ENV == "dev" {
-                    format!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
+                    format_smolstr!("http://127.0.0.1:{}", crate::env::WEAVER_PORT)
                 } else {
-                    crate::env::WEAVER_APP_HOST.to_string()
+                    SmolStr::new_static(crate::env::WEAVER_APP_HOST)
                 };
-                let og_image_url = format!("{}/og/notebook/{}/{}.png", base, ident(), book_title());
-                let canonical_url = format!("{}/{}/{}", base, ident(), book_title());
+                let og_image_url = format_smolstr!("{}/og/notebook/{}/{}.png", base, ident(), book_title());
+                let canonical_url = format_smolstr!("{}/{}/{}", base, ident(), book_title());
 
                 rsx! {
                     NotebookOgMeta {
                         title: og_title,
                         description: og_description,
-                        image_url: og_image_url,
-                        canonical_url,
-                        author_handle: og_author,
+                        image_url: og_image_url.to_string(),
+                        canonical_url: canonical_url.to_string(),
+                        author_handle: og_author.to_string(),
                         entry_count: entries.len(),
                     }
                     div { class: "notebook-layout",