cli publish workflow and basic minimal renderer/server works end-to-end.

Cargo.lock

···
 ]
 
 [[package]]
-name = "async-lock"
-version = "3.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
-dependencies = [
- "event-listener",
- "event-listener-strategy",
- "pin-project-lite",
-]
-
-[[package]]
 name = "async-recursion"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "borrow-or-share"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fa326467c5d528c03e479661320269e7716d6b7d5d49bafd30890ce0c725696"
+checksum = "dc0b364ead1874514c8c2855ab558056ebfeb775653e7ae45ff72f28f8f3166c"
 
 [[package]]
 name = "borsh"
···
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
-name = "bytecount"
-version = "0.6.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
-
-[[package]]
 name = "byteorder"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "camino"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "276a59bf2b2c967788139340c9f0c5b12d7fd6630315c15c217e559de85d2609"
-dependencies = [
- "serde_core",
-]
-
-[[package]]
-name = "cargo-platform"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "cargo_metadata"
-version = "0.14.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4acbb09d9ee8e23699b9634375c72795d095bf268439da88562cf9b501f181fa"
-dependencies = [
- "camino",
- "cargo-platform",
- "semver",
- "serde",
- "serde_json",
-]
-
-[[package]]
 name = "cbor4ii"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "libc",
  "once_cell",
  "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "dashmap"
-version = "5.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
-dependencies = [
- "cfg-if",
- "hashbrown 0.14.5",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
-[[package]]
-name = "dashmap"
 version = "6.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
···
  "global-hotkey",
  "infer",
  "jni",
- "lazy-js-bundle 0.7.0",
+ "lazy-js-bundle",
  "libc",
  "muda",
  "ndk",
···
  "futures-channel",
  "futures-util",
  "generational-box",
- "lazy-js-bundle 0.7.0",
+ "lazy-js-bundle",
  "serde",
  "serde_json",
  "tracing",
···
  "futures-util",
  "generational-box",
  "keyboard-types",
- "lazy-js-bundle 0.7.0",
+ "lazy-js-bundle",
  "rustversion",
  "serde",
  "serde_json",
···
  "dioxus-core-types",
  "dioxus-html",
  "js-sys",
- "lazy-js-bundle 0.7.0",
+ "lazy-js-bundle",
  "rustc-hash 2.1.1",
  "serde",
  "sledgehammer_bindgen",
···
 ]
 
 [[package]]
-name = "dioxus-primitives"
-version = "0.0.1"
-source = "git+https://github.com/DioxusLabs/components#8e25631c7d4234ee070509156ed2abebb7b1d6e9"
-dependencies = [
- "dioxus",
- "dioxus-time",
- "lazy-js-bundle 0.6.2",
- "num-integer",
- "time",
- "tracing",
-]
-
-[[package]]
 name = "dioxus-router"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "bytes",
  "chrono",
  "ciborium",
- "dashmap 6.1.0",
+ "dashmap",
  "dioxus-cli-config",
  "dioxus-core",
  "dioxus-core-macro",
···
 ]
 
 [[package]]
-name = "dioxus-time"
-version = "0.7.0"
-source = "git+https://github.com/ealmloff/dioxus-std?branch=0.7#e5a74354cd36be440febdd6b701f584bd552bd62"
-dependencies = [
- "dioxus",
- "futures",
- "gloo-timers",
- "tokio",
-]
-
-[[package]]
 name = "dioxus-web"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "generational-box",
  "gloo-timers",
  "js-sys",
- "lazy-js-bundle 0.7.0",
+ "lazy-js-bundle",
  "rustc-hash 2.1.1",
  "send_wrapper",
  "serde",
···
 dependencies = [
  "libc",
  "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "error-chain"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d2f06b9cac1506ece98fe3231e3cc9c4410ec3d5b1f24ae1c8946f0742cdefc"
-dependencies = [
- "version_check",
 ]
 
 [[package]]
···
  "libc",
  "system-deps",
 ]
-
-[[package]]
-name = "glob"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "global-hotkey"
···
 [[package]]
 name = "jacquard"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
···
 [[package]]
 name = "jacquard-api"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-axum"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "axum",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "bon",
  "bytes",
···
  "jacquard-common",
  "jacquard-lexicon",
  "miette 7.6.0",
- "moka",
+ "mini-moka",
  "n0-future",
  "percent-encoding",
  "reqwest",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "cid",
- "dashmap 6.1.0",
+ "dashmap",
  "heck 0.5.0",
  "inventory",
  "jacquard-common",
···
 [[package]]
 name = "jacquard-oauth"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#71aae4e8c9a174927d3404fdcf9031547ca89691"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "chrono",
- "dashmap 6.1.0",
+ "dashmap",
  "elliptic-curve",
  "http",
  "jacquard-common",
···
  "static-regular-grammar",
  "thiserror 1.0.69",
 ]
-
-[[package]]
-name = "lazy-js-bundle"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e49596223b9d9d4947a14a25c142a6e7d8ab3f27eb3ade269d238bb8b5c267e2"
 
 [[package]]
 name = "lazy-js-bundle"
···
 
 [[package]]
 name = "mini-moka"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c325dfab65f261f386debee8b0969da215b3fa0037e74c8a1234db7ba986d803"
+version = "0.11.0"
+source = "git+https://github.com/moka-rs/mini-moka?rev=da864e849f5d034f32e02197fee9bb5d5af36d3d#da864e849f5d034f32e02197fee9bb5d5af36d3d"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
- "dashmap 5.5.3",
- "skeptic",
+ "dashmap",
  "smallvec",
  "tagptr",
  "triomphe",
+ "web-time",
 ]
 
 [[package]]
···
  "libc",
  "wasi 0.11.1+wasi-snapshot-preview1",
  "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "moka"
