client-side works fully again

Cargo.lock

···
 
 [[package]]
 name = "const-serialize"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08259976d62c715c4826cb4a3d64a3a9e5c5f68f964ff6087319857f569f93a6"
+dependencies = [
+ "const-serialize-macro 0.6.2",
+ "serde",
+]
+
+[[package]]
+name = "const-serialize"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd339aa356cc6452308fad2ee56623f900a8e68bc0ab9360a0ddb8270e5640c8"
 dependencies = [
- "const-serialize-macro",
+ "const-serialize-macro 0.7.1",
  "serde",
+]
+
+[[package]]
+name = "const-serialize-macro"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04382d0d9df7434af6b1b49ea1a026ef39df1b0738b1cc373368cf175354f6eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "convert_case"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f"
···
 
 [[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"
···
 
 [[package]]
 name = "dioxus"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a247114500f1a78e87022defa8173de847accfada8e8809dfae23a118a580c"
+dependencies = [
+ "dioxus-cli-config 0.6.3",
+ "dioxus-config-macro 0.6.2",
+ "dioxus-core 0.6.3",
+ "dioxus-core-macro 0.6.3",
+ "dioxus-devtools 0.6.2",
+ "dioxus-document 0.6.3",
+ "dioxus-fullstack 0.6.3",
+ "dioxus-history 0.6.2",
+ "dioxus-hooks 0.6.2",
+ "dioxus-html 0.6.3",
+ "dioxus-logger 0.6.2",
+ "dioxus-signals 0.6.3",
+ "dioxus-web 0.6.3",
+ "manganis 0.6.2",
+ "warnings",
+]
+
+[[package]]
+name = "dioxus"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f76e820919058a685a1fdbb2ef4888c73ac77d623c39a7dfde2aa812947246be"
 dependencies = [
  "dioxus-asset-resolver",
- "dioxus-cli-config",
- "dioxus-config-macro",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-config-macro 0.7.1",
  "dioxus-config-macros",
- "dioxus-core",
- "dioxus-core-macro",
+ "dioxus-core 0.7.1",
+ "dioxus-core-macro 0.7.1",
  "dioxus-desktop",
- "dioxus-devtools",
- "dioxus-document",
- "dioxus-fullstack",
+ "dioxus-devtools 0.7.1",
+ "dioxus-document 0.7.1",
+ "dioxus-fullstack 0.7.1",
  "dioxus-fullstack-macro",
- "dioxus-history",
- "dioxus-hooks",
- "dioxus-html",
+ "dioxus-history 0.7.1",
+ "dioxus-hooks 0.7.1",
+ "dioxus-html 0.7.1",
  "dioxus-liveview",
- "dioxus-logger",
+ "dioxus-logger 0.7.1",
  "dioxus-router",
  "dioxus-server",
- "dioxus-signals",
+ "dioxus-signals 0.7.1",
  "dioxus-ssr",
  "dioxus-stores",
- "dioxus-web",
- "manganis",
+ "dioxus-web 0.7.1",
+ "manganis 0.7.1",
  "serde",
  "subsecond",
  "warnings",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f6a124667ce5565c39fe2f33af45c21fe459c5bfcf7a8074ad12c9e9da5817c"
 dependencies = [
- "dioxus-cli-config",
+ "dioxus-cli-config 0.7.1",
  "http",
  "infer",
  "jni",
···
 
 [[package]]
 name = "dioxus-cli-config"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdd16948f1ffdb068dd9a64812158073a4250e2af4e98ea31fdac0312e6bce86"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "dioxus-cli-config"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "babc8eaf90379352bc4820830749fd231feb9312433d4094b4e7b79d912b3d96"
···
 
 [[package]]
 name = "dioxus-config-macro"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75cbf582fbb1c32d34a1042ea675469065574109c95154468710a4d73ee98b49"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "dioxus-config-macro"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "30018b5b95567cee42febbb444d5e5e47dbe3e91fa6e44b9e571edad0184cd36"
···
 
 [[package]]
 name = "dioxus-core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c03f451a119e47433c16e2d8eb5b15bf7d6e6734eb1a4c47574e6711dadff8d"
+dependencies = [
+ "const_format",
+ "dioxus-core-types 0.6.2",
+ "futures-channel",
+ "futures-util",
+ "generational-box 0.6.2",
+ "longest-increasing-subsequence",
+ "rustc-hash 1.1.0",
+ "rustversion",
+ "serde",
+ "slab",
+ "slotmap",
+ "tracing",
+ "warnings",
+]
+
+[[package]]
+name = "dioxus-core"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75468d08468919f783b0f7ee826802f4e8e66c5b5a0451245d861c211ca18216"
 dependencies = [
  "anyhow",
  "const_format",
- "dioxus-core-types",
+ "dioxus-core-types 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "longest-increasing-subsequence",
  "rustc-hash 2.1.1",
  "rustversion",
···
 
 [[package]]
 name = "dioxus-core-macro"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "105c954caaaedf8cd10f3d1ba576b01e18aa8d33ad435182125eefe488cf0064"
+dependencies = [
+ "convert_case 0.6.0",
+ "dioxus-rsx 0.6.2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "dioxus-core-macro"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f145abdb2a3f858456cb4382390863cf0398c228ad0733618f48891da7687be3"
 dependencies = [
  "convert_case 0.8.0",
- "dioxus-rsx",
+ "dioxus-rsx 0.7.1",
  "proc-macro2",
  "quote",
  "syn 2.0.110",
···
 
 [[package]]
 name = "dioxus-core-types"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91a82fccfa48574eb7aa183e297769540904694844598433a9eb55896ad9f93b"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "dioxus-core-types"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "36f5ecf5a51de06d78aded3b5f7516a258f53117cba718bc5706317a3c04c844"
···
  "cocoa",
  "core-foundation 0.10.1",
  "dioxus-asset-resolver",
- "dioxus-cli-config",
- "dioxus-core",
- "dioxus-devtools",
- "dioxus-document",
- "dioxus-history",
- "dioxus-hooks",
- "dioxus-html",
- "dioxus-interpreter-js",
- "dioxus-signals",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
+ "dioxus-devtools 0.7.1",
+ "dioxus-document 0.7.1",
+ "dioxus-history 0.7.1",
+ "dioxus-hooks 0.7.1",
+ "dioxus-html 0.7.1",
+ "dioxus-interpreter-js 0.7.1",
+ "dioxus-signals 0.7.1",
  "dunce",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "global-hotkey",
  "infer",
  "jni",
···
 
 [[package]]
 name = "dioxus-devtools"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712a7300f1e8181218187b03502044157eef04e0a25b518117c5ef9ae1096880"
+dependencies = [
+ "dioxus-core 0.6.3",
+ "dioxus-devtools-types 0.6.2",
+ "dioxus-signals 0.6.3",
+ "serde",
+ "serde_json",
+ "tracing",
+ "tungstenite 0.23.0",
+ "warnings",
+]
+
+[[package]]
+name = "dioxus-devtools"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4eb2c5019b7fa72e8e6b21ba99e9263bd390c9a30bbf09793b72f4b57ed7c3d7"
 dependencies = [
- "dioxus-cli-config",
- "dioxus-core",
- "dioxus-devtools-types",
- "dioxus-signals",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
+ "dioxus-devtools-types 0.7.1",
+ "dioxus-signals 0.7.1",
  "futures-channel",
  "futures-util",
  "serde",
···
  "tracing",
  "tungstenite 0.27.0",
  "warnings",
+]
+
+[[package]]
+name = "dioxus-devtools-types"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f62434973c0c9c5a3bc42e9cd5e7070401c2062a437fb5528f318c3e42ebf4ff"
+dependencies = [
+ "dioxus-core 0.6.3",
+ "serde",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b007cec5b8548281921c4e4678926a3936e9d6757e951380685cc6121a6f974"
 dependencies = [
- "dioxus-core",
+ "dioxus-core 0.7.1",
  "serde",
  "subsecond-types",
 ]
 
 [[package]]
 name = "dioxus-document"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "802a2014d1662b6615eec0a275745822ee4fc66aacd9d0f2fb33d6c8da79b8f2"
+dependencies = [
+ "dioxus-core 0.6.3",
+ "dioxus-core-macro 0.6.3",
+ "dioxus-core-types 0.6.2",
+ "dioxus-html 0.6.3",
+ "futures-channel",
+ "futures-util",
+ "generational-box 0.6.2",
+ "lazy-js-bundle 0.6.2",
+ "serde",
+ "serde_json",
+ "tracing",
+]
+
+[[package]]
+name = "dioxus-document"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c55bcae9aaf150d4a141c61b3826da5a7ac23dfff09726568525cd46336e9a2"
 dependencies = [
- "dioxus-core",
- "dioxus-core-macro",
- "dioxus-core-types",
- "dioxus-html",
+ "dioxus-core 0.7.1",
+ "dioxus-core-macro 0.7.1",
+ "dioxus-core-types 0.7.1",
+ "dioxus-html 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "lazy-js-bundle 0.7.1",
  "serde",
  "serde_json",
···
 ]
 
 [[package]]
+name = "dioxus-free-icons"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd226c24168bb63d12d69cc0e7a6d73faa970574445c8e79c29965892f1a2ad8"
+dependencies = [
+ "dioxus 0.6.3",
+]
+
+[[package]]
+name = "dioxus-fullstack"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe99b48a1348eec385b5c4bd3e80fd863b0d3b47257d34e2ddc58754dec5d128"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "ciborium",
+ "dioxus-devtools 0.6.2",
+ "dioxus-history 0.6.2",
+ "dioxus-lib",
+ "dioxus-web 0.6.3",
+ "dioxus_server_macro",
+ "futures-channel",
+ "futures-util",
+ "generational-box 0.6.2",
+ "once_cell",
+ "serde",
+ "server_fn",
+ "tracing",
+]
+
+[[package]]
 name = "dioxus-fullstack"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "content_disposition",
  "derive_more 2.0.1",
  "dioxus-asset-resolver",
- "dioxus-cli-config",
- "dioxus-core",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
  "dioxus-fullstack-core",
  "dioxus-fullstack-macro",
- "dioxus-hooks",
- "dioxus-html",
- "dioxus-signals",
+ "dioxus-hooks 0.7.1",
+ "dioxus-html 0.7.1",
+ "dioxus-signals 0.7.1",
  "form_urlencoded",
  "futures",
  "futures-channel",
···
  "send_wrapper",
  "serde",
  "serde_json",
- "serde_qs",
+ "serde_qs 0.15.0",
  "serde_urlencoded",
  "thiserror 2.0.17",
  "tokio",
···
  "axum-core",
  "base64 0.22.1",
  "ciborium",
- "dioxus-core",
- "dioxus-document",
- "dioxus-history",
- "dioxus-hooks",
- "dioxus-signals",
+ "dioxus-core 0.7.1",
+ "dioxus-document 0.7.1",
+ "dioxus-history 0.7.1",
+ "dioxus-hooks 0.7.1",
+ "dioxus-signals 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "http",
  "inventory",
  "parking_lot",
···
 
 [[package]]
 name = "dioxus-history"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ae4e22616c698f35b60727313134955d885de2d32e83689258e586ebc9b7909"
+dependencies = [
+ "dioxus-core 0.6.3",
+ "tracing",
+]
+
+[[package]]
+name = "dioxus-history"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dac73657da5c7a20629482d774b52f4a4f7cb57a520649f1d855d4073e809c98"
 dependencies = [
- "dioxus-core",
+ "dioxus-core 0.7.1",
  "tracing",
 ]
 
 [[package]]
 name = "dioxus-hooks"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "948e2b3f20d9d4b2c300aaa60281b1755f3298684448920b27106da5841896d0"
+dependencies = [
+ "dioxus-core 0.6.3",
+ "dioxus-signals 0.6.3",
+ "futures-channel",
+ "futures-util",
+ "generational-box 0.6.2",
+ "rustversion",
+ "slab",
+ "tracing",
+ "warnings",
+]
+
+[[package]]
+name = "dioxus-hooks"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ffd445f16d64939e06cd71a1c63a665f383fda6b7882f4c6f8f1bd6efca2046"
 dependencies = [
- "dioxus-core",
- "dioxus-signals",
+ "dioxus-core 0.7.1",
+ "dioxus-signals 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "rustversion",
  "slab",
  "tracing",
···
 
 [[package]]
 name = "dioxus-html"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59c9a40e6fee20ce7990095492dedb6a753eebe05e67d28271a249de74dc796d"
+dependencies = [
+ "async-trait",
+ "dioxus-core 0.6.3",
+ "dioxus-core-macro 0.6.3",
+ "dioxus-core-types 0.6.2",
+ "dioxus-hooks 0.6.2",
+ "dioxus-html-internal-macro 0.6.2",
+ "enumset",
+ "euclid",
+ "futures-channel",
+ "generational-box 0.6.2",
+ "keyboard-types",
+ "lazy-js-bundle 0.6.2",
+ "rustversion",
+ "tracing",
+]
+
+[[package]]
+name = "dioxus-html"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f407fc73a9554a644872fcccc9faf762acad8f45158e3d67e42ab8dd42f4586"
 dependencies = [
  "async-trait",
  "bytes",
- "dioxus-core",
- "dioxus-core-macro",
- "dioxus-core-types",
- "dioxus-hooks",
- "dioxus-html-internal-macro",
+ "dioxus-core 0.7.1",
+ "dioxus-core-macro 0.7.1",
+ "dioxus-core-types 0.7.1",
+ "dioxus-hooks 0.7.1",
+ "dioxus-html-internal-macro 0.7.1",
  "enumset",
  "euclid",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "keyboard-types",
  "lazy-js-bundle 0.7.1",
  "rustversion",
···
 
 [[package]]
 name = "dioxus-html-internal-macro"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43ba87b53688a2c9f619ecdf4b3b955bc1f08bd0570a80a0d626c405f6d14a76"
+dependencies = [
+ "convert_case 0.6.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "dioxus-html-internal-macro"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a968aae4bc92de87cbac3d0d043803b25a7c62c187841e61adcc9b49917c2b2a"
···
 
 [[package]]
 name = "dioxus-interpreter-js"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330707b10ca75cb0eb05f9e5f8d80217cd0d7e62116a8277ae363c1a09b57a22"
+dependencies = [
+ "js-sys",
+ "lazy-js-bundle 0.6.2",
+ "rustc-hash 1.1.0",
+ "sledgehammer_bindgen",
+ "sledgehammer_utils",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "dioxus-interpreter-js"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83ab170d89308399205f8ad3d43d8d419affe317016b41ca0695186f7593cba2"
 dependencies = [
- "dioxus-core",
- "dioxus-core-types",
- "dioxus-html",
+ "dioxus-core 0.7.1",
+ "dioxus-core-types 0.7.1",
+ "dioxus-html 0.7.1",
  "js-sys",
  "lazy-js-bundle 0.7.1",
  "rustc-hash 2.1.1",
···
 ]
 
 [[package]]
+name = "dioxus-lib"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5405b71aa9b8b0c3e0d22728f12f34217ca5277792bd315878cc6ecab7301b72"
+dependencies = [
+ "dioxus-config-macro 0.6.2",
+ "dioxus-core 0.6.3",
+ "dioxus-core-macro 0.6.3",
+ "dioxus-document 0.6.3",
+ "dioxus-history 0.6.2",
+ "dioxus-hooks 0.6.2",
+ "dioxus-html 0.6.3",
+ "dioxus-rsx 0.6.2",
+ "dioxus-signals 0.6.3",
+ "warnings",
+]
+
+[[package]]
 name = "dioxus-liveview"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca4f2850ec1a468c6f15b578c43218562d2309aadaf2b8bf17f54ce30e72f594"
 dependencies = [
  "axum",
- "dioxus-cli-config",
- "dioxus-core",
- "dioxus-devtools",
- "dioxus-document",
- "dioxus-history",
- "dioxus-html",
- "dioxus-interpreter-js",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
+ "dioxus-devtools 0.7.1",
+ "dioxus-document 0.7.1",
+ "dioxus-history 0.7.1",
+ "dioxus-html 0.7.1",
+ "dioxus-interpreter-js 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "rustc-hash 2.1.1",
  "serde",
  "serde_json",
···
 
 [[package]]
 name = "dioxus-logger"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "545961e752f6c8bf59c274951b3c8b18a106db6ad2f9e2035b29e1f2a3e899b1"
+dependencies = [
+ "console_error_panic_hook",
+ "dioxus-cli-config 0.6.3",
+ "tracing",
+ "tracing-subscriber",
+ "tracing-wasm",
+]
+
+[[package]]
+name = "dioxus-logger"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42237934c6a67f5ed9a8c37e47ca980ee7cfec9e783a9a1f8c2e36c8b96ae74b"
 dependencies = [
- "dioxus-cli-config",
+ "dioxus-cli-config 0.7.1",
  "tracing",
  "tracing-subscriber",
  "tracing-wasm",
···
 version = "0.0.1"
 source = "git+https://github.com/DioxusLabs/components#a15f329d1dc2bd76cd4030b27ecd70edb9fd8c6b"
 dependencies = [
- "dioxus",
+ "dioxus 0.7.1",
  "dioxus-time",
  "lazy-js-bundle 0.6.2",
  "num-integer",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdf1b95b7cafd07a2b39651ab2b146e4aa72acb0295cd52f422b7db5e2ab6eeb"
 dependencies = [
- "dioxus-cli-config",
- "dioxus-core",
- "dioxus-core-macro",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
+ "dioxus-core-macro 0.7.1",
  "dioxus-fullstack-core",
- "dioxus-history",
- "dioxus-hooks",
- "dioxus-html",
+ "dioxus-history 0.7.1",
+ "dioxus-hooks 0.7.1",
+ "dioxus-html 0.7.1",
  "dioxus-router-macro",
- "dioxus-signals",
+ "dioxus-signals 0.7.1",
  "percent-encoding",
  "rustversion",
  "tracing",
···
 
 [[package]]
 name = "dioxus-rsx"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eb588e05800b5a7eb90b2f40fca5bbd7626e823fb5e1ba21e011de649b45aa1"
+dependencies = [
+ "proc-macro2",
+ "proc-macro2-diagnostics",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "dioxus-rsx"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f026380dfda8b93ad995c0a90a62a17b8afeb246baff1b781a52c7b1b3ebd791"
···
  "bytes",
  "chrono",
  "ciborium",
- "dashmap",
- "dioxus-cli-config",
- "dioxus-core",
- "dioxus-core-macro",
- "dioxus-devtools",
- "dioxus-document",
+ "dashmap 6.1.0",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
+ "dioxus-core-macro 0.7.1",
+ "dioxus-devtools 0.7.1",
+ "dioxus-document 0.7.1",
  "dioxus-fullstack-core",
- "dioxus-history",
- "dioxus-hooks",
- "dioxus-html",
- "dioxus-interpreter-js",
- "dioxus-logger",
+ "dioxus-history 0.7.1",
+ "dioxus-hooks 0.7.1",
+ "dioxus-html 0.7.1",
+ "dioxus-interpreter-js 0.7.1",
+ "dioxus-logger 0.7.1",
  "dioxus-router",
- "dioxus-signals",
+ "dioxus-signals 0.7.1",
  "dioxus-ssr",
  "enumset",
  "futures",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "http",
  "http-body-util",
  "hyper",
···
  "rustc-hash 2.1.1",
  "serde",
  "serde_json",
- "serde_qs",
+ "serde_qs 0.15.0",
  "subsecond",
  "thiserror 2.0.17",
  "tokio",
···
 
 [[package]]
 name = "dioxus-signals"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10e032dbb3a2c0386ec8b8ee59bc20b5aeb67038147c855801237b45b13d72ac"
+dependencies = [
+ "dioxus-core 0.6.3",
+ "futures-channel",
+ "futures-util",
+ "generational-box 0.6.2",
+ "once_cell",
+ "parking_lot",
+ "rustc-hash 1.1.0",
+ "tracing",
+ "warnings",
+]
+
+[[package]]
+name = "dioxus-signals"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3895cc17ff5b43ada07743111be586e7a927ed7ec511457020e4235e13e63fe6"
 dependencies = [
- "dioxus-core",
+ "dioxus-core 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "parking_lot",
  "rustc-hash 2.1.1",
  "tracing",
···
 checksum = "592391fc30a77f94bc5a3385d1569052907e3b3cecb28099671b9d5801dee6c6"
 dependencies = [
  "askama_escape",
- "dioxus-core",
- "dioxus-core-types",
+ "dioxus-core 0.7.1",
+ "dioxus-core-types 0.7.1",
  "rustc-hash 2.1.1",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8521729ac35f362476ac4eb7d1c4ab79e7e92a0facfdea3ee978c0ddf7108d37"
 dependencies = [
- "dioxus-core",
- "dioxus-signals",
+ "dioxus-core 0.7.1",
+ "dioxus-signals 0.7.1",
  "dioxus-stores-macro",
 ]
 
···
 version = "0.7.0"
 source = "git+https://github.com/ealmloff/dioxus-std?branch=0.7#8c868ac1d60e3232e3f16f6195d6deb3c016de17"
 dependencies = [
- "dioxus",
+ "dioxus 0.7.1",
  "futures",
  "gloo-timers",
  "tokio",
···
 
 [[package]]
 name = "dioxus-web"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e7c12475c3d360058b8afe1b68eb6dfc9cbb7dcd760aed37c5f85c561c83ed1"
+dependencies = [
+ "async-trait",
+ "ciborium",
+ "dioxus-cli-config 0.6.3",
+ "dioxus-core 0.6.3",
+ "dioxus-core-types 0.6.2",
+ "dioxus-devtools 0.6.2",
+ "dioxus-document 0.6.3",
+ "dioxus-history 0.6.2",
+ "dioxus-html 0.6.3",
+ "dioxus-interpreter-js 0.6.2",
+ "dioxus-signals 0.6.3",
+ "futures-channel",
+ "futures-util",
+ "generational-box 0.6.2",
+ "js-sys",
+ "lazy-js-bundle 0.6.2",
+ "rustc-hash 1.1.0",
+ "serde",
+ "serde-wasm-bindgen 0.5.0",
+ "serde_json",
+ "tracing",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "dioxus-web"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76155ecd44535e7c096ec8c5aac4a945899e47567ead4869babdaa74f3f9bca0"
 dependencies = [
- "dioxus-cli-config",
- "dioxus-core",
- "dioxus-core-types",
- "dioxus-devtools",
- "dioxus-document",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core 0.7.1",
+ "dioxus-core-types 0.7.1",
+ "dioxus-devtools 0.7.1",
+ "dioxus-document 0.7.1",
  "dioxus-fullstack-core",
- "dioxus-history",
- "dioxus-html",
- "dioxus-interpreter-js",
- "dioxus-signals",
+ "dioxus-history 0.7.1",
+ "dioxus-html 0.7.1",
+ "dioxus-interpreter-js 0.7.1",
+ "dioxus-signals 0.7.1",
  "futures-channel",
  "futures-util",
- "generational-box",
+ "generational-box 0.7.1",
  "gloo-timers",
  "js-sys",
  "lazy-js-bundle 0.7.1",
···
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
+]
+
+[[package]]
+name = "dioxus_server_macro"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "371a5b21989a06b53c5092e977b3f75d0e60a65a4c15a2aa1d07014c3b2dda97"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "server_fn_macro",
+ "syn 2.0.110",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "generational-box"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a673cf4fb0ea6a91aa86c08695756dfe875277a912cdbf33db9a9f62d47ed82b"
+dependencies = [
+ "parking_lot",
+ "tracing",
+]
+
+[[package]]
+name = "generational-box"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3c1ae09dfd2d455484a54b56129b9821241c4b0e412227806b6c3730cd18a29"
···
 version = "0.9.2"
 dependencies = [
  "cid",
- "dashmap",
+ "dashmap 6.1.0",
  "heck 0.5.0",
  "inventory",
  "jacquard-common",
···
  "base64 0.22.1",
  "bytes",
  "chrono",
- "dashmap",
+ "dashmap 6.1.0",
  "elliptic-curve",
  "http",
  "jacquard-common",
···
 
 [[package]]
 name = "manganis"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "317af44b15e7605b85f04525449a3bb631753040156c9b318e6cba8a3ea4ef73"
+dependencies = [
+ "const-serialize 0.6.2",
+ "manganis-core 0.6.2",
+ "manganis-macro 0.6.2",
+]
+
+[[package]]
+name = "manganis"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "124f8f094eb75783b38209ce4d534b9617da4efac652802d9bafe05043a3ec95"
 dependencies = [
- "const-serialize",
- "manganis-core",
- "manganis-macro",
+ "const-serialize 0.7.1",
+ "manganis-core 0.7.1",
+ "manganis-macro 0.7.1",
+]
+
+[[package]]
+name = "manganis-core"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c38bee65cc725b2bba23b5dbb290f57c8be8fadbe2043fb7e2ce73022ea06519"
+dependencies = [
+ "const-serialize 0.6.2",
+ "dioxus-cli-config 0.6.3",
+ "dioxus-core-types 0.6.2",
+ "serde",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fbd1fb8c5aabcc54c6b02dbc968e1c89c28f3e543f2789ef9e3ce45dbdf5df"
 dependencies = [
- "const-serialize",
- "dioxus-cli-config",
- "dioxus-core-types",
+ "const-serialize 0.7.1",
+ "dioxus-cli-config 0.7.1",
+ "dioxus-core-types 0.7.1",
  "serde",
 ]
 
 [[package]]
 name = "manganis-macro"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f4f71310913c40174d9f0cfcbcb127dad0329ecdb3945678a120db22d3d065"
+dependencies = [
+ "dunce",
+ "manganis-core 0.6.2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "manganis-macro"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "45d6fec2a8249739bb30b53a08ecbb217f76096c08f1053f38ec3981ba424c11"
 dependencies = [
  "dunce",
  "macro-string",
- "manganis-core",
+ "manganis-core 0.7.1",
  "proc-macro2",
  "quote",
  "syn 2.0.110",
···
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
- "dashmap",
+ "dashmap 6.1.0",
  "smallvec",
  "tagptr",
  "triomphe",
···
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
- "dashmap",
+ "dashmap 6.1.0",
  "smallvec",
  "tagptr",
  "triomphe",
···
 
 [[package]]
 name = "serde-wasm-bindgen"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3b143e2833c57ab9ad3ea280d21fd34e285a42837aeb0ee301f4f41890fa00e"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "serde-wasm-bindgen"
 version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
···
  "itoa",
  "serde",
  "serde_core",
+]
+
+[[package]]
+name = "serde_qs"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0431a35568651e363364210c91983c1da5eb29404d9f0928b67d4ebcfa7d330c"
+dependencies = [
+ "percent-encoding",
+ "serde",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
···
 dependencies = [
  "base16ct",
  "serde",
+]
+
+[[package]]
+name = "server_fn"
+version = "0.6.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fae7a3038a32e5a34ba32c6c45eb4852f8affaf8b794ebfcd4b1099e2d62ebe"
+dependencies = [
+ "bytes",
+ "const_format",
+ "dashmap 5.5.3",
+ "futures",
+ "gloo-net",
+ "http",
+ "js-sys",
+ "once_cell",
+ "send_wrapper",
+ "serde",
+ "serde_json",
+ "serde_qs 0.12.0",
+ "server_fn_macro_default",
+ "thiserror 1.0.69",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "server_fn_macro"
+version = "0.6.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faaaf648c6967aef78177c0610478abb5a3455811f401f3c62d10ae9bd3901a1"
+dependencies = [
+ "const_format",
+ "convert_case 0.6.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "server_fn_macro_default"
+version = "0.6.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f2aa8119b558a17992e0ac1fd07f080099564f24532858811ce04f742542440"
+dependencies = [
+ "server_fn_macro",
+ "syn 2.0.110",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "tungstenite"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e2ce1e47ed2994fd43b04c8f618008d4cabdd5ee34027cf14f9d918edd9c8"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror 1.0.69",
+ "utf-8",
+]
+
+[[package]]
+name = "tungstenite"
 version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
···
  "base64 0.22.1",
  "chrono",
  "console_error_panic_hook",
- "dashmap",
- "dioxus",
+ "dashmap 6.1.0",
+ "dioxus 0.7.1",
+ "dioxus-free-icons",
  "dioxus-primitives",
  "dotenvy",
  "gloo-storage",
···
  "axum",
  "chrono",
  "clap",
- "dashmap",
+ "dashmap 6.1.0",
  "diesel",
  "diesel-async",
  "diesel_migrations",
···
 version = "0.1.0"
 dependencies = [
  "bitflags 2.10.0",
- "dashmap",
+ "dashmap 6.1.0",
  "http",
  "ignore",
  "insta",

Cargo.toml

···
 
 [profile.wasm-dev]
 inherits = "dev"
-opt-level = 1
-lto = true
 debug = true
 
 [profile.server-dev]
 inherits = "dev"
-lto = true
 debug = true
 
 [profile.android-dev]

crates/weaver-app/Cargo.toml

···
 edition = "2024"
 
 [features]
-default = ["web", "no-app-index"]
+default = ["web", "fullstack-server", "no-app-index"]
 # Fullstack mode with SSR and server functions
 fullstack-server = ["dioxus/fullstack"]
 wasm-split = ["dioxus/wasm-split"]
···
 base64 = "0.22"
 http = "1.3"
 reqwest = { version = "0.12", default-features = false, features = ["json"] }
+dioxus-free-icons = { version = "0.9", features = ["font-awesome-brands"] }
 
 # diesel = { version = "2.3",  features = ["sqlite", "returning_clauses_for_sqlite_3_35", "chrono", "serde_json"] }
 # diesel_migrations = { version = "2.3", features = ["sqlite"] }

crates/weaver-app/Dioxus.toml

···
 # HTML title tag content
 title = "Weaver"
 
+out_dir = "dist"
+asset_dir = "public"
+
 # include `assets` in web platform
 [web.resource]
 

crates/weaver-app/assets/styling/navbar.css

···
 
 .auth-button {
     align-self: flex-end;
+    background-color: var(--color-base);
 }
 
 .auth-handle {

crates/weaver-app/assets/styling/profile.css

···
 
 .profile-banner {
     max-width: 100%;
-    height: 200px;
+    height: 150px;
     overflow: hidden;
 }
 

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

···
 pub use state::AuthState;
 
 use crate::fetch::Fetcher;
-#[cfg(all(feature = "fullstack-server", feature = "server"))]
 use dioxus::prelude::*;
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
 use jacquard::oauth::types::OAuthClientMetadata;
···
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-pub async fn restore_session(_fetcher: Fetcher) -> Result<(), String> {
+pub async fn restore_session(
+    _fetcher: Fetcher,
+    _auth_state: Signal<AuthState>,
+) -> Result<(), String> {
     Ok(())
 }
 
 #[cfg(target_arch = "wasm32")]
-pub async fn restore_session(fetcher: Fetcher) -> Result<(), CapturedError> {
+pub async fn restore_session(
+    fetcher: Fetcher,
+    mut auth_state: Signal<AuthState>,
+) -> Result<(), CapturedError> {
     use dioxus::prelude::*;
     use gloo_storage::{LocalStorage, Storage};
     use jacquard::types::string::Did;
···
     let (restored_did, session_id) = session.session_info().await;
 
     // Update auth state
-    let mut auth_state = try_consume_context::<Signal<AuthState>>()
-        .ok_or(CapturedError::from_display("AuthState not in context"))?;
     auth_state
         .write()
         .set_authenticated(restored_did, session_id);

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

···
 #[component]
 pub fn Accordion(props: AccordionProps) -> Element {
     rsx! {
-        document::Link { rel: "stylesheet", href: asset!("./style.css") }
+        document::Link { rel: "stylesheet", href: asset!("./accordion.css") }
         accordion::Accordion {
             class: "accordion",
             id: props.id,

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

···
 #[component]
 pub fn Avatar(props: AvatarProps) -> Element {
     rsx! {
-        document::Link { rel: "stylesheet", href: asset!("./style.css") }
+        document::Link { rel: "stylesheet", href: asset!("./avatar.css") }
 
         avatar::Avatar {
             class: "avatar {props.size.to_class()}",

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

···
     children: Element,
 ) -> Element {
     rsx! {
-        document::Link { rel: "stylesheet", href: asset!("./style.css") }
+        document::Link { rel: "stylesheet", href: asset!("/assets/styling/button.css") }
 
         button {
             class: "button",

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

···
 #[component]
 pub fn DialogRoot(props: DialogRootProps) -> Element {
     rsx! {
-        document::Link { rel: "stylesheet", href: asset!("./style.css") }
+        document::Link { rel: "stylesheet", href: asset!("./dialog.css") }
         dialog::DialogRoot {
             class: "dialog-backdrop",
             id: props.id,

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

···
 use crate::blobcache::BlobCache;
 use crate::{
     components::avatar::{Avatar, AvatarImage},
-    data::{NotebookHandle, use_handle},
+    data::use_handle,
 };
 
 use crate::Route;
···
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
 ) -> Element {
+    tracing::debug!(
+        "EntryPage component rendering for ident: {:?}, book: {}, title: {}",
+        ident(),
+        book_title(),
+        title()
+    );
     rsx! {
         {std::iter::once(rsx! {Entry {ident, book_title, title}})}
     }
···
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
 ) -> Element {
+    tracing::debug!(
+        "Entry component rendering for ident: {:?}, book: {}, title: {}",
+        ident(),
+        book_title(),
+        title()
+    );
     // Use feature-gated hook for SSR support
     let entry = crate::data::use_entry_data(ident, book_title, title);
-    let handle = use_context::<NotebookHandle>();
     let fetcher = use_context::<crate::fetch::Fetcher>();
+    tracing::debug!("Entry component got entry data");
 
     // Handle blob caching when entry data is available
-    if let Ok(entry) = entry {
-        match &*entry.read() {
-            Some((book_entry_view, entry_record)) => {
-                if let Some(embeds) = &entry_record.embeds {
-                    if let Some(images) = &embeds.images {
-                        // Register blob mappings with service worker (client-side only)
-                        #[cfg(all(
-                            target_family = "wasm",
-                            target_os = "unknown",
-                            not(feature = "fullstack-server")
-                        ))]
-                        {
-                            let fetcher = fetcher.clone();
-                            let images = images.clone();
-                            spawn(async move {
-                                let _ = crate::service_worker::register_entry_blobs(
-                                    &ident(),
-                                    book_title().as_str(),
-                                    &images,
-                                    &fetcher,
-                                )
-                                .await;
-                            });
-                        }
+    match &*entry.read() {
+        Some((book_entry_view, entry_record)) => {
+            if let Some(embeds) = &entry_record.embeds {
+                if let Some(images) = &embeds.images {
+                    // Register blob mappings with service worker (client-side only)
+                    #[cfg(all(
+                        target_family = "wasm",
+                        target_os = "unknown",
+                        not(feature = "fullstack-server")
+                    ))]
+                    {
+                        let fetcher = fetcher.clone();
+                        let images = images.clone();
+                        spawn(async move {
+                            let _ = crate::service_worker::register_entry_blobs(
+                                &ident(),
+                                book_title().as_str(),
+                                &images,
+                                &fetcher,
+                            )
+                            .await;
+                        });
                     }
                 }
-                rsx! { EntryPageView {
-                    book_entry_view: book_entry_view.clone(),
-                    entry_record: entry_record.clone(),
-                    ident: handle.as_ref().unwrap().clone(),
-                    book_title: book_title()
-                } }
             }
-            _ => rsx! { p { "Loading..." } },
+            rsx! { EntryPageView {
+                book_entry_view: book_entry_view.clone(),
+                entry_record: entry_record.clone(),
+                ident: ident(),
+                book_title: book_title()
+            } }
         }
-    } else {
-        rsx! { p { "Loading..." } }
+        _ => rsx! { p { "Loading..." } },
     }
 }
 
 /// Full entry page with metadata, content, and navigation
 #[component]
 fn EntryPageView(
-    book_entry_view: BookEntryView<'static>,
-    entry_record: entry::Entry<'static>,
-    ident: AtIdentifier<'static>,
-    book_title: SmolStr,
+    book_entry_view: ReadSignal<BookEntryView<'static>>,
+    entry_record: ReadSignal<entry::Entry<'static>>,
+    ident: ReadSignal<AtIdentifier<'static>>,
+    book_title: ReadSignal<SmolStr>,
 ) -> Element {
     // Extract metadata
-    let entry_view = &book_entry_view.entry;
+    let entry_view = &book_entry_view().entry;
     let title = entry_view
         .title
         .as_ref()
···
 
         div { class: "entry-page-layout",
             // Left gutter with prev button
-            if let Some(ref prev) = book_entry_view.prev {
+            if let Some(ref prev) = book_entry_view().prev {
                 div { class: "nav-gutter nav-prev",
                     NavButton {
                         direction: "prev",
                         entry: prev.entry.clone(),
-                        ident: ident.clone(),
-                        book_title: book_title.clone()
+                        ident: ident(),
+                        book_title: book_title()
                     }
                 }
             }
···
                 // Metadata header
                 EntryMetadata {
                     entry_view: entry_view.clone(),
-                    ident: ident.clone(),
-                    created_at: entry_record.created_at.clone()
+                    created_at: entry_record().created_at.clone()
                 }
 
                 // Rendered markdown
-                EntryMarkdownDirect {
+                EntryMarkdown {
                     content: entry_record,
-                    ident: ident.clone()
+                    ident
                 }
             }
 
             // Right gutter with next button
-            if let Some(ref next) = book_entry_view.next {
+            if let Some(ref next) = book_entry_view().next {
                 div { class: "nav-gutter nav-next",
                     NavButton {
                         direction: "next",
                         entry: next.entry.clone(),
-                        ident: ident.clone(),
-                        book_title: book_title.clone()
+                        ident: ident(),
+                        book_title: book_title()
                     }
                 }
             }
···
     entry: BookEntryView<'static>,
     book_title: SmolStr,
     author_count: usize,
+    ident: AtIdentifier<'static>,
 ) -> Element {
     use crate::Route;
     use jacquard::from_data;
···
         .as_ref()
         .map(|t| t.as_ref())
         .unwrap_or("Untitled");
-
-    let ident = use_context::<NotebookHandle>();
     // Format date
     let formatted_date = entry_view
         .indexed_at
···
         div { class: "entry-card",
             Link {
                 to: Route::EntryPage {
-                    ident: ident.as_ref().unwrap().clone(),
+                    ident: ident,
                     book_title: book_title.clone(),
                     title: title.to_string().into()
                 },
···
                                 match &author.record.inner {
                                     ProfileDataViewInner::ProfileView(profile) => {
                                         let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
+                                         let handle = profile.handle.clone();
                                         rsx! {
                                             if let Some(ref avatar_url) = profile.avatar {
                                                 Avatar {
···
                                                 }
                                             }
                                             span { class: "author-name", "{display_name}" }
-                                            span { class: "meta-label", "@{ident.as_ref().unwrap()}" }
+                                            span { class: "meta-label", "@{handle}" }
                                         }
                                     }
                                     ProfileDataViewInner::ProfileViewDetailed(profile) => {
                                         let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
+                                         let handle = profile.handle.clone();
                                         rsx! {
                                             if let Some(ref avatar_url) = profile.avatar {
                                                 Avatar {
···
                                                 }
                                             }
                                             span { class: "author-name", "{display_name}" }
-                                            span { class: "meta-label", "@{ident.as_ref().unwrap()}" }
+                                            span { class: "meta-label", "@{handle}" }
                                         }
                                     }
                                     ProfileDataViewInner::TangledProfileView(profile) => {
···
 
 /// Metadata header showing title, authors, date, tags
 #[component]
-fn EntryMetadata(
-    entry_view: EntryView<'static>,
-    ident: AtIdentifier<'static>,
-    created_at: Datetime,
-) -> Element {
+fn EntryMetadata(entry_view: EntryView<'static>, created_at: Datetime) -> Element {
     let title = entry_view
         .title
         .as_ref()
···
                                 match &author.record.inner {
                                     ProfileDataViewInner::ProfileView(profile) => {
                                         let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
+                                        let handle = profile.handle.clone();
+
                                         rsx! {
                                             Link {
-                                                to: Route::RepositoryIndex { ident: ident.clone() },
+                                                to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
                                                 div { class: "entry-authors",
                                                     if let Some(ref avatar_url) = profile.avatar {
                                                         Avatar {
···
                                                         }
                                                     }
                                                     span { class: "author-name", "{display_name}" }
-                                                    span { class: "meta-label", "@{ident}" }
+                                                    span { class: "meta-label", "@{handle}" }
                                                 }
                                             }
                                         }
                                     }
                                     ProfileDataViewInner::ProfileViewDetailed(profile) => {
                                         let display_name = profile.display_name.as_ref().map(|n| n.as_ref()).unwrap_or("Unknown");
+                                        let handle = profile.handle.clone();
                                         rsx! {
                                             Link {
-                                                to: Route::RepositoryIndex { ident: ident.clone() },
+                                                to: Route::RepositoryIndex { ident: AtIdentifier::Handle(handle.clone()) },
                                                 div { class: "entry-authors",
                                                     if let Some(ref avatar_url) = profile.avatar {
                                                         Avatar {
···
                                                         }
                                                     }
                                                     span { class: "author-name", "{display_name}" }
-                                                    span { class: "meta-label", "@{ident}" }
+                                                    span { class: "meta-label", "@{handle}" }
                                                 }
                                             }
                                         }
···
 pub struct EntryMarkdownProps {
     #[props(default)]
     id: Signal<String>,
-    #[props(default)]
+    #[props(default = use_signal(||"entry".to_string()))]
     class: Signal<String>,
     content: ReadSignal<entry::Entry<'static>>,
     ident: ReadSignal<AtIdentifier<'static>>,
 }
 
 /// Render some text as markdown.
-#[allow(unused)]
 pub fn EntryMarkdown(props: EntryMarkdownProps) -> Element {
-    let processed = crate::data::use_rendered_markdown(
-        props.content,
-        props.ident,
-    )?;
+    let processed = crate::data::use_rendered_markdown(props.content, props.ident);
 
     match &*processed.read() {
-        Some(Some(html_buf)) => rsx! {
+        Some(html_buf) => rsx! {
             div {
                 id: "{&*props.id.read()}",
                 class: "{&*props.class.read()}",
···
     // Use feature-gated hook for SSR support
     let content = use_signal(|| content);
     let ident = use_signal(|| ident);
-    let processed = crate::data::use_rendered_markdown(content.into(), ident.into())?;
+    let processed = crate::data::use_rendered_markdown(content.into(), ident.into());
 
     match &*processed.read() {
-        Some(Some(html_buf)) => rsx! {
+        Some(html_buf) => rsx! {
             div {
                 id: "{id}",
                 class: "{class}",

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

···
 
 #[component]
 pub fn Repository(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
-    // Fetch notebooks for this specific DID with SSR support
-    let notebooks = data::use_notebooks_for_did(ident)?;
-    use_context_provider(|| notebooks);
+    tracing::debug!("Repository component rendering for ident: {:?}", ident());
+    // Fetch notebooks for this specific DID with SSR support;
+    tracing::debug!("Repository component context set up");
+
     rsx! {
         div {
             Outlet::<Route> {}
···
     }
 }
 
-pub fn use_repo_notebook_context()
--> Option<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>> {
-    try_use_context::<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>>()
-}
-
 #[component]
 pub fn RepositoryIndex(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
+    tracing::debug!(
+        "RepositoryIndex component rendering for ident: {:?}",
+        ident()
+    );
     use crate::components::ProfileDisplay;
-    let notebooks = use_repo_notebook_context();
-    let profile = crate::data::use_profile_data(ident)?;
+    let notebooks = data::use_notebooks_for_did(ident);
+    let profile = crate::data::use_profile_data(ident);
+    tracing::debug!("RepositoryIndex got profile and notebooks");
     rsx! {
         document::Stylesheet { href: NOTEBOOK_CARD_CSS }
 
         div { class: "repository-layout",
             // Profile sidebar (desktop) / header (mobile)
             aside { class: "repository-sidebar",
-                ProfileDisplay { profile }
+                ProfileDisplay { profile, notebooks }
             }
 
             // Main content area
             main { class: "repository-main",
                 div { class: "notebooks-list",
-                   if let Some(notebooks) = notebooks {
-                       match &*notebooks.read() {
-                           Some(notebook_list) => rsx! {
-                               for notebook in notebook_list.iter() {
-                                   {
-                                       let view = &notebook.0;
-                                       let entries = &notebook.1;
-                                       rsx! {
-                                           div {
-                                               key: "{view.cid}",
-                                               NotebookCard {
-                                                   notebook: view.clone(),
-                                                   entry_refs: entries.clone()
-                                               }
-                                           }
-                                       }
-                                   }
-                               }
-                           },
-                           None => rsx! {
-                               div { "Loading notebooks..." }
-                           }
-                       }
-                   }
+                    match &*notebooks.read() {
+                        Some(notebook_list) => rsx! {
+                            for notebook in notebook_list.iter() {
+                                {
+                                    let view = &notebook.0;
+                                    let entries = &notebook.1;
+                                    rsx! {
+                                        div {
+                                            key: "{view.cid}",
+                                            NotebookCard {
+                                                notebook: view.clone(),
+                                                entry_refs: entries.clone()
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        None => rsx! {
+                            div { "Loading notebooks..." }
+                        }
+                    }
                 }
             }
         }

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

···
     children: Element,
 ) -> Element {
     rsx! {
-        document::Link { rel: "stylesheet", href: asset!("./style.css") }
+        document::Link { rel: "stylesheet", href: asset!("./input-style.css") }
         input {
             class: "input",
             oninput: move |e| _ = oninput.map(|callback| callback(e)),

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

···
 #![allow(non_snake_case)]
 
-use crate::{
-    components::avatar::{Avatar, AvatarImage},
-    data::NotebookHandle,
-};
+use crate::components::avatar::{Avatar, AvatarImage};
 use dioxus::prelude::*;
 use weaver_api::sh_weaver::notebook::NotebookView;
 

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

···
 use crate::components::{
     BskyIcon, TangledIcon,
     avatar::{Avatar, AvatarImage},
-    identity::use_repo_notebook_context,
 };
 use dioxus::prelude::*;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
···
 const PROFILE_CSS: Asset = asset!("/assets/styling/profile.css");
 
 #[component]
-pub fn ProfileDisplay(profile: Memo<Option<ProfileDataView<'static>>>) -> Element {
-    let notebooks = use_repo_notebook_context();
+pub fn ProfileDisplay(
+    profile: Memo<Option<ProfileDataView<'static>>>,
+    notebooks: Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>,
+) -> Element {
     match &*profile.read() {
         Some(profile_view) => {
             let profile_view = Arc::new(profile_view.clone());
···
                         div {
                             class: "profile-extras",
                             // Stats
-                            ProfileStats { notebooks: notebooks.unwrap() }
+                            ProfileStats { notebooks: notebooks }
 
                             // Links
                             ProfileLinks { profile_view }

crates/weaver-app/src/data.rs

···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
-) -> Result<Memo<Option<(BookEntryView<'static>, Entry<'static>)>>, RenderError> {
+) -> Memo<Option<(BookEntryView<'static>, Entry<'static>)>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
     let res = use_server_future(move || {
···
                 None
             }
         }
-    })?; // Handle the Result first to avoid calling use_memo in a closure
-    Ok(use_memo(move || {
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some((ev, e))) = &*res.read() {
             use jacquard::from_json_value;
 
···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
     title: ReadSignal<SmolStr>,
-) -> Result<Memo<Option<(BookEntryView<'static>, Entry<'static>)>>, RenderError> {
+) -> Memo<Option<(BookEntryView<'static>, Entry<'static>)>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
         async move {
-            fetcher
+            if let Some(entry) = fetcher
                 .get_entry(ident(), book_title(), title())
                 .await
                 .ok()
                 .flatten()
-                .map(|arc| {
-                    (
-                        serde_json::to_value(arc.0.clone()).unwrap(),
-                        serde_json::to_value(arc.1.clone()).unwrap(),
-                    )
-                })
+            {
+                let (_book_entry_view, entry_record) = (&entry.0, &entry.1);
+                if let Some(embeds) = &entry_record.embeds {
+                    if let Some(images) = &embeds.images {
+                        #[cfg(all(
+                            target_family = "wasm",
+                            target_os = "unknown",
+                            not(feature = "fullstack-server")
+                        ))]
+                        {
+                            let _ = crate::service_worker::register_entry_blobs(
+                                &ident(),
+                                book_title().as_str(),
+                                images,
+                                &fetcher,
+                            )
+                            .await;
+                        }
+                    }
+                }
+                Some((
+                    serde_json::to_value(entry.0.clone()).unwrap(),
+                    serde_json::to_value(entry.1.clone()).unwrap(),
+                ))
+            } else {
+                None
+            }
         }
     });
-    res.suspend()?;
-    Ok(use_memo(move || {
+    use_memo(move || {
         if let Some(Some((ev, e))) = &*res.read() {
             use jacquard::from_json_value;
 
···
         } else {
             None
         }
-    }))
+    })
 }
 
 pub fn use_get_handle(did: Did<'static>) -> AtIdentifier<'static> {
     let ident = use_signal(use_reactive!(|did| AtIdentifier::Did(did.clone())));
-    use_handle(ident.into())
-        .read()
-        .as_ref()
-        .unwrap_or(&Ok(ident.read().clone()))
-        .as_ref()
-        .unwrap()
-        .clone()
+    use_handle(ident.into()).read().clone()
+}
+
+#[cfg(feature = "fullstack-server")]
+pub fn use_load_handle(
+    ident: Option<AtIdentifier<'static>>,
+) -> ReadSignal<Option<AtIdentifier<'static>>> {
+    let ident = use_signal(use_reactive!(|ident| ident.clone()));
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let fetcher = fetcher.clone();
+    let res = use_server_future(move || {
+        let client = fetcher.get_client();
+        async move {
+            if let Some(ident) = &*ident.read() {
+                use jacquard::smol_str::ToSmolStr;
+
+                client
+                    .resolve_ident_owned(ident)
+                    .await
+                    .map(|doc| doc.handles().first().map(|h| h.to_smolstr()))
+                    .unwrap_or(Some(ident.to_smolstr()))
+            } else {
+                None
+            }
+        }
+    });
+
+    use_memo(use_reactive!(|res| {
+        if let Ok(res) = res {
+            if let Some(value) = &*res.read() {
+                if let Some(handle) = value {
+                    AtIdentifier::new_owned(handle.clone()).ok()
+                } else {
+                    ident.read().clone()
+                }
+            } else {
+                ident.read().clone()
+            }
+        } else {
+            ident.read().clone()
+        }
+    }))
+    .into()
 }
 
-pub fn use_handle(
-    ident: ReadSignal<AtIdentifier<'static>>,
-) -> Resource<Result<AtIdentifier<'static>, IdentityError>> {
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_load_handle(
+    ident: Option<AtIdentifier<'static>>,
+) -> ReadSignal<Option<AtIdentifier<'static>>> {
+    let ident = use_signal(use_reactive!(|ident| ident.clone()));
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let fetcher = fetcher.clone();
+    let res = use_resource(move || {
+        let client = fetcher.get_client();
+        async move {
+            if let Some(ident) = &*ident.read() {
+                client
+                    .resolve_ident_owned(ident)
+                    .await
+                    .map(|doc| {
+                        doc.handles()
+                            .first()
+                            .map(|h| AtIdentifier::Handle(h.clone()).into_static())
+                    })
+                    .unwrap_or(Some(ident.clone()))
+            } else {
+                None
+            }
+        }
+    });
+
+    if let Ok(ident) = res.suspend() {
+        ident.into()
+    } else {
+        ident.into()
+    }
+}
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_handle(ident: ReadSignal<AtIdentifier<'static>>) -> ReadSignal<AtIdentifier<'static>> {
+    let old_ident = ident.read().clone();
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
-    use_resource(move || {
+    let res = use_resource(move || {
         let client = fetcher.get_client();
+        let old_ident = old_ident.clone();
         async move {
             client
                 .resolve_ident_owned(&*ident.read())
···
                         .first()
                         .map(|h| AtIdentifier::Handle(h.clone()).into_static())
                 })
-                .map(|h| h.ok_or(IdentityError::invalid_well_known()))?
+                .ok()
+                .flatten()
+                .unwrap_or(old_ident)
         }
-    })
+    });
+    if let Ok(ident) = res.suspend() {
+        ident.into()
+    } else {
+        ident
+    }
 }
+#[cfg(feature = "fullstack-server")]
+pub fn use_handle(ident: ReadSignal<AtIdentifier<'static>>) -> ReadSignal<AtIdentifier<'static>> {
+    let old_ident = ident.read().clone();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let fetcher = fetcher.clone();
+    let res = use_server_future(move || {
+        let client = fetcher.get_client();
+        let old_ident = old_ident.clone();
+        async move {
+            use jacquard::smol_str::ToSmolStr;
 
-#[derive(Clone, PartialEq, Eq)]
-pub struct NotebookHandle(pub Arc<Option<AtIdentifier<'static>>>);
+            client
+                .resolve_ident_owned(&*ident.read())
+                .await
+                .map(|doc| {
+                    use jacquard::smol_str::ToSmolStr;
 
-impl NotebookHandle {
-    pub fn as_ref(&self) -> Option<&AtIdentifier<'static>> {
-        self.0.as_ref().as_ref()
-    }
-}
+                    doc.handles().first().map(|h| h.to_smolstr())
+                })
+                .ok()
+                .flatten()
+                .unwrap_or(old_ident.to_smolstr())
+        }
+    });
 
-pub fn use_notebook_handle(ident: Signal<Option<AtIdentifier<'static>>>) -> NotebookHandle {
-    let ident = if let Some(ident) = &*ident.read() {
-        let _ident = Signal::new(ident.clone());
-        if let Some(Ok(handle)) = &*use_handle(_ident.into()).read() {
-            Some(handle.clone())
+    use_memo(use_reactive!(|res| {
+        if let Ok(res) = res {
+            if let Some(value) = &*res.read() {
+                AtIdentifier::new_owned(value).unwrap()
+            } else {
+                ident.read().clone()
+            }
         } else {
-            Some(ident.clone())
+            ident.read().clone()
         }
-    } else {
-        ident.read().clone()
-    };
-    use_context_provider(|| NotebookHandle(Arc::new(ident)))
+    }))
+    .into()
 }
 
 /// Hook to render markdown with SSR support.
···
 pub fn use_rendered_markdown(
     content: ReadSignal<Entry<'static>>,
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Result<Resource<Option<String>>, RenderError> {
+) -> Memo<Option<String>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    Ok(use_server_future(move || {
+    let res = use_server_future(move || {
         let client = fetcher.get_client();
         async move {
             let did = match ident() {
···
             };
             Some(render_markdown_impl(content(), did).await)
         }
-    })?)
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
+        if let Some(Some(value)) = &*res.read() {
+            Some(value.clone())
+        } else {
+            None
+        }
+    }))
 }
 
 /// Hook to render markdown client-side only (no SSR).
···
 pub fn use_rendered_markdown(
     content: ReadSignal<Entry<'static>>,
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Result<Resource<Option<String>>, RenderError> {
+) -> Memo<Option<String>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
-    Ok(use_resource(move || {
+    let res = use_resource(move || {
         let client = fetcher.get_client();
         async move {
             let did = match ident() {
···
             };
             Some(render_markdown_impl(content(), did).await)
         }
-    }))
+    });
+    use_memo(move || {
+        if let Some(Some(value)) = &*res.read() {
+            Some(value.clone())
+        } else {
+            None
+        }
+    })
 }
 
 /// Internal implementation of markdown rendering.
···
 #[cfg(feature = "fullstack-server")]
 pub fn use_profile_data(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Result<Memo<Option<ProfileDataView<'static>>>, RenderError> {
+) -> Memo<Option<ProfileDataView<'static>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
         async move {
-            fetcher
+            tracing::debug!("use_profile_data server future STARTED for {:?}", ident());
+            let result = fetcher
                 .fetch_profile(&ident())
                 .await
                 .ok()
                 .map(|arc| serde_json::to_value(&*arc).ok())
-                .flatten()
+                .flatten();
+            tracing::debug!("use_profile_data server future COMPLETED for {:?}", ident());
+            result
         }
-    })?;
-    Ok(use_memo(move || {
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<ProfileDataView>(value.clone()).ok()
         } else {
···
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_profile_data(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Result<Memo<Option<ProfileDataView<'static>>>, RenderError> {
+) -> Memo<Option<ProfileDataView<'static>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    res.suspend()?;
-    Ok(use_memo(move || {
+    use_memo(move || {
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<ProfileDataView>(value.clone()).ok()
         } else {
             None
         }
-    }))
+    })
 }
 
 /// Fetches notebooks for a specific DID
 #[cfg(feature = "fullstack-server")]
 pub fn use_notebooks_for_did(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+) -> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
                 })
                 .flatten()
         }
-    })?;
-    Ok(use_memo(move || {
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_notebooks_for_did(
     ident: ReadSignal<AtIdentifier<'static>>,
-) -> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+) -> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    res.suspend()?;
-    Ok(use_memo(move || {
+    use_memo(move || {
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    }))
+    })
 }
 
 /// Fetches notebooks from UFOS with SSR support in fullstack mode
 #[cfg(feature = "fullstack-server")]
 pub fn use_notebooks_from_ufos()
--> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+-> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
                 })
                 .flatten()
         }
-    })?;
-    Ok(use_memo(move || {
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
 /// Fetches notebooks from UFOS client-side only (no SSR)
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_notebooks_from_ufos()
--> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+-> Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    res.suspend()?;
-    Ok(use_memo(move || {
+    use_memo(move || {
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
         } else {
             None
         }
-    }))
+    })
 }
 
 /// Fetches notebook metadata with SSR support in fullstack mode
···
 pub fn use_notebook(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Result<Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>, RenderError> {
+) -> Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
                 .map(|arc| serde_json::to_value(arc.as_ref()).ok())
                 .flatten()
         }
-    })?;
-    Ok(use_memo(move || {
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
         } else {
···
 pub fn use_notebook(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Result<Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>, RenderError> {
+) -> Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    res.suspend()?;
-    Ok(use_memo(move || {
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some(value)) = &*res.read() {
             jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
         } else {
···
 pub fn use_notebook_entries(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Result<Memo<Option<Vec<BookEntryView<'static>>>>, RenderError> {
+) -> Memo<Option<Vec<BookEntryView<'static>>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
                 })
                 .flatten()
         }
-    })?;
-    res.suspend()?;
-    Ok(use_memo(move || {
+    });
+    use_memo(use_reactive!(|res| {
+        let res = res.ok()?;
         if let Some(Some(values)) = &*res.read() {
             values
                 .iter()
···
 pub fn use_notebook_entries(
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
-) -> Result<Memo<Option<Vec<BookEntryView<'static>>>>, RenderError> {
+) -> Memo<Option<Vec<BookEntryView<'static>>>> {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let r = use_resource(move || {
         let fetcher = fetcher.clone();
···
                 .flatten()
         }
     });
-    r.suspend()?;
-    Ok(use_memo(move || r.read().as_ref().and_then(|v| v.clone())))
+    use_memo(move || r.read().as_ref().and_then(|v| v.clone()))
 }
 
 #[cfg(feature = "fullstack-server")]

crates/weaver-app/src/env.rs

···
 // This file is automatically generated by build.rs
 
 #[allow(unused)]
-pub const WEAVER_APP_ENV: &'static str = "prod";
+pub const WEAVER_APP_ENV: &'static str = "dev";
 #[allow(unused)]
-pub const WEAVER_APP_HOST: &'static str = "https://alpha.weaver.sh";
+pub const WEAVER_APP_HOST: &'static str = "http://localhost";
 #[allow(unused)]
-pub const WEAVER_APP_DOMAIN: &'static str = "https://alpha.weaver.sh";
+pub const WEAVER_APP_DOMAIN: &'static str = "";
 #[allow(unused)]
 pub const WEAVER_PORT: &'static str = "8080";
 #[allow(unused)]

crates/weaver-app/src/main.rs

···
         use std::sync::Arc;
 
         #[cfg(not(feature = "fullstack-server"))]
-        let router = {
-            axum::Router::new()
-                .route("/sw.js", get(serve_sw))
-                .merge(dioxus::server::router(App))
-        };
+        let router = { axum::Router::new().merge(dioxus::server::router(App)) };
 
         #[cfg(feature = "fullstack-server")]
         let router = {
···
     #[cfg(not(feature = "server"))]
     dioxus::launch(App);
 }
+const THEME_DEFAULTS_CSS: Asset = asset!("/assets/styling/theme-defaults.css");
 
 #[component]
 fn App() -> Element {
+    tracing::debug!("App component rendering");
+    #[allow(unused)]
     let fetcher = use_context_provider(|| {
         fetch::Fetcher::new(OAuthClient::new(
             AuthStore::new(),
             ClientData::new_public(CONFIG.oauth.clone()),
         ))
     });
-    use_context_provider(|| Signal::new(AuthState::default()));
-    use_effect(move || {
+    let auth_state = use_signal(|| AuthState::default());
+    #[allow(unused)]
+    let auth_state = use_context_provider(|| auth_state);
+    #[cfg(all(
+        target_family = "wasm",
+        target_os = "unknown",
+        feature = "fullstack-server"
+    ))]
+    {
         let fetcher = fetcher.clone();
-        spawn(async move {
-            if let Err(e) = auth::restore_session(fetcher).await {
-                tracing::debug!("Session restoration failed: {}", e);
+        use_future(move || {
+            let fetcher = fetcher.clone();
+            async move {
+                if let Err(e) = auth::restore_session(fetcher, auth_state).await {
+                    tracing::debug!("Session restoration failed: {}", e);
+                }
             }
         });
-    });
+    }
 
     #[cfg(all(
         target_family = "wasm",
         target_os = "unknown",
         not(feature = "fullstack-server")
     ))]
-    spawn(async move {
-        let _ = service_worker::register_service_worker().await;
-    });
+    {
+        let fetcher = fetcher.clone();
+        use_future(move || {
+            let fetcher = fetcher.clone();
+            async move {
+                if let Err(e) = auth::restore_session(fetcher, auth_state).await {
+                    tracing::debug!("Session restoration failed: {}", e);
+                }
+            }
+        });
+    }
+
+    #[cfg(all(
+        target_family = "wasm",
+        target_os = "unknown",
+        not(feature = "fullstack-server")
+    ))]
+    {
+        use_effect(move || {
+            let fetcher = fetcher.clone();
+            spawn(async move {
+                tracing::info!("Registering service worker");
+                let _ = service_worker::register_service_worker().await;
+            });
+        });
+    }
 
     rsx! {
         document::Link { rel: "icon", href: FAVICON }
···
         document::Link { rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&family=IBM+Plex+Sans:ital,wght@0,100..700;1,100..700&family=IBM+Plex+Serif:ital,wght@0,200;0,300;0,400;0,500;0,600;0,700;1,200;1,300;1,400;1,500;1,600;1,700&display=swap" }
         document::Link { rel: "preconnect", href: "https://fonts.googleapis.com" }
         document::Link { rel: "preconnect", href: "https://fonts.gstatic.com" }
+
+        document::Link { rel: "stylesheet", href: THEME_DEFAULTS_CSS }
         Router::<Route> {}
     }
 }
···
 fn ErrorLayout() -> Element {
     rsx! {
         ErrorBoundary {
-            handle_error: move |err: ErrorContext| {
+            handle_error: move |_err: ErrorContext| {
                 #[cfg(feature = "fullstack-server")]
                 {
-                    let http_error = FullstackContext::commit_error_status(err.error().unwrap());
+                    let http_error = FullstackContext::commit_error_status(_err.error().unwrap());
                     match http_error.status {
                         StatusCode::NOT_FOUND => rsx! { div { "404 - Page not found" } },
                         _ => rsx! { div { "An unknown error occurred" } },

crates/weaver-app/src/service_worker.rs

···
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("no window"))?;
     let navigator = window.navigator();
     let sw_container = navigator.service_worker();
-
+    tracing::debug!("Registering service worker");
     let promise = sw_container.register("/sw.js");
     JsFuture::from(promise).await?;
+    tracing::debug!("Service worker registered");
 
     Ok(())
 }
···
     use jacquard::prelude::IdentityResolver;
     use std::collections::HashMap;
 
+    tracing::debug!("registering blobs for {}", book_title);
     let mut blob_mappings = HashMap::new();
 
     // Resolve DID and PDS URL
···
                 blob_mappings.insert(name.as_ref().to_string(), blob_url);
             }
         }
+    }
 
-        // Send mappings to service worker
-        if !blob_mappings.is_empty() {
-            send_blob_mappings(book_title, blob_mappings)?;
-        }
+    // Send mappings to service worker
+    if !blob_mappings.is_empty() {
+        send_blob_mappings(book_title, blob_mappings)?;
     }
+    //}
 
     Ok(())
 }
···
     let navigator = window.navigator();
     let sw_container = navigator.service_worker();
 
+    tracing::debug!("sending blob mappings for {}", notebook);
     let controller = sw_container
         .controller()
         .ok_or_else(|| JsValue::from_str("no service worker controller"))?;
···
     js_sys::Reflect::set(&msg, &"blobs".into(), &blobs_obj)?;
 
     controller.post_message(&msg)?;
+    tracing::debug!("sent blob mappings for {}", notebook);
 
     Ok(())
 }
···
 }
 
 // #[used]
-// static BINDINGS_JS: Asset = asset!("/assets/sw.js", AssetOptions::js().with_hash_suffix(false));
+// static BINDINGS_JS: Asset = asset!(
+//     "/sw.js",
+//     AssetOptions::js()
+//         .with_hash_suffix(false)
+//         .with_minify(false)
+//         .with_preload(true)
+// );

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

···
 #[component]
 pub fn Home() -> Element {
     // Fetch notebooks from UFOS with SSR support
-    let notebooks = data::use_notebooks_from_ufos()?;
+    let notebooks = data::use_notebooks_from_ufos();
     let navigator = use_navigator();
     let mut uri_input = use_signal(|| String::new());
 
···
         let input_uri = uri_input.read().clone();
         if !input_uri.is_empty() {
             if let Ok(parsed) = AtUri::new(&input_uri) {
-                navigator.push(Route::RecordPage {
-                    uri: vec![parsed.to_string()],
-                });
+                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, parsed);
+                navigator.push(link);
             }
         }
     };

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

···
 use crate::Route;
+use crate::auth::AuthState;
 use crate::components::button::{Button, ButtonVariant};
 use crate::components::login::LoginModal;
-use crate::data::{use_get_handle, use_notebook_handle};
+use crate::data::{use_get_handle, use_load_handle};
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
-use jacquard::types::did::Did;
 
-const THEME_DEFAULTS_CSS: Asset = asset!("/assets/styling/theme-defaults.css");
 const NAVBAR_CSS: Asset = asset!("/assets/styling/navbar.css");
 
 /// The Navbar component that will be rendered on all pages of our app since every page is under the layout.
···
 /// routes will be rendered under the outlet inside this component
 #[component]
 pub fn Navbar() -> Element {
+    tracing::debug!("Navbar component rendering");
     let route = use_route::<Route>();
+    tracing::debug!("Route: {:?}", route);
 
-    let route_handle = use_signal(|| match &route {
+    let mut auth_state = use_context::<Signal<crate::auth::AuthState>>();
+    let route_handle = use_load_handle(match &route {
         Route::EntryPage { ident, .. } => Some(ident.clone()),
         Route::RepositoryIndex { ident } => Some(ident.clone()),
         Route::NotebookIndex { ident, .. } => Some(ident.clone()),
         _ => None,
     });
-    let notebook_handle = use_notebook_handle(route_handle);
+    let fetcher = use_context::<Fetcher>();
+    let mut show_login_modal = use_signal(|| false);
+
+    tracing::debug!("Navbar got route_handle: {:?}", route_handle);
 
     rsx! {
-        document::Link { rel: "stylesheet", href: THEME_DEFAULTS_CSS }
         document::Link { rel: "stylesheet", href: NAVBAR_CSS }
-
+        document::Link { rel: "stylesheet", href: asset!("/assets/styling/button.css") }
         div {
             id: "navbar",
             nav { class: "breadcrumbs",
···
 
                 // Show repository breadcrumb if we're on a repository page
                 match route {
-                    Route::RepositoryIndex { .. } => {
-                        let handle = notebook_handle.as_ref().unwrap();
+                    Route::RepositoryIndex { ident } => {
+                        let route_handle = route_handle.read().clone();
+                        let handle = route_handle.unwrap_or(ident.clone());
                         rsx! {
                             span { class: "breadcrumb-separator", " > " }
                             span { class: "breadcrumb breadcrumb-current", "@{handle}" }
                         }
                     },
                     Route::NotebookIndex { ident, book_title } => {
-                        let handle = notebook_handle.as_ref().unwrap();
+                        let route_handle = route_handle.read().clone();
+                        let handle = route_handle.unwrap_or(ident.clone());
                         rsx! {
                             span { class: "breadcrumb-separator", " > " }
                             Link {
···
                         }
                     },
                     Route::EntryPage { ident, book_title, .. } => {
-                        let handle = notebook_handle.as_ref().unwrap();
+                        let route_handle = route_handle.read().clone();
+                        let handle = route_handle.unwrap_or(ident.clone());
                         rsx! {
                             span { class: "breadcrumb-separator", " > " }
                             Link {
···
                     _ => rsx! {}
                 }
             }
-            LoginButton {}
-
-        }
-
-        Outlet::<Route> {}
-    }
-}
-
-#[component]
-fn LoginButton() -> Element {
-    let fetcher = use_context::<Fetcher>();
-    let mut show_login_modal = use_signal(|| false);
-    let mut auth_state = use_context::<Signal<crate::auth::AuthState>>();
-    let did_signal = use_signal(|| auth_state.read().did.clone());
-    if let Some(did) = &*did_signal.read() {
-        rsx! {
-            Button {
-                variant: ButtonVariant::Ghost,
-                onclick: move |_| {
-                    let fetcher = fetcher.clone();
-                    auth_state.write().clear();
-                    async move {
-                        fetcher.downgrade_to_unauthenticated().await;
+            if auth_state.read().is_authenticated() {
+                if let Some(did) = &auth_state.read().did {
+                    Button {
+                        variant: ButtonVariant::Ghost,
+                        onclick: move |_| {
+                            let fetcher = fetcher.clone();
+                            auth_state.write().clear();
+                            async move {
+                                fetcher.downgrade_to_unauthenticated().await;
+                            }
+                        },
+                        span { class: "auth-handle", "@{use_get_handle(did.clone())}" }
+                    }
+                }
+            } else {
+                div {
+                    class: "auth-button",
+                    Button {
+                        variant: ButtonVariant::Ghost,
+                        onclick: move |_| show_login_modal.set(true),
+                        span { class: "auth-handle", "Sign In" }
                     }
-                },
-                span { class: "auth-handle", "@{use_get_handle(did.clone())}" }
-            }
-            LoginModal {
-                open: show_login_modal
-            }
-        }
-    } else {
-        rsx! {
-            div {
-                class: "auth-button",
-                Button {
-                    variant: ButtonVariant::Ghost,
-                    onclick: move |_| show_login_modal.set(true),
-                    span { class: "auth-handle", "Sign In" }
+
                 }
-            }
-            LoginModal {
-                open: show_login_modal
+                LoginModal {
+                    open: show_login_modal
+                }
             }
         }
+
+        Outlet::<Route> {}
     }
 }

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

···
 /// re-run and the rendered HTML will be updated.
 #[component]
 pub fn Notebook(ident: ReadSignal<AtIdentifier<'static>>, book_title: SmolStr) -> Element {
+    tracing::debug!(
+        "Notebook component rendering for ident: {:?}, book: {}",
+        ident(),
+        book_title
+    );
     rsx! {
         NotebookCss { ident: ident.to_smolstr(), notebook: book_title }
         Outlet::<Route> {}
···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
 ) -> Element {
+    tracing::debug!(
+        "NotebookIndex component rendering for ident: {:?}, book: {}",
+        ident(),
+        book_title()
+    );
     // Fetch full notebook metadata with SSR support
     // IMPORTANT: Call ALL hooks before any ? early returns to maintain hook order
     let notebook_data = data::use_notebook(ident, book_title);
     let entries_resource = data::use_notebook_entries(ident, book_title);
-
-    // Now check for errors
-    let notebook_data = notebook_data?;
-    let entries_resource = entries_resource?;
+    tracing::debug!("NotebookIndex got notebook data and entries");
 
     rsx! {
         document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
···
                                     EntryCard {
                                         entry: entry.clone(),
                                         book_title: book_title(),
-                                        author_count
+                                        author_count,
+                                        ident: ident(),
                                     }
                                 }
                             }

crates/weaver-common/src/agent.rs

···
                         AgentError::from(ClientError::invalid_request("Invalid weaver profile URI"))
                     },
                 )?;
-            let weaver_future = async {
-                if let Ok(weaver_record) = self.fetch_record(&weaver_uri).await {
-                    // Convert blobs to CDN URLs
-                    let avatar = weaver_record
-                        .value
-                        .avatar
-                        .as_ref()
-                        .map(|blob| {
-                            let cid = blob.blob().cid();
-                            jacquard::types::string::Uri::new_owned(format!(
-                                "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
-                                did, cid
-                            ))
-                        })
-                        .transpose()
-                        .map_err(|_| {
-                            AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
-                        })?;
-                    let banner = weaver_record
-                        .value
-                        .banner
-                        .as_ref()
-                        .map(|blob| {
-                            let cid = blob.blob().cid();
-                            jacquard::types::string::Uri::new_owned(format!(
-                                "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
-                                did, cid
-                            ))
-                        })
-                        .transpose()
-                        .map_err(|_| {
-                            AgentError::from(ClientError::invalid_request("Invalid banner URI"))
-                        })?;
+            // let weaver_future = async {
+            //     if let Ok(weaver_record) = self.fetch_record(&weaver_uri).await {
+            //         // Convert blobs to CDN URLs
+            //         let avatar = weaver_record
+            //             .value
+            //             .avatar
+            //             .as_ref()
+            //             .map(|blob| {
+            //                 let cid = blob.blob().cid();
+            //                 jacquard::types::string::Uri::new_owned(format!(
+            //                     "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
+            //                     did, cid
+            //                 ))
+            //             })
+            //             .transpose()
+            //             .map_err(|_| {
+            //                 AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
+            //             })?;
+            //         let banner = weaver_record
+            //             .value
+            //             .banner
+            //             .as_ref()
+            //             .map(|blob| {
+            //                 let cid = blob.blob().cid();
+            //                 jacquard::types::string::Uri::new_owned(format!(
+            //                     "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
+            //                     did, cid
+            //                 ))
+            //             })
+            //             .transpose()
+            //             .map_err(|_| {
+            //                 AgentError::from(ClientError::invalid_request("Invalid banner URI"))
+            //             })?;
 
-                    let profile_view = ProfileView::new()
-                        .did(did.clone())
-                        .handle(handle.clone())
-                        .maybe_display_name(weaver_record.value.display_name.clone())
-                        .maybe_description(weaver_record.value.description.clone())
-                        .maybe_avatar(avatar)
-                        .maybe_banner(banner)
-                        .maybe_bluesky(weaver_record.value.bluesky)
-                        .maybe_tangled(weaver_record.value.tangled)
-                        .maybe_streamplace(weaver_record.value.streamplace)
-                        .maybe_location(weaver_record.value.location.clone())
-                        .maybe_links(weaver_record.value.links.clone())
-                        .maybe_pronouns(weaver_record.value.pronouns.clone())
-                        .maybe_pinned(weaver_record.value.pinned.clone())
-                        .indexed_at(jacquard::types::string::Datetime::now())
-                        .maybe_created_at(weaver_record.value.created_at)
-                        .build();
+            //         let profile_view = ProfileView::new()
+            //             .did(did.clone())
+            //             .handle(handle.clone())
+            //             .maybe_display_name(weaver_record.value.display_name.clone())
+            //             .maybe_description(weaver_record.value.description.clone())
+            //             .maybe_avatar(avatar)
+            //             .maybe_banner(banner)
+            //             .maybe_bluesky(weaver_record.value.bluesky)
+            //             .maybe_tangled(weaver_record.value.tangled)
+            //             .maybe_streamplace(weaver_record.value.streamplace)
+            //             .maybe_location(weaver_record.value.location.clone())
+            //             .maybe_links(weaver_record.value.links.clone())
+            //             .maybe_pronouns(weaver_record.value.pronouns.clone())
+            //             .maybe_pinned(weaver_record.value.pinned.clone())
+            //             .indexed_at(jacquard::types::string::Datetime::now())
+            //             .maybe_created_at(weaver_record.value.created_at)
+            //             .build();
 
-                    Ok((
-                        Some(weaver_uri.as_uri().clone().into_static()),
-                        ProfileDataView::new()
-                            .inner(ProfileDataViewInner::ProfileView(Box::new(profile_view)))
-                            .build()
-                            .into_static(),
-                    ))
-                } else {
-                    Err(WeaverError::Agent(
-                        ClientError::invalid_request("Invalid weaver profile URI").into(),
-                    ))
-                }
-            };
+            //         Ok((
+            //             Some(weaver_uri.as_uri().clone().into_static()),
+            //             ProfileDataView::new()
+            //                 .inner(ProfileDataViewInner::ProfileView(Box::new(profile_view)))
+            //                 .build()
+            //                 .into_static(),
+            //         ))
+            //     } else {
+            //         Err(WeaverError::Agent(
+            //             ClientError::invalid_request("Invalid weaver profile URI").into(),
+            //         ))
+            //     }
+            // };
             let bsky_appview_future = async {
                 if let Ok(bsky_resp) = self
                     .send(GetProfile::new().actor(did.clone()).build())
···
                     AgentError::from(ClientError::invalid_request("Invalid bsky profile URI"))
                 })?;
 
-            let bsky_future = async {
-                let bsky_record = self.fetch_record(&bsky_uri).await?;
+            // let bsky_future = async {
+            //     let bsky_record = self.fetch_record(&bsky_uri).await?;
 
-                let avatar = bsky_record
-                    .value
-                    .avatar
-                    .as_ref()
-                    .map(|blob| {
-                        let cid = blob.blob().cid();
-                        jacquard::types::string::Uri::new_owned(format!(
-                            "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
-                            did, cid
-                        ))
-                    })
-                    .transpose()
-                    .map_err(|_| {
-                        AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
-                    })?;
-                let banner = bsky_record
-                    .value
-                    .banner
-                    .as_ref()
-                    .map(|blob| {
-                        let cid = blob.blob().cid();
-                        jacquard::types::string::Uri::new_owned(format!(
-                            "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
-                            did, cid
-                        ))
-                    })
-                    .transpose()
-                    .map_err(|_| {
-                        AgentError::from(ClientError::invalid_request("Invalid banner URI"))
-                    })?;
+            //     let avatar = bsky_record
+            //         .value
+            //         .avatar
+            //         .as_ref()
+            //         .map(|blob| {
+            //             let cid = blob.blob().cid();
+            //             jacquard::types::string::Uri::new_owned(format!(
+            //                 "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
+            //                 did, cid
+            //             ))
+            //         })
+            //         .transpose()
+            //         .map_err(|_| {
+            //             AgentError::from(ClientError::invalid_request("Invalid avatar URI"))
+            //         })?;
+            //     let banner = bsky_record
+            //         .value
+            //         .banner
+            //         .as_ref()
+            //         .map(|blob| {
+            //             let cid = blob.blob().cid();
+            //             jacquard::types::string::Uri::new_owned(format!(
+            //                 "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
+            //                 did, cid
+            //             ))
+            //         })
+            //         .transpose()
+            //         .map_err(|_| {
+            //             AgentError::from(ClientError::invalid_request("Invalid banner URI"))
+            //         })?;
 
-                let profile_detailed = ProfileViewDetailed::new()
-                    .did(did.clone())
-                    .handle(handle.clone())
-                    .maybe_display_name(bsky_record.value.display_name.clone())
-                    .maybe_description(bsky_record.value.description.clone())
-                    .maybe_avatar(avatar)
-                    .maybe_banner(banner)
-                    .indexed_at(jacquard::types::string::Datetime::now())
-                    .maybe_created_at(bsky_record.value.created_at)
-                    .build();
+            //     let profile_detailed = ProfileViewDetailed::new()
+            //         .did(did.clone())
+            //         .handle(handle.clone())
+            //         .maybe_display_name(bsky_record.value.display_name.clone())
+            //         .maybe_description(bsky_record.value.description.clone())
+            //         .maybe_avatar(avatar)
+            //         .maybe_banner(banner)
+            //         .indexed_at(jacquard::types::string::Datetime::now())
+            //         .maybe_created_at(bsky_record.value.created_at)
+            //         .build();
 
-                Ok((
-                    Some(bsky_uri.as_uri().clone().into_static()),
-                    ProfileDataView::new()
-                        .inner(ProfileDataViewInner::ProfileViewDetailed(Box::new(
-                            profile_detailed,
-                        )))
-                        .build()
-                        .into_static(),
-                ))
-            };
+            //     Ok((
+            //         Some(bsky_uri.as_uri().clone().into_static()),
+            //         ProfileDataView::new()
+            //             .inner(ProfileDataViewInner::ProfileViewDetailed(Box::new(
+            //                 profile_detailed,
+            //             )))
+            //             .build()
+            //             .into_static(),
+            //     ))
+            // };
 
-            n0_future::future::or(
-                weaver_future,
-                n0_future::future::or(bsky_appview_future, bsky_future),
-            )
-            .await
+            // n0_future::future::or(
+            //     weaver_future,
+            //     n0_future::future::or(bsky_appview_future, bsky_future),
+            // )
+            // .await
+            bsky_appview_future.await
         }
     }
 

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

···
         if let Some(embeds) = &entry.embeds {
             if let Some(images) = &embeds.images {
                 for img in &images.images {
-                    tracing::info!("Image: {:?}", img);
                     if let Some(name) = &img.name {
                         let blob_name = BlobName::from_filename(name.as_ref());
                         map.insert(blob_name, img.image.blob().cid().clone().into_static());