-version = "0.12.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8261cd88c312e0004c1d51baad2980c66528dfdb2bee62003e643a4d8f86b077"
-dependencies = [
- "async-lock",
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "equivalent",
- "event-listener",
- "futures-util",
- "parking_lot",
- "portable-atomic",
- "rustc_version",
- "smallvec",
- "tagptr",
- "uuid",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "num-bigint-dig"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151"
+checksum = "82c79c15c05d4bf82b6f5ef163104cc81a760d8e874d38ac50ab67c8877b647b"
 dependencies = [
- "byteorder",
  "lazy_static",
  "libm",
  "num-integer",
···
 checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3"
 
 [[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
-
-[[package]]
 name = "postgres-protocol"
 version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "pulldown-cmark"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"
-dependencies = [
- "bitflags 2.10.0",
- "memchr",
- "unicase",
-]
-
-[[package]]
 name = "quick-error"
 version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "schemars"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
+checksum = "1317c3bf3e7df961da95b0a56a172a02abead31276215a0497241a7624b487ce"
 dependencies = [
  "dyn-clone",
  "ref-cast",
···
 version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
-dependencies = [
- "serde",
- "serde_core",
-]
 
 [[package]]
 name = "send_wrapper"
···
  "indexmap 1.9.3",
  "indexmap 2.12.0",
  "schemars 0.9.0",
- "schemars 1.0.4",
+ "schemars 1.0.5",
  "serde_core",
  "serde_json",
  "serde_with_macros",
···
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
-name = "skeptic"
-version = "0.13.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16d23b015676c90a0f01c197bfdc786c20342c73a0afdda9025adb0bc42940a8"
-dependencies = [
- "bytecount",
- "cargo_metadata",
- "error-chain",
- "glob",
- "pulldown-cmark",
- "tempfile",
- "walkdir",
-]
-
-[[package]]
 name = "slab"
 version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "deranged",
  "itoa",
+ "js-sys",
  "libc",
  "num-conv",
  "num_threads",
···
 
 [[package]]
 name = "tokio-util"
-version = "0.7.16"
+version = "0.7.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
+checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
 dependencies = [
  "bytes",
  "futures-core",
···
  "axum",
  "chrono",
  "clap",
- "dashmap 6.1.0",
+ "dashmap",
  "diesel",
  "diesel-async",
  "diesel_migrations",
···
 dependencies = [
  "bitflags 2.10.0",
  "compact_string",
- "dashmap 6.1.0",
+ "dashmap",
  "dynosaur",
  "http",
  "ignore",
···
 version = "0.1.0"
 dependencies = [
  "axum",
- "dashmap 6.1.0",
+ "chrono",
+ "console_error_panic_hook",
+ "dashmap",
  "dioxus",
- "dioxus-primitives",
  "jacquard",
  "jacquard-axum",
  "markdown-weaver",
  "mini-moka",
- "moka",
+ "time",
  "weaver-api",
  "weaver-common",
  "weaver-renderer",
···
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8"
+checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e"
 dependencies = [
  "rustls-pki-types",
 ]

Cargo.toml

···
 lexicon_cid = { package = "cid", version = "0.10.1", features = [
   "serde-codec",
 ] }
+
 markdown-weaver = { git = "https://github.com/rsform/markdown-weaver" }
 markdown-weaver-escape = { git = "https://github.com/rsform/markdown-weaver" }
 

crates/weaver-cli/src/main.rs

···
+use jacquard::IntoStatic;
 use jacquard::client::{Agent, FileAuthStore};
 use jacquard::identity::JacquardResolver;
 use jacquard::oauth::client::{OAuthClient, OAuthSession};
 use jacquard::oauth::loopback::LoopbackConfig;
 use jacquard::prelude::*;
 use jacquard::types::string::Handle;
-use jacquard::IntoStatic;
 use miette::{IntoDiagnostic, Result};
 use std::io::BufRead;
 use std::path::PathBuf;
 use std::sync::Arc;
-use weaver_renderer::static_site::StaticSiteWriter;
-use weaver_renderer::walker::{WalkOptions, vault_contents};
 use weaver_renderer::atproto::AtProtoPreprocessContext;
+use weaver_renderer::static_site::StaticSiteWriter;
 use weaver_renderer::utils::VaultBrokenLinkCallback;
+use weaver_renderer::walker::{WalkOptions, vault_contents};
 
 use clap::{Parser, Subcommand};
 
···
         source: PathBuf,
 
         /// Notebook title
-        #[arg(long)]
+        //#[arg(long)]
         title: String,
 
         /// Path to auth store file
···
             let store_path = store.unwrap_or_else(default_auth_store_path);
             authenticate(handle, store_path).await?;
         }
-        Some(Commands::Publish { source, title, store }) => {
+        Some(Commands::Publish {
+            source,
+            title,
+            store,
+        }) => {
             let store_path = store.unwrap_or_else(default_auth_store_path);
             publish_notebook(source, title, store_path).await?;
         }
···
             authenticate(handle, store_path.clone()).await?;
 
             // Load the session we just created
-            try_load_session(&store_path).await
+            try_load_session(&store_path)
+                .await
                 .ok_or_else(|| miette::miette!("Failed to load session after authentication"))?
         }
     };
···
 
     // Create agent and resolve DID document to get handle
     let agent = Agent::new(session);
-    let (did, _session_id) = agent.info().await
+    let (did, _session_id) = agent
+        .info()
+        .await
         .ok_or_else(|| miette::miette!("No session info available"))?;
     let did_doc_response = agent.resolve_did_doc(&did).await?;
     let did_doc = did_doc_response.parse()?;
···
     println!("Found {} markdown files", md_files.len());
 
     // Create preprocessing context
-    let context = AtProtoPreprocessContext::new(
-        vault_arc.clone(),
-        title.clone(),
-        agent.clone(),
-    ).with_creator(did.clone().into_static(), handle.clone().into_static());
+    let context = AtProtoPreprocessContext::new(vault_arc.clone(), title.clone(), agent.clone())
+        .with_creator(did.clone().into_static(), handle.clone().into_static());
 
     // Process each file
     for file_path in &md_files {
···
         });
 
         // Parse markdown
-        use weaver_renderer::default_md_options;
         use markdown_weaver::Parser;
-        let parser = Parser::new_with_broken_link_callback(&contents, default_md_options(), callback);
+        use weaver_renderer::default_md_options;
+        let parser =
+            Parser::new_with_broken_link_callback(&contents, default_md_options(), callback);
         let iterator = weaver_renderer::ContextIterator::default(parser);
 
         // Process through NotebookProcessor
-        use weaver_renderer::{NotebookProcessor, NotebookContext};
         use n0_future::StreamExt;
+        use weaver_renderer::{NotebookContext, NotebookProcessor};
         let mut processor = NotebookProcessor::new(file_context.clone(), iterator);
 
         // Write canonical markdown with MarkdownWriter
···
 
         // Process all events
         while let Some(event) = processor.next().await {
-            md_writer.write_event(event).map_err(|e| {
-                miette::miette!("Failed to write markdown: {:?}", e)
-            })?;
+            md_writer
+                .write_event(event)
+                .map_err(|e| miette::miette!("Failed to write markdown: {:?}", e))?;
         }
 
         // Extract blobs and entry metadata
···
         let entry_title = file_context.entry_title();
 
         // Build Entry record with blobs
-        use weaver_api::sh_weaver::notebook::entry::{Entry, EntryEmbeds};
-        use weaver_api::sh_weaver::embed::images::{Images, Image};
-        use jacquard::types::string::Datetime;
         use jacquard::types::blob::BlobRef;
+        use jacquard::types::string::Datetime;
+        use weaver_api::sh_weaver::embed::images::{Image, Images};
+        use weaver_api::sh_weaver::notebook::entry::{Entry, EntryEmbeds};
 
         let embeds = if !blobs.is_empty() {
             // Build images from blobs

crates/weaver-renderer/src/atproto.rs

···
 //! Two-stage pipeline: markdown→markdown preprocessing (CLI),
 //! then client-side markdown→HTML rendering (WASM).
 
+mod client;
+mod embed_renderer;
 mod error;
-mod types;
 mod markdown_writer;
+#[cfg(not(target_family = "wasm"))]
 mod preprocess;
-mod client;
-mod embed_renderer;
+mod types;
 mod writer;
 
+pub use client::{ClientContext, DefaultEmbedResolver, EmbedResolver};
+pub use embed_renderer::{
+    fetch_and_render_generic, fetch_and_render_post, fetch_and_render_profile,
+};
 pub use error::{AtProtoPreprocessError, ClientRenderError};
-pub use types::{BlobName, BlobInfo};
+pub use markdown_writer::MarkdownWriter;
+#[cfg(not(target_family = "wasm"))]
 pub use preprocess::AtProtoPreprocessContext;
-pub use client::{ClientContext, EmbedResolver, DefaultEmbedResolver};
-pub use markdown_writer::MarkdownWriter;
-pub use embed_renderer::{fetch_and_render_profile, fetch_and_render_post, fetch_and_render_generic};
+pub use types::{BlobInfo, BlobName};
 pub use writer::{ClientWriter, EmbedContentProvider};

crates/weaver-renderer/src/atproto/client.rs

···
+use super::{error::ClientRenderError, types::BlobName};
 use crate::{Frontmatter, NotebookContext};
-use super::{types::BlobName, error::ClientRenderError};
 use jacquard::{
     client::{Agent, AgentSession},
     prelude::IdentityResolver,
     types::string::{AtUri, Cid, Did},
 };
-use markdown_weaver::{Tag, CowStr as MdCowStr, WeaverAttributes};
+use markdown_weaver::{CowStr as MdCowStr, Tag, WeaverAttributes};
 use std::collections::HashMap;
 use std::sync::Arc;
 use weaver_api::sh_weaver::notebook::entry::Entry;
···
 /// Trait for resolving embed content on the client side
 ///
 /// Implementations can fetch from cache, make HTTP requests, or use other sources.
-pub trait EmbedResolver: Send + Sync {
+pub trait EmbedResolver {
     /// Resolve a profile embed by AT URI
     fn resolve_profile(
         &self,
         uri: &AtUri<'_>,
-    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>> + Send;
+    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>>;
 
     /// Resolve a post/record embed by AT URI
     fn resolve_post(
         &self,
         uri: &AtUri<'_>,
-    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>> + Send;
+    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>>;
 
     /// Resolve a markdown embed from URL
     ///
···
         &self,
         url: &str,
         depth: usize,
-    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>> + Send;
+    ) -> impl std::future::Future<Output = Result<String, ClientRenderError>>;
 }
 
 /// Default embed resolver that fetches records from PDSs
···
     }
 
     async fn resolve_post(&self, uri: &AtUri<'_>) -> Result<String, ClientRenderError> {
-        use crate::atproto::{fetch_and_render_post, fetch_and_render_generic};
+        use crate::atproto::{fetch_and_render_generic, fetch_and_render_post};
 
         // Check if it's a known type
         if let Some(collection) = uri.collection() {
             match collection.as_ref() {
                 "app.bsky.feed.post" => {
-                    fetch_and_render_post(uri, &*self.agent)
-                        .await
-                        .map_err(|e| ClientRenderError::EntryFetch {
+                    fetch_and_render_post(uri, &*self.agent).await.map_err(|e| {
+                        ClientRenderError::EntryFetch {
                             uri: uri.as_ref().to_string(),
                             source: Box::new(e),
-                        })
-                }
-                _ => {
-                    fetch_and_render_generic(uri, &*self.agent)
-                        .await
-                        .map_err(|e| ClientRenderError::EntryFetch {
-                            uri: uri.as_ref().to_string(),
-                            source: Box::new(e),
-                        })
+                        }
+                    })
                 }
+                _ => fetch_and_render_generic(uri, &*self.agent)
+                    .await
+                    .map_err(|e| ClientRenderError::EntryFetch {
+                        uri: uri.as_ref().to_string(),
+                        source: Box::new(e),
+                    }),
             }
         } else {
             Err(ClientRenderError::EntryFetch {
···
     }
 
     /// Add an embed resolver for fetching embed content
-    pub fn with_embed_resolver<R: EmbedResolver>(
-        self,
-        resolver: Arc<R>,
-    ) -> ClientContext<'a, R> {
+    pub fn with_embed_resolver<R: EmbedResolver>(self, resolver: Arc<R>) -> ClientContext<'a, R> {
         ClientContext {
             entry: self.entry,
             creator_did: self.creator_did,
···
             }
             // Weaver records and unknown collections go to weaver.sh
             _ => {
-                format!("https://weaver.sh/{}/{}/{}", authority, collection_str, rkey_str)
+                format!(
+                    "https://weaver.sh/{}/{}/{}",
+                    authority, collection_str, rkey_str
+                )
             }
         }
     } else {
···
 
     async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s> {
         match &link {
-            Tag::Link { link_type, dest_url, title, id } => {
+            Tag::Link {
+                link_type,
+                dest_url,
+                title,
+                id,
+            } => {
                 let url = dest_url.as_ref();
 
                 // Try to parse as AT URI
···
 #[cfg(test)]
 mod tests {
     use super::*;
+    use jacquard::types::string::{Datetime, Did};
     use weaver_api::sh_weaver::notebook::entry::Entry;
-    use jacquard::types::string::{Did, Datetime};
 
     #[test]
     fn test_client_context_creation() {
···
     #[test]
     fn test_at_uri_to_web_url_profile() {
         let uri = AtUri::new("at://did:plc:xyz123").unwrap();
-        assert_eq!(
-            at_uri_to_web_url(&uri),
-            "https://weaver.sh/did:plc:xyz123"
-        );
+        assert_eq!(at_uri_to_web_url(&uri), "https://weaver.sh/did:plc:xyz123");
     }
 
     #[test]

crates/weaver-renderer/src/atproto/preprocess.rs

···
+use super::types::{BlobInfo, BlobName};
 use crate::{Frontmatter, NotebookContext};
-use super::types::{BlobName, BlobInfo};
 use dashmap::DashMap;
 use jacquard::{
     client::{Agent, AgentSession, AgentSessionExt},
     prelude::IdentityResolver,
     types::string::{CowStr, Did, Handle},
 };
-use markdown_weaver::{Tag, CowStr as MdCowStr, WeaverAttributes};
-use std::{
-    path::PathBuf,
-    sync::Arc,
-};
+use markdown_weaver::{CowStr as MdCowStr, Tag, WeaverAttributes};
+use std::{path::PathBuf, sync::Arc};
+use yaml_rust2::Yaml;
 
 pub struct AtProtoPreprocessContext<A: AgentSession + IdentityResolver> {
     // Vault information
···
 // Stub NotebookContext implementation
 impl<A: AgentSession + IdentityResolver> NotebookContext for AtProtoPreprocessContext<A> {
     fn set_entry_title(&self, title: MdCowStr<'_>) {
-        self.titles.insert(self.current_path.clone(), title.into_static());
+        let path = self.current_path.clone();
+        self.titles
+            .insert(path.clone(), title.clone().into_static());
+        self.frontmatter.get_mut(&path).map(|frontmatter| {
+            if let Ok(mut yaml) = frontmatter.yaml.write() {
+                if yaml.get(0).is_some_and(|y| y.is_hash()) {
+                    let map = yaml.get_mut(0).unwrap().as_mut_hash().unwrap();
+                    map.insert(
+                        Yaml::String("title".into()),
+                        Yaml::String(title.into_static().into()),
+                    );
+                }
+            }
+        });
     }
 
     fn entry_title(&self) -> MdCowStr<'_> {
         self.titles
             .get(&self.current_path)
             .map(|t| t.value().clone())
-            .unwrap_or(MdCowStr::Borrowed(""))
+            .unwrap_or_else(|| {
+                // Fall back to file stem if no explicit title set
+                let title = self
+                    .current_path
+                    .file_stem()
+                    .and_then(|s| s.to_str())
+                    .map(|s| MdCowStr::Borrowed(s))
+                    .unwrap_or(MdCowStr::Borrowed("Untitled"));
+
+                // Cache the derived title
+                self.titles
+                    .insert(self.current_path.clone(), title.clone().into_static());
+                title
+            })
     }
 
     fn frontmatter(&self) -> Frontmatter {
···
     }
 
     fn set_frontmatter(&self, frontmatter: Frontmatter) {
-        self.frontmatter.insert(self.current_path.clone(), frontmatter);
+        self.frontmatter
+            .insert(self.current_path.clone(), frontmatter);
     }
 
     async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s> {
···
                 match resolved {
                     LinkUri::Path(path) => {
                         // Local wikilink - look up in vault
-                        if let Some(file_path) = lookup_filename_in_vault(path.as_ref(), &self.vault_contents) {
+                        if let Some(file_path) =
+                            lookup_filename_in_vault(path.as_ref(), &self.vault_contents)
+                        {
                             let entry_title = file_path
                                 .file_stem()
                                 .and_then(|s| s.to_str())
···
                                     normalized_title
                                 )
                             } else {
-                                format!(
-                                    "/{}/{}",
-                                    self.notebook_title.as_ref(),
-                                    normalized_title
-                                )
+                                format!("/{}/{}", self.notebook_title.as_ref(), normalized_title)
                             };
 
                             return Tag::Link {
···
 
     async fn handle_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
         use crate::utils::is_local_path;
-        use tokio::fs;
         use jacquard::bytes::Bytes;
         use jacquard::types::blob::MimeType;
         use mime_sniffer::MimeTypeSniffer;
+        use tokio::fs;
 
         match &image {
             Tag::Image {
···
                         // Sniff mime type from data
                         let bytes = Bytes::from(image_data.clone());
                         let mime = MimeType::new_owned(
-                            bytes.sniff_mime_type().unwrap_or("application/octet-stream")
+                            bytes
+                                .sniff_mime_type()
+                                .unwrap_or("application/octet-stream"),
                         );
 
                         // Upload blob (dereference Arc)
···
                 match resolved {
                     LinkUri::Path(path) => {
                         // Entry embed - look up in vault
-                        if let Some(file_path) = lookup_filename_in_vault(path.as_ref(), &self.vault_contents) {
+                        if let Some(file_path) =
+                            lookup_filename_in_vault(path.as_ref(), &self.vault_contents)
+                        {
                             let entry_title = file_path
                                 .file_stem()
                                 .and_then(|s| s.to_str())
···
                                     normalized_title
                                 )
                             } else {
-                                format!(
-                                    "/{}/{}",
-                                    self.notebook_title.as_ref(),
-                                    normalized_title
-                                )
+                                format!("/{}/{}", self.notebook_title.as_ref(), normalized_title)
                             };
+                            // Markdown embed - look up in vault and render
+                            //use tokio::fs;
+
+                            // Check depth limit
+                            const MAX_DEPTH: usize = 1;
+                            if self.embed_depth >= MAX_DEPTH {
+                                eprintln!("Max embed depth reached for {}", path.as_ref());
+                                return Tag::Embed {
+                                    embed_type: *embed_type,
+                                    dest_url: MdCowStr::Boxed(canonical_url.into_boxed_str()),
+                                    title: title.clone(),
+                                    id: id.clone(),
+                                    attrs: attrs.clone(),
+                                };
+                            }
+                            // // Read the markdown file
+                            // match fs::read_to_string(&file_path).await {
+                            //     Ok(markdown_content) => {
+                            //         // Create a child context with incremented depth
+                            //         let mut child_ctx = self.with_depth(self.embed_depth + 1);
+                            //         child_ctx.current_path = file_path.clone();
+
+                            //         // Render the markdown through the processor
+                            //         // We'll use markdown_weaver to parse and render to HTML
+                            //         use markdown_weaver::{Options, Parser};
+                            //         use markdown_weaver_escape::StrWrite;
+
+                            //         let parser = Parser::new_ext(&markdown_content, Options::all());
+                            //         let mut html_output = String::new();
+
+                            //         // Process events through context callbacks
+                            //         for event in parser {
+                            //             match event {
+                            //                 markdown_weaver::Event::Start(tag) => {
+                            //                     let processed = match tag {
+                            //                         Tag::Link { .. } => {
+                            //                             child_ctx.handle_link(tag).await
+                            //                         }
+                            //                         Tag::Image { .. } => {
+                            //                             child_ctx.handle_image(tag).await
+                            //                         }
+                            //                         Tag::Embed { .. } => {
+                            //                             child_ctx.handle_embed(tag).await
+                            //                         }
+                            //                         _ => tag,
+                            //                     };
+                            //                     // Simple HTML writing (reuse escape logic)
+                            //                     match processed {
+                            //                         Tag::Paragraph => {
+                            //                             html_output.write_str("<p>").ok()
+                            //                         }
+                            //                         _ => None,
+                            //                     };
+                            //                 }
+                            //                 markdown_weaver::Event::End(tag_end) => {
+                            //                     match tag_end {
+                            //                         markdown_weaver::TagEnd::Paragraph => {
+                            //                             html_output.write_str("</p>\n").ok()
+                            //                         }
+                            //                         _ => None,
+                            //                     };
+                            //                 }
+                            //                 markdown_weaver::Event::Text(text) => {
+                            //                     use markdown_weaver_escape::escape_html_body_text;
+                            //                     escape_html_body_text(&mut html_output, &text).ok();
+                            //                 }
+                            //                 _ => {}
+                            //             }
+                            //         }
+
+                            //         let mut new_attrs =
+                            //             attrs.clone().unwrap_or_else(|| WeaverAttributes {
+                            //                 classes: vec![],
+                            //                 attrs: vec![],
+                            //             });
+
+                            //         new_attrs.attrs.push(("content".into(), html_output.into()));
+
+                            //         return Tag::Embed {
+                            //             embed_type: *embed_type,
+                            //             dest_url: MdCowStr::Boxed(canonical_url.into_boxed_str()),
+                            //             title: title.clone(),
+                            //             id: id.clone(),
+                            //             attrs: Some(new_attrs),
+                            //         };
+                            //     }
+                            //     Err(e) => {
+                            //         eprintln!("Failed to read file {:?}: {}", file_path, e);
+                            //     }
+                            // }
 
                             return Tag::Embed {
                                 embed_type: *embed_type,
···
                         });
 
                         if let Some(content_html) = content {
-                            new_attrs.attrs.push(("content".into(), content_html.into()));
+                            new_attrs
+                                .attrs
+                                .push(("content".into(), content_html.into()));
                         }
 
                         return Tag::Embed {
···
                     }
                     LinkUri::AtRecord(uri) => {
                         // AT URI embed - fetch and render
-                        use crate::atproto::{fetch_and_render_post, fetch_and_render_generic};
+                        use crate::atproto::{fetch_and_render_generic, fetch_and_render_post};
                         use markdown_weaver::WeaverAttributes;
 
                         // Determine if this is a known type
···
                                     match fetch_and_render_post(&uri, &*self.agent).await {
                                         Ok(html) => Some(html),
                                         Err(e) => {
-                                            eprintln!("Failed to fetch post {}: {}", uri.as_ref(), e);
+                                            eprintln!(
+                                                "Failed to fetch post {}: {}",
+                                                uri.as_ref(),
+                                                e
+                                            );
                                             None
                                         }
                                     }
···
                                     match fetch_and_render_generic(&uri, &*self.agent).await {
                                         Ok(html) => Some(html),
                                         Err(e) => {
-                                            eprintln!("Failed to fetch record {}: {}", uri.as_ref(), e);
+                                            eprintln!(
+                                                "Failed to fetch record {}: {}",
+                                                uri.as_ref(),
+                                                e
+                                            );
                                             None
                                         }
                                     }
···
                         });
 
                         if let Some(content_html) = content {
-                            new_attrs.attrs.push(("content".into(), content_html.into()));
+                            new_attrs
+                                .attrs
+                                .push(("content".into(), content_html.into()));
                         }
 
                         return Tag::Embed {
···
                             attrs: Some(new_attrs),
                         };
                     }
-                    LinkUri::Path(path) => {
-                        // Markdown embed - look up in vault and render
-                        use crate::utils::lookup_filename_in_vault;
-                        use tokio::fs;
 
-                        // Check depth limit
-                        const MAX_DEPTH: usize = 1;
-                        if self.embed_depth >= MAX_DEPTH {
-                            eprintln!("Max embed depth reached for {}", path.as_ref());
-                            return embed.clone();
-                        }
-
-                        if let Some(file_path) = lookup_filename_in_vault(path.as_ref(), &self.vault_contents) {
-                            // Read the markdown file
-                            match fs::read_to_string(&file_path).await {
-                                Ok(markdown_content) => {
-                                    // Create a child context with incremented depth
-                                    let mut child_ctx = self.with_depth(self.embed_depth + 1);
-                                    child_ctx.current_path = file_path.clone();
-
-                                    // Render the markdown through the processor
-                                    // We'll use markdown_weaver to parse and render to HTML
-                                    use markdown_weaver::{Parser, Options};
-                                    use markdown_weaver_escape::StrWrite;
-
-                                    let parser = Parser::new_ext(&markdown_content, Options::all());
-                                    let mut html_output = String::new();
-
-                                    // Process events through context callbacks
-                                    for event in parser {
-                                        match event {
-                                            markdown_weaver::Event::Start(tag) => {
-                                                let processed = match tag {
-                                                    Tag::Link { .. } => child_ctx.handle_link(tag).await,
-                                                    Tag::Image { .. } => child_ctx.handle_image(tag).await,
-                                                    Tag::Embed { .. } => child_ctx.handle_embed(tag).await,
-                                                    _ => tag,
-                                                };
-                                                // Simple HTML writing (reuse escape logic)
-                                                match processed {
-                                                    Tag::Paragraph => html_output.write_str("<p>").ok(),
-                                                    _ => None,
-                                                };
-                                            }
-                                            markdown_weaver::Event::End(tag_end) => {
-                                                match tag_end {
-                                                    markdown_weaver::TagEnd::Paragraph => html_output.write_str("</p>\n").ok(),
-                                                    _ => None,
-                                                };
-                                            }
-                                            markdown_weaver::Event::Text(text) => {
-                                                use markdown_weaver_escape::escape_html_body_text;
-                                                escape_html_body_text(&mut html_output, &text).ok();
-                                            }
-                                            _ => {}
-                                        }
-                                    }
-
-                                    let mut new_attrs = attrs.clone().unwrap_or_else(|| WeaverAttributes {
-                                        classes: vec![],
-                                        attrs: vec![],
-                                    });
-
-                                    new_attrs.attrs.push(("content".into(), html_output.into()));
-
-                                    return Tag::Embed {
-                                        embed_type: *embed_type,
-                                        dest_url: dest_url.clone(),
-                                        title: title.clone(),
-                                        id: id.clone(),
-                                        attrs: Some(new_attrs),
-                                    };
-                                }
-                                Err(e) => {
-                                    eprintln!("Failed to read file {:?}: {}", file_path, e);
-                                }
-                            }
-                        }
-                    }
                     _ => {}
                 }
 
                 // Pass through other embed types
                 embed.clone()
             }
-            Tag::Image {
-                link_type,
-                dest_url,
-                title,
-                id,
-                attrs,
-            } => {
+            Tag::Image { .. } => {
                 // Some embeds come through as explicit Tag::Image
                 // Delegate to handle_image for image-specific processing
                 self.handle_image(embed).await
···
     }
 
     fn add_reference(&self, reference: MdCowStr<'_>) {
-        self.reference_map.insert(reference.into_static(), self.current_path.clone());
+        self.reference_map
+            .insert(reference.into_static(), self.current_path.clone());
     }
 }
 

crates/weaver-renderer/src/css.rs

···
 use crate::theme::Theme;
 use miette::IntoDiagnostic;
 use std::io::Cursor;
-use syntect::highlighting::{Theme as SyntectTheme, ThemeSet};
+use syntect::highlighting::ThemeSet;
 use syntect::html::{ClassStyle, css_for_theme_with_class_style};
-use syntect::parsing::SyntaxSet;
 use weaver_api::com_atproto::sync::get_blob::GetBlob;
 use weaver_api::sh_weaver::notebook::theme::ThemeCodeTheme;
 use weaver_common::jacquard::client::BasicClient;

crates/weaver-renderer/src/static_site.rs

···
 pub mod document;
 pub mod writer;
 
+use crate::utils::VaultBrokenLinkCallback;
 use crate::{
     ContextIterator, NotebookProcessor,
     static_site::{
···
         document::{CssMode, write_document_footer, write_document_head},
         writer::StaticPageWriter,
     },
-    theme::defaultTheme,
+    theme::default_theme,
     utils::flatten_dir_to_just_one_parent,
     walker::{WalkOptions, vault_contents},
 };
···
     path::{Path, PathBuf},
     sync::Arc,
 };
-use crate::utils::VaultBrokenLinkCallback;
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use tokio::io::AsyncWriteExt;
 use unicode_normalization::UnicodeNormalization;
···
             | Self::NORMALIZE_DIR_NAMES
     }
 }
-
 
 pub struct StaticSiteWriter<A>
 where
···
             .await
             .into_diagnostic()?;
 
-        let default_theme = defaultTheme();
+        let default_theme = default_theme();
         let theme = self.context.theme.as_deref().unwrap_or(&default_theme);
 
         // Write base.css
···
 
     Ok(())
 }
-
-
 
 #[cfg(test)]
 mod tests;

crates/weaver-renderer/src/static_site/document.rs

···
 use crate::css::{generate_base_css, generate_syntax_css};
 use crate::static_site::context::{KaTeXSource, StaticSiteContext};
-use crate::theme::{Theme, defaultTheme};
+use crate::theme::{Theme, default_theme};
 use miette::IntoDiagnostic;
 use weaver_common::jacquard::client::AgentSession;
 
···
                 .into_diagnostic()?;
         }
         CssMode::Inline => {
-            let default_theme = defaultTheme();
+            let default_theme = default_theme();
             let theme = context.theme.as_deref().unwrap_or(&default_theme);
 
             writer.write_all(b"  <style>\n").await.into_diagnostic()?;

crates/weaver-renderer/src/theme.rs

···
 use weaver_common::jacquard::CowStr;
 use weaver_common::jacquard::cowstr::ToCowStr;
 
-pub fn defaultTheme() -> Theme<'static> {
+pub fn default_theme() -> Theme<'static> {
     Theme::new()
         .code_theme(ThemeCodeTheme::CodeThemeName(Box::new(
             "rose-pine".to_cowstr(),
         )))
         .colours(ThemeColours {
-            background: CowStr::new_static("#faf4ed"),
-            foreground: CowStr::new_static("#2b303b"),
-            link: CowStr::new_static("#286983"),
-            link_hover: CowStr::new_static("#56949f"),
+            background: CowStr::new_static("#191724"),
+            foreground: CowStr::new_static("#e0def4"),
+            link: CowStr::new_static("#31748f"),
+            link_hover: CowStr::new_static("#9ccfd8"),
             primary: CowStr::new_static("#c4a7e7"),
             secondary: CowStr::new_static("#3e8fb0"),
 

crates/weaver-server/Cargo.toml

···
 authors = ["Orual <[e-mail]>"]
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = ["web"]
+# The feature that are only required for the web = ["dioxus/web"] build target should be optional and only enabled in the web = ["dioxus/web"] feature
+web = ["dioxus/web", "chrono/wasmbind"]
+# The feature that are only required for the desktop = ["dioxus/desktop"] build target should be optional and only enabled in the desktop = ["dioxus/desktop"] feature
+desktop = ["dioxus/desktop"]
+# The feature that are only required for the mobile = ["dioxus/mobile"] build target should be optional and only enabled in the mobile = ["dioxus/mobile"] feature
+mobile = ["dioxus/mobile"]
+# The feature that are only required for the server = ["dioxus/server"] build target should be optional and only enabled in the server = ["dioxus/server"] feature
+server = ["dioxus/server", "dep:jacquard-axum", "dep:axum"]
 
 [dependencies]
 dashmap = "6.1.0"
···
 weaver-api = { path = "../weaver-api", features = ["streaming"] }
 markdown-weaver = { workspace = true }
 weaver-renderer = { path = "../weaver-renderer" }
-moka = { version = "0.12", features = ["future"], optional = true }
-mini-moka = { version = "0.10" }
-dioxus-primitives = { git = "https://github.com/DioxusLabs/components", version = "0.0.1", default-features = false }
+mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d" }
+#dioxus-primitives = { git = "https://github.com/DioxusLabs/components", version = "0.0.1", default-features = false }
 axum = {version = "0.8.6", optional = true}
 
-[features]
-default = ["web"]
-# The feature that are only required for the web = ["dioxus/web"] build target should be optional and only enabled in the web = ["dioxus/web"] feature
-web = ["dioxus/web"]
-# The feature that are only required for the desktop = ["dioxus/desktop"] build target should be optional and only enabled in the desktop = ["dioxus/desktop"] feature
-desktop = ["dioxus/desktop"]
-# The feature that are only required for the mobile = ["dioxus/mobile"] build target should be optional and only enabled in the mobile = ["dioxus/mobile"] feature
-mobile = ["dioxus/mobile"]
-# The feature that are only required for the server = ["dioxus/server"] build target should be optional and only enabled in the server = ["dioxus/server"] feature
-server = ["dioxus/server", "dep:jacquard-axum", "dep:moka", "dep:axum"]
+chrono = { version = "0.4" }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+time = { version = "0.3", features = ["wasm-bindgen"] }
+console_error_panic_hook = "0.1"
+mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d", features = ["js"] }

crates/weaver-server/src/cache_impl.rs

···
+//! Platform-specific cache implementations
+//! Native uses sync cache (thread-safe, no mutex needed)
+//! WASM uses unsync cache wrapped in Arc<Mutex<>> (no threads, but need interior mutability)
+
+#[cfg(not(target_arch = "wasm32"))]
+mod native {
+    use std::time::Duration;
+
+    pub type Cache<K, V> = mini_moka::sync::Cache<K, V>;
+
+    pub fn new_cache<K, V>(max_capacity: u64, ttl: Duration) -> Cache<K, V>
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        mini_moka::sync::Cache::builder()
+            .max_capacity(max_capacity)
+            .time_to_live(ttl)
+            .build()
+    }
+
+    pub fn get<K, V>(cache: &Cache<K, V>, key: &K) -> Option<V>
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        cache.get(key)
+    }
+
+    pub fn insert<K, V>(cache: &Cache<K, V>, key: K, value: V)
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        cache.insert(key, value);
+    }
+
+    pub fn iter<K, V>(cache: &Cache<K, V>) -> Vec<V>
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        cache.iter().map(|entry| entry.value().clone()).collect()
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+mod wasm {
+    use std::sync::{Arc, Mutex};
+    use std::time::Duration;
+
+    pub type Cache<K, V> = Arc<Mutex<mini_moka::unsync::Cache<K, V>>>;
+
+    pub fn new_cache<K, V>(max_capacity: u64, ttl: Duration) -> Cache<K, V>
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        Arc::new(Mutex::new(
+            mini_moka::unsync::Cache::builder()
+                .max_capacity(max_capacity)
+                .time_to_live(ttl)
+                .build(),
+        ))
+    }
+
+    pub fn get<K, V>(cache: &Cache<K, V>, key: &K) -> Option<V>
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        cache.lock().unwrap().get(key).cloned()
+    }
+
+    pub fn insert<K, V>(cache: &Cache<K, V>, key: K, value: V)
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        cache.lock().unwrap().insert(key, value);
+    }
+
+    pub fn iter<K, V>(cache: &Cache<K, V>) -> Vec<V>
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        cache.lock().unwrap().iter().map(|(_, v)| v.clone()).collect()
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use native::*;
+
+#[cfg(target_arch = "wasm32")]
+pub use wasm::*;

crates/weaver-server/src/components/css.rs

···
 #[allow(unused_imports)]
 use crate::fetch;
-use dioxus::prelude::*;
 #[allow(unused_imports)]
-use dioxus::{fullstack::extract::Extension, fullstack::get_server_url, CapturedError};
+use dioxus::{fullstack::get_server_url, CapturedError};
+use dioxus::{
+    fullstack::{
+        headers::ContentType,
+        http::header::CONTENT_TYPE,
+        response::{self, Response},
+    },
+    prelude::*,
+};
 use jacquard::smol_str::SmolStr;
 #[allow(unused_imports)]
 use std::sync::Arc;
 #[allow(unused_imports)]
 use weaver_renderer::theme::Theme;
+
+#[cfg(feature = "server")]
+use axum::{extract::Extension, response::IntoResponse};
 
 #[component]
 pub fn NotebookCss(ident: SmolStr, notebook: SmolStr) -> Element {
···
 }
 
 #[get("/css/{ident}/{notebook}", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
-pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<String> {
+pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<Response> {
     use jacquard::client::AgentSessionExt;
     use jacquard::types::ident::AtIdentifier;
     use jacquard::{from_data, CowStr};
 
     use weaver_api::sh_weaver::notebook::book::Book;
     use weaver_renderer::css::{generate_base_css, generate_syntax_css};
-    use weaver_renderer::theme::defaultTheme;
+    use weaver_renderer::theme::default_theme;
 
     let ident = AtIdentifier::new_owned(ident)?;
     let theme = if let Some(notebook) = fetcher.get_notebook(ident, notebook).await? {
···
                 theme
                     .into_output()
                     .map(|t| t.value)
-                    .unwrap_or(defaultTheme())
+                    .unwrap_or(default_theme())
             } else {
-                defaultTheme()
+                default_theme()
             }
         } else {
-            defaultTheme()
+            default_theme()
         }
     } else {
-        defaultTheme()
+        default_theme()
     };
     let mut css = generate_base_css(&theme);
     css.push_str(
···
             .map_err(|e| CapturedError::from_display(e))
             .unwrap_or_default(),
     );
-    Ok(css)
+
+    Ok(([(CONTENT_TYPE, "text/css")], css).into_response())
 }

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

···
         entry
     }));
 
-    rsx! {
-        match &*entry.read_unchecked() {
-            Some(Some(entry)) => {
-                let class = use_signal(|| String::from("entry"));
-                let content = use_signal(||entry.1.clone());
-                rsx! { EntryMarkdown {
-                    class,
-                    content
-                } }
-            },
-            Some(None) => rsx! { p { "Loading entry failed" } },
-            None =>  rsx! { p { "Loading..." } }
+    match &*entry.read_unchecked() {
+        Some(Some(entry_data)) => {
+            rsx! { EntryMarkdownDirect {
+                content: entry_data.1.clone()
+            } }
+        },
+        Some(None) => {
+            rsx! { div { class: "error", "Entry not found" } }
         }
+        None => rsx! { p { "Loading..." } }
     }
 }
 
···
         div {
             id: "{&*props.id.read()}",
             class: "{&*props.class.read()}",
+            dangerous_inner_html: "{html_buf}"
+        }
+    }
+}
+
+/// Render entry content directly without signals
+#[component]
+fn EntryMarkdownDirect(
+    #[props(default)] id: String,
+    #[props(default = "entry".to_string())] class: String,
+    content: entry::Entry<'static>,
+) -> Element {
+    let parser = markdown_weaver::Parser::new(&content.content);
+
+    let mut html_buf = String::new();
+    markdown_weaver::html::push_html(&mut html_buf, parser);
+
+    rsx! {
+        div {
+            id: "{id}",
+            class: "{class}",
             dangerous_inner_html: "{html_buf}"
         }
     }

crates/weaver-server/src/components/mod.rs

···
 //! They can be used to defined common UI elements like buttons, forms, and modals. In this template, we define a Hero
 //! component and an Echo component for fullstack apps to be used in our app.
 
-mod css;
+pub mod css;
 pub use css::NotebookCss;
 
 mod entry;
···
 
 mod identity;
 pub use identity::{Repository, RepositoryIndex};
-pub mod avatar;
+//pub mod avatar;

crates/weaver-server/src/fetch.rs

···
+use crate::cache_impl;
 use dioxus::Result;
 use jacquard::{client::BasicClient, smol_str::SmolStr, types::ident::AtIdentifier};
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
-};
+use std::{sync::Arc, time::Duration};
 use weaver_api::{
     com_atproto::repo::strong_ref::StrongRef,
     sh_weaver::notebook::{entry::Entry, BookEntryView, NotebookView},
···
 #[derive(Clone)]
 pub struct CachedFetcher {
     pub client: Arc<BasicClient>,
-    #[cfg(not(feature = "server"))]
-    book_cache: Arc<
-        Mutex<
-            mini_moka::unsync::Cache<
-                (AtIdentifier<'static>, SmolStr),
-                Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
-            >,
-        >,
-    >,
-    #[cfg(not(feature = "server"))]
-    entry_cache: Arc<
-        Mutex<
-            mini_moka::unsync::Cache<
-                (AtIdentifier<'static>, SmolStr),
-                Arc<(BookEntryView<'static>, Entry<'static>)>,
-            >,
-        >,
-    >,
-    #[cfg(feature = "server")]
-    book_cache: Arc<
-        Mutex<
-            mini_moka::sync::Cache<
-                (AtIdentifier<'static>, SmolStr),
-                Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
-            >,
-        >,
+    book_cache: cache_impl::Cache<
+        (AtIdentifier<'static>, SmolStr),
+        Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
     >,
-    #[cfg(feature = "server")]
-    entry_cache: Arc<
-        Mutex<
-            mini_moka::sync::Cache<
-                (AtIdentifier<'static>, SmolStr),
-                Arc<(BookEntryView<'static>, Entry<'static>)>,
-            >,
-        >,
+    entry_cache: cache_impl::Cache<
+        (AtIdentifier<'static>, SmolStr),
+        Arc<(BookEntryView<'static>, Entry<'static>)>,
     >,
 }
 
 impl CachedFetcher {
-    #[cfg(not(feature = "server"))]
     pub fn new(client: Arc<BasicClient>) -> Self {
-        let book_cache = mini_moka::unsync::Cache::builder()
-            .max_capacity(100)
-            .time_to_idle(Duration::from_secs(1200))
-            .build();
-        let entry_cache = mini_moka::unsync::Cache::builder()
-            .max_capacity(100)
-            .time_to_idle(Duration::from_secs(600))
-            .build();
-
         Self {
             client,
-            book_cache: Arc::new(Mutex::new(book_cache)),
-            entry_cache: Arc::new(Mutex::new(entry_cache)),
-        }
-    }
-
-    #[cfg(feature = "server")]
-    pub fn new(client: Arc<BasicClient>) -> Self {
-        let book_cache = mini_moka::sync::Cache::builder()
-            .max_capacity(100)
-            .time_to_idle(Duration::from_secs(1200))
-            .build();
-        let entry_cache = mini_moka::sync::Cache::builder()
-            .max_capacity(100)
-            .time_to_idle(Duration::from_secs(600))
-            .build();
-
-        Self {
-            client,
-            book_cache: Arc::new(Mutex::new(book_cache)),
-            entry_cache: Arc::new(Mutex::new(entry_cache)),
+            book_cache: cache_impl::new_cache(100, Duration::from_secs(1200)),
+            entry_cache: cache_impl::new_cache(100, Duration::from_secs(600)),
         }
     }
 
···
         ident: AtIdentifier<'static>,
         title: SmolStr,
     ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
-        if let Ok(mut book_cache) = self.book_cache.lock() {
-            if let Some(entry) = book_cache.get(&(ident.clone(), title.clone())) {
-                Ok(Some(entry.clone()))
+        if let Some(entry) = cache_impl::get(&self.book_cache, &(ident.clone(), title.clone())) {
+            Ok(Some(entry))
+        } else {
+            if let Some((notebook, entries)) =
+                notebook_by_title(self.client.clone(), &ident, &title)
+                    .await
+                    .map_err(|e| dioxus::CapturedError::from_display(e))?
+            {
+                let stored = Arc::new((notebook, entries));
+                cache_impl::insert(&self.book_cache, (ident, title), stored.clone());
+                Ok(Some(stored))
             } else {
-                if let Some((notebook, entries)) =
-                    notebook_by_title(self.client.clone(), &ident, &title)
-                        .await
-                        .map_err(|e| dioxus::CapturedError::from_display(e))?
-                {
-                    let stored = Arc::new((notebook, entries));
-                    book_cache.insert((ident.clone(), title.into()), stored.clone());
-                    Ok(Some(stored))
-                } else {
-                    Ok(None)
-                }
+                Ok(None)
             }
-        } else {
-            Ok(None)
         }
     }
 
···
     ) -> Result<Option<Arc<(BookEntryView<'static>, Entry<'static>)>>> {
         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
             let (notebook, entries) = result.as_ref();
-            if let Ok(mut entry_cache) = self.entry_cache.lock() {
-                if let Some(entry) = entry_cache.get(&(ident.clone(), entry_title.clone())) {
-                    Ok(Some(entry.clone()))
+            if let Some(entry) = cache_impl::get(&self.entry_cache, &(ident.clone(), entry_title.clone())) {
+                Ok(Some(entry))
+            } else {
+                if let Some(entry) = entry_by_title(
+                    self.client.clone(),
+                    notebook,
+                    entries.as_ref(),
+                    &entry_title,
+                )
+                .await
+                .map_err(|e| dioxus::CapturedError::from_display(e))?
+                {
+                    let stored = Arc::new(entry);
+                    cache_impl::insert(&self.entry_cache, (ident, entry_title), stored.clone());
+                    Ok(Some(stored))
                 } else {
-                    if let Some(entry) = entry_by_title(
-                        self.client.clone(),
-                        notebook,
-                        entries.as_ref(),
-                        &entry_title,
-                    )
-                    .await
-                    .map_err(|e| dioxus::CapturedError::from_display(e))?
-                    {
-                        let stored = Arc::new(entry);
-                        entry_cache.insert((ident.clone(), entry_title.into()), stored.clone());
-                        Ok(Some(stored))
-                    } else {
-                        Ok(None)
-                    }
+                    Ok(None)
                 }
-            } else {
-                Ok(None)
             }
         } else {
             Ok(None)
         }
     }
 
-    #[cfg(not(feature = "server"))]
     pub fn list_recent_entries(&self) -> Vec<Arc<(BookEntryView<'static>, Entry<'static>)>> {
-        if let Ok(entry_cache) = self.entry_cache.lock() {
-            let mut entries = Vec::new();
-            for (_, entry) in entry_cache.iter() {
-                entries.push(entry.clone());
-            }
-            entries
-        } else {
-            Vec::new()
-        }
-    }
-
-    #[cfg(not(feature = "server"))]
-    pub fn list_recent_notebooks(
-        &self,
-    ) -> Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
-        if let Ok(book_cache) = self.book_cache.lock() {
-            let mut entries = Vec::new();
-            for (_, entry) in book_cache.iter() {
-                entries.push(entry.clone());
-            }
-            entries
-        } else {
-            Vec::new()
-        }
-    }
-
-    #[cfg(feature = "server")]
-    pub fn list_recent_entries(&self) -> Vec<Arc<(BookEntryView<'static>, Entry<'static>)>> {
-        if let Ok(entry_cache) = self.entry_cache.lock() {
-            let mut entries = Vec::new();
-            for entry in entry_cache.iter() {
-                entries.push(entry.clone());
-            }
-            entries
-        } else {
-            Vec::new()
-        }
+        cache_impl::iter(&self.entry_cache)
     }
 
-    #[cfg(feature = "server")]
     pub fn list_recent_notebooks(
         &self,
     ) -> Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
-        if let Ok(book_cache) = self.book_cache.lock() {
-            let mut entries = Vec::new();
-            for entry in book_cache.iter() {
-                entries.push(entry.clone());
-            }
-            entries
-        } else {
-            Vec::new()
-        }
+        cache_impl::iter(&self.book_cache)
     }
 }

crates/weaver-server/src/main.rs

···
 use views::{Home, Navbar, Notebook, NotebookIndex, NotebookPage};
 
 mod blobcache;
+mod cache_impl;
 /// Define a components module that contains all shared components for our app.
 mod components;
 mod fetch;
···
 const MAIN_CSS: Asset = asset!("/assets/styling/main.css");
 
 fn main() {
+    // Set up better panic messages for wasm
+    #[cfg(target_arch = "wasm32")]
+    console_error_panic_hook::set_once();
+
     // Run `serve()` on the server only
     #[cfg(feature = "server")]
     dioxus::serve(|| async move {
-        use axum::{extract::Request, middleware, middleware::Next};
-        // Create a new router for our app using the `router` function
-        let mut router = dioxus::server::router(App).layer(middleware::from_fn(
-            |mut req: Request, next: Next| async move {
-                // Attach some extra state to the request
+        use crate::blobcache::BlobCache;
+        use crate::fetch::CachedFetcher;
+        use axum::{
+            extract::{Extension, Request},
+            middleware,
+            middleware::Next,
+        };
+        use std::convert::Infallible;
+        use std::sync::Arc;
 
-                use crate::blobcache::BlobCache;
-                use crate::fetch::CachedFetcher;
-                use std::convert::Infallible;
-                use std::sync::Arc;
-                req.extensions_mut()
-                    .insert(Arc::new(CachedFetcher::new(Arc::new(
-                        BasicClient::unauthenticated(),
-                    ))));
-                req.extensions_mut()
-                    .insert(Arc::new(BlobCache::new(Arc::new(
-                        BasicClient::unauthenticated(),
-                    ))));
+        // Create shared state
+        let fetcher = Arc::new(CachedFetcher::new(Arc::new(BasicClient::unauthenticated())));
+        let blob_cache = Arc::new(BlobCache::new(Arc::new(BasicClient::unauthenticated())));
 
-                // And then return the response with `next.run()
-                Ok::<_, Infallible>(next.run(req).await)
-            },
-        ));
+        // Create a new router for our app using the `router` function
+        let router = dioxus::server::router(App).layer(middleware::from_fn({
+            let fetcher = fetcher.clone();
+            let blob_cache = blob_cache.clone();
+            move |mut req: Request, next: Next| {
+                let fetcher = fetcher.clone();
+                let blob_cache = blob_cache.clone();
+                async move {
+                    // Attach extensions for dioxus server functions
+                    req.extensions_mut().insert(fetcher);
+                    req.extensions_mut().insert(blob_cache);
 
-        // .. customize the router, adding layers and new routes
-
+                    // And then return the response with `next.run()
+                    Ok::<_, Infallible>(next.run(req).await)
+                }
+            }
+        }));
         // And then return the router
         Ok(router)
     });