hmmm

Cargo.lock

···
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.10"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "axum"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a18ed336352031311f4e0b4dd2ff392d4fbb370777c9d18d7fc9d7359f73871"
+checksum = "5b098575ebe77cb6d14fc7f32749631a6e44edbef6b796f89b020e99ba20d425"
 dependencies = [
  "axum-core",
  "axum-macros",
···
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 dependencies = [
  "serde",
 ]
···
 
 [[package]]
 name = "cc"
-version = "1.2.45"
+version = "1.2.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35900b6c8d709fb1d854671ae27aeaa9eec2f8b01b364e1619a40da3e6fe2afe"
+checksum = "b97463e1064cb1b1c1384ad0a0b9c8abd0988e2a91f52606c80ef14aadb63e36"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
···
 
 [[package]]
 name = "clap"
-version = "4.5.51"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c26d721170e0295f191a69bd9a1f93efcdb0aff38684b61ab5750468972e5f5"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
 dependencies = [
  "clap_builder",
  "clap_derive",
···
 
 [[package]]
 name = "clap_builder"
-version = "4.5.51"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75835f0c7bf681bfd05abe44e965760fea999a5286c6eb2d59883634fd02011a"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
 dependencies = [
  "anstream",
  "anstyle",
···
 dependencies = [
  "bytes",
  "memchr",
-]
-
-[[package]]
-name = "compact_string"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5255b88d8ea09573f588088dea17fbea682b4442abea6761a15d1da2c3a76c5c"
-dependencies = [
- "serde",
- "thiserror 1.0.69",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "dioxus-free-icons"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d356e0f9edad0930bc1cc76744360c0ecca020cb943acaadf42cb774f28284"
-dependencies = [
- "dioxus",
-]
-
-[[package]]
 name = "dioxus-fullstack"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 [[package]]
 name = "dioxus-primitives"
 version = "0.0.1"
-source = "git+https://github.com/DioxusLabs/components#98067ce2da493651b0c089db91e9903714c211f7"
+source = "git+https://github.com/DioxusLabs/components#a15f329d1dc2bd76cd4030b27ecd70edb9fd8c6b"
 dependencies = [
  "dioxus",
  "dioxus-time",
···
 checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
-name = "dynosaur"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "277b2cb52d2df4acece06bb16bc0bb0a006970c7bf504eac2d310927a6f65890"
-dependencies = [
- "dynosaur_derive",
- "trait-variant",
-]
-
-[[package]]
-name = "dynosaur_derive"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a4102713839a8c01c77c165bc38ef2e83948f6397fa1e1dcfacec0f07b149d3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "ecdsa"
 version = "0.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
 name = "flate2"
···
  "futures-core",
  "futures-sink",
  "http",
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "slab",
  "tokio",
  "tokio-util",
···
 
 [[package]]
 name = "hashbrown"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
  "allocator-api2",
  "equivalent",
···
 
 [[package]]
 name = "hyper"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1744436df46f0bde35af3eda22aeaba453aada65d8f1c171cd8a5f59030bd69f"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
 dependencies = [
  "atomic-waker",
  "bytes",
···
 ]
 
 [[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes",
- "http-body-util",
- "hyper",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
-]
-
-[[package]]
 name = "hyper-util"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56"
 dependencies = [
  "base64 0.22.1",
  "bytes",
···
 
 [[package]]
 name = "indexmap"
-version = "2.12.0"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.0",
+ "hashbrown 0.16.1",
  "serde",
  "serde_core",
 ]
···
 
 [[package]]
 name = "insta"
-version = "1.43.2"
+version = "1.44.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fdb647ebde000f43b5b53f773c30cf9b0cb4300453208713fa38b2c70935a0"
+checksum = "e8732d3774162a0851e3f2b150eb98f31a9885dd75985099421d393385a01dfd"
 dependencies = [
  "console",
  "once_cell",
···
 
 [[package]]
 name = "jacquard"
-version = "0.9.0"
+version = "0.9.4"
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
···
  "jose-jwk",
  "miette 7.6.0",
  "regex",
+ "regex-lite",
  "reqwest",
  "serde",
  "serde_html_form",
···
 
 [[package]]
 name = "jacquard-api"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "bon",
  "bytes",
···
 
 [[package]]
 name = "jacquard-axum"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "axum",
  "bytes",
···
 
 [[package]]
 name = "jacquard-common"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
  "p256",
  "rand 0.9.2",
  "regex",
+ "regex-lite",
  "reqwest",
  "serde",
  "serde_html_form",
···
 
 [[package]]
 name = "jacquard-derive"
-version = "0.9.0"
+version = "0.9.4"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 
 [[package]]
 name = "jacquard-identity"
-version = "0.9.1"
+version = "0.9.2"
 dependencies = [
  "bon",
  "bytes",
···
  "jacquard-common",
  "jacquard-lexicon",
  "miette 7.6.0",
- "mini-moka",
+ "mini-moka 0.10.99",
  "percent-encoding",
  "reqwest",
  "serde",
···
 
 [[package]]
 name = "jacquard-lexicon"
-version = "0.9.1"
+version = "0.9.2"
 dependencies = [
  "cid",
  "dashmap",
···
 
 [[package]]
 name = "jacquard-oauth"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "base64 0.22.1",
  "bytes",
···
 dependencies = [
  "cssparser",
  "html5ever 0.29.1",
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "selectors",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96051b46fc183dc9cd4a223960ef37b9af631b55191852a8274bfef064cda20f"
 dependencies = [
- "hashbrown 0.16.0",
+ "hashbrown 0.16.1",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "mini-moka"
+version = "0.10.99"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-utils",
+ "dashmap",
+ "smallvec",
+ "tagptr",
+ "triomphe",
+ "web-time",
+]
+
+[[package]]
+name = "mini-moka"
 version = "0.11.0"
 source = "git+https://github.com/moka-rs/mini-moka?rev=da864e849f5d034f32e02197fee9bb5d5af36d3d#da864e849f5d034f32e02197fee9bb5d5af36d3d"
 dependencies = [
···
 checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07"
 dependencies = [
  "base64 0.22.1",
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "quick-xml 0.38.4",
  "serde",
  "time",
···
 ]
 
 [[package]]
+name = "regex-lite"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
+
+[[package]]
 name = "regex-syntax"
 version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "http-body-util",
  "hyper",
  "hyper-rustls",
- "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
  "mime",
  "mime_guess",
- "native-tls",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
···
  "serde_urlencoded",
  "sync_wrapper",
  "tokio",
- "tokio-native-tls",
  "tokio-rustls",
  "tokio-util",
  "tower",
···
 
 [[package]]
 name = "resolv-conf"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b3789b30bd25ba102de4beabd95d21ac45b69b1be7d14522bab988c526d6799"
+checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
 
 [[package]]
 name = "rfc6979"
···
 
 [[package]]
 name = "rsa"
-version = "0.9.8"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78928ac1ed176a5ca1d17e578a1825f3d81ca54cf41053a592584b020cfd691b"
+checksum = "40a0376c50d0358279d9d643e4bf7b7be212f1f4ff1da9070a7b54d22ef75c88"
 dependencies = [
  "const-oid",
  "digest",
···
 checksum = "b2f2d7ff8a2140333718bb329f5c40fc5f0865b84c426183ce14c97d2ab8154f"
 dependencies = [
  "form_urlencoded",
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "itoa",
  "ryu",
  "serde_core",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "itoa",
  "memchr",
  "ryu",
···
 
 [[package]]
 name = "serde_with"
-version = "3.15.1"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa66c845eee442168b2c8134fec70ac50dc20e760769c8ba0ad1319ca1959b04"
+checksum = "10574371d41b0d9b2cff89418eda27da52bcaff2cc8741db26382a77c29131f1"
 dependencies = [
  "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "schemars 0.9.0",
  "schemars 1.1.0",
  "serde_core",
···
 
 [[package]]
 name = "serde_with_macros"
-version = "3.15.1"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91a903660542fced4e99881aa481bdbaec1634568ee02e0b8bd57c64cb38955"
+checksum = "08a72d8216842fdd57820dc78d840bef99248e35fb2554ff923319e60f2d686b"
 dependencies = [
  "darling",
  "proc-macro2",
···
 ]
 
 [[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
-[[package]]
 name = "tokio-rustls"
 version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "serde",
  "serde_spanned 0.6.9",
  "toml_datetime 0.6.11",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "toml_datetime 0.6.11",
  "winnow 0.5.40",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "toml_datetime 0.6.11",
  "winnow 0.5.40",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "serde",
  "serde_spanned 0.6.9",
  "toml_datetime 0.6.11",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.12.1",
  "toml_datetime 0.7.3",
  "toml_parser",
  "winnow 0.7.13",
···
  "console_error_panic_hook",
  "dashmap",
  "dioxus",
- "dioxus-free-icons",
  "dioxus-primitives",
  "dotenvy",
  "gloo-storage",
···
  "humansize",
  "jacquard",
  "jacquard-axum",
+ "jacquard-identity",
  "jacquard-lexicon",
  "js-sys",
  "lol_alloc",
  "markdown-weaver",
  "mime-sniffer",
- "mini-moka",
+ "mini-moka 0.11.0",
  "n0-future",
  "reqwest",
  "serde",
  "serde_html_form",
+ "serde_ipld_dagcbor",
  "serde_json",
  "time",
  "tokio",
···
  "clap",
  "dirs",
  "jacquard",
- "jacquard-api",
  "kdl",
  "markdown-weaver",
  "markdown-weaver-escape",
···
  "markdown-weaver-escape",
  "miette 7.6.0",
  "mime-sniffer",
- "minijinja",
  "n0-future",
- "owo-colors",
  "pin-project",
  "regex",
+ "regex-lite",
  "reqwest",
  "send_wrapper",
  "serde",
- "serde_bytes",
- "serde_html_form",
- "serde_ipld_dagcbor",
  "serde_json",
  "thiserror 2.0.17",
  "tokio",
···
  "futures-util",
  "hyper",
  "jacquard",
- "jacquard-api",
  "jacquard-axum",
  "jose",
  "jose-jwk",
···
 version = "0.1.0"
 dependencies = [
  "bitflags 2.10.0",
- "compact_string",
  "dashmap",
- "dynosaur",
  "http",
  "ignore",
  "insta",
···
  "pin-project",
  "pin-utils",
  "regex",
+ "regex-lite",
  "reqwest",
  "smol_str",
  "syntect",
···
 
 [[package]]
 name = "windows-registry"
-version = "0.5.3"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
 dependencies = [
- "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "zerocopy"
-version = "0.8.27"
+version = "0.8.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+checksum = "43fa6694ed34d6e57407afbccdeecfa268c470a7d2a5b0cf49ce9fcc345afb90"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.27"
+version = "0.8.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+checksum = "c640b22cd9817fae95be82f0d2f90b11f7605f6c319d16705c459b27ac2cbc26"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

···
 
 
 [workspace.dependencies]
-
 serde = { version = "1.0", features = ["derive"] }
 bytes = "1.10"
-minijinja = { version = "2.9.0", default-features = false }
-minijinja-contrib = { version = "2.9.0", default-features = false }
 miette = { version = "7.6" }
-owo-colors = { version = "4.2.0" }
 thiserror = "2.0"
 syntect = { version = "5.2.0", default-features = false }
-jane-eyre = "0.6.12"
 n0-future = "=0.1.3"
 tracing = { version = "0.1.41", default-features = false, features = ["std"] }
-lexicon_cid = { package = "cid", version = "0.10.1", features = [
-  "serde-codec",
-] }
-
 markdown-weaver = { git = "https://github.com/rsform/markdown-weaver" }
 markdown-weaver-escape = { git = "https://github.com/rsform/markdown-weaver" }
 
 # jacquard = { git = "https://tangled.org/@nonbinary.computer/jacquard", default-features = false, features = ["derive", "api_bluesky", "tracing"] }
-# jacquard-api = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
+# jacquard-identity = { git = "https://tangled.org/@nonbinary.computer/jacquard", features = ["cache"] }
 # jacquard-common = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
 # jacquard-axum = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
 # jacquard-derive = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
 # jacquard-lexicon = { git = "https://tangled.org/@nonbinary.computer/jacquard", default-features = false }
 
-jacquard = { path = "../jacquard/crates/jacquard", default-features = false, features = ["derive", "api_bluesky", "tracing"] }
+jacquard = { path = "../jacquard/crates/jacquard", default-features = false, features = ["derive", "api_bluesky", "tracing", "cache"] }
+jacquard-identity = { path = "../jacquard/crates/jacquard-identity", features = ["cache"] }
 jacquard-api = { path = "../jacquard/crates/jacquard-api" }
 jacquard-common = { path = "../jacquard/crates/jacquard-common" }
 jacquard-axum = {path = "../jacquard/crates/jacquard-axum" }
 jacquard-derive = { path = "../jacquard/crates/jacquard-derive" }
 jacquard-lexicon = { path = "../jacquard/crates/jacquard-lexicon", default-features = false }
+
+# jacquard = { path = "../jacquard-facet/crates/jacquard", default-features = false, features = ["derive", "api_bluesky", "tracing", "serde"] }
+# jacquard-identity = { path = "../jacquard-facet/crates/jacquard-identity", features = ["cache"] }
+# jacquard-api = { path = "../jacquard-facet/crates/jacquard-api" }
+# jacquard-common = { path = "../jacquard-facet/crates/jacquard-common" }
+# jacquard-axum = {path = "../jacquard-facet/crates/jacquard-axum" }
+# jacquard-derive = { path = "../jacquard-facet/crates/jacquard-derive" }
+# jacquard-lexicon = { path = "../jacquard-facet/crates/jacquard-lexicon", default-features = false }
 
 [profile]
 

crates/weaver-api/Cargo.toml

···
 authors.workspace = true
 
 [dependencies]
-bytes = { workspace = true, features = ["serde"] }
+bytes = { workspace = true }
 jacquard-common = { workspace = true }
 jacquard-derive = { workspace = true }
 jacquard-lexicon = { workspace = true }
 miette.workspace = true
 rustversion = "1.0"
 serde.workspace = true
-serde_ipld_dagcbor = "0.6"
+serde_ipld_dagcbor = { version = "0.6", optional = true }
 thiserror.workspace = true
 unicode-segmentation = "1.12"
 
···
 non_snake_case = "allow"
 
 [features]
-default = ["sh_weaver", "com_atproto"]
+default = ["sh_weaver", "com_atproto",  "serde"]
 streaming = ["jacquard-common/websocket"]
+serde = ["bytes/serde", "dep:serde_ipld_dagcbor"]
+
 
 # --- generated ---
 # Generated namespace features

crates/weaver-api/lexicons/tools_ozone_moderation_defs.json

···
           "type": "string",
           "description": "The content of the email sent to the user."
         },
+        "isDelivered": {
+          "type": "boolean",
+          "description": "Indicates whether the email was successfully delivered to the user's inbox."
+        },
         "policies": {
           "type": "array",
           "description": "Names/Keywords of the policies that necessitated the email.",
···
           "type": "string",
           "description": "When the strike should expire. If not provided, the strike never expires.",
           "format": "datetime"
+        },
+        "targetServices": {
+          "type": "array",
+          "description": "List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services.",
+          "items": {
+            "type": "string",
+            "knownValues": [
+              "appview",
+              "pds"
+            ]
+          }
         }
       }
     },

crates/weaver-api/lexicons/tools_ozone_moderation_queryStatuses.json

···
           },
           "reviewState": {
             "type": "string",
-            "description": "Specify when fetching subjects in a certain state"
+            "description": "Specify when fetching subjects in a certain state",
+            "knownValues": [
+              "tools.ozone.moderation.defs#reviewOpen",
+              "tools.ozone.moderation.defs#reviewClosed",
+              "tools.ozone.moderation.defs#reviewEscalated",
+              "tools.ozone.moderation.defs#reviewNone"
+            ]
           },
           "reviewedAfter": {
             "type": "string",

crates/weaver-api/lexicons/tools_ozone_moderation_scheduleAction.json

···
           "type": "integer",
           "description": "Indicates how long the takedown should be in effect before automatically expiring."
         },
+        "emailContent": {
+          "type": "string",
+          "description": "Email content to be sent to the user upon takedown."
+        },
+        "emailSubject": {
+          "type": "string",
+          "description": "Subject of the email to be sent to the user upon takedown."
+        },
         "policies": {
           "type": "array",
           "description": "Names/Keywords of the policies that drove the decision.",
···
             "type": "string"
           },
           "maxLength": 5
+        },
+        "severityLevel": {
+          "type": "string",
+          "description": "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.)."
+        },
+        "strikeCount": {
+          "type": "integer",
+          "description": "Number of strikes to assign to the user when takedown is applied."
+        },
+        "strikeExpiresAt": {
+          "type": "string",
+          "description": "When the strike should expire. If not provided, the strike never expires.",
+          "format": "datetime"
         }
       }
     }

crates/weaver-api/src/app_bsky/actor.rs

···
     /// Groups of users to apply the muted word to. If undefined, applies to all users.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub actor_target: Option<jacquard_common::CowStr<'a>>,
+    pub actor_target: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The date and time at which the muted word will expire and no longer be applied.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub expires_at: Option<jacquard_common::types::string::Datetime>,
+    pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub id: Option<jacquard_common::CowStr<'a>>,
+    pub id: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The intended targets of the muted word.
     #[serde(borrow)]
     pub targets: Vec<crate::app_bsky::actor::MutedWordTarget<'a>>,
···
     /// Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub data: Option<jacquard_common::CowStr<'a>>,
+    pub data: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The date and time at which the NUX will expire and should be considered completed.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub expires_at: Option<jacquard_common::types::string::Datetime>,
+    pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub id: jacquard_common::CowStr<'a>,
 }
···
 pub struct ProfileView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
+    pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Debug information for internal development
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub debug: Option<jacquard_common::types::value::Data<'a>>,
+    pub debug: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub indexed_at: Option<jacquard_common::types::string::Datetime>,
+    pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<jacquard_common::CowStr<'a>>,
+    pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<crate::app_bsky::actor::StatusView<'a>>,
+    pub status: std::option::Option<crate::app_bsky::actor::StatusView<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
+    pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
 }
 
 pub mod profile_view_state {
···
 pub struct ProfileViewBasic<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
+    pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Debug information for internal development
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub debug: Option<jacquard_common::types::value::Data<'a>>,
+    pub debug: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<jacquard_common::CowStr<'a>>,
+    pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<crate::app_bsky::actor::StatusView<'a>>,
+    pub status: std::option::Option<crate::app_bsky::actor::StatusView<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
+    pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
 }
 
 pub mod profile_view_basic_state {
···
 pub struct ProfileViewDetailed<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
+    pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub banner: Option<jacquard_common::types::string::Uri<'a>>,
+    pub banner: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Debug information for internal development
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub debug: Option<jacquard_common::types::value::Data<'a>>,
+    pub debug: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub followers_count: Option<i64>,
+    pub followers_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub follows_count: Option<i64>,
+    pub follows_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub indexed_at: Option<jacquard_common::types::string::Datetime>,
+    pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub joined_via_starter_pack: Option<
+    pub joined_via_starter_pack: std::option::Option<
         crate::app_bsky::graph::StarterPackViewBasic<'a>,
     >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pinned_post: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub pinned_post: std::option::Option<
+        crate::com_atproto::repo::strong_ref::StrongRef<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub posts_count: Option<i64>,
+    pub posts_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<jacquard_common::CowStr<'a>>,
+    pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<crate::app_bsky::actor::StatusView<'a>>,
+    pub status: std::option::Option<crate::app_bsky::actor::StatusView<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
+    pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub website: Option<jacquard_common::types::string::Uri<'a>>,
+    pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,
 }
 
 pub mod profile_view_detailed_state {
···
     #[serde(borrow)]
     pub saved: Vec<jacquard_common::types::string::AtUri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub timeline_index: Option<i64>,
+    pub timeline_index: std::option::Option<i64>,
 }
 
 pub mod saved_feeds_pref_state {
···
     /// An optional embed associated with the status.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embed: Option<crate::app_bsky::embed::external::View<'a>>,
+    pub embed: std::option::Option<crate::app_bsky::embed::external::View<'a>>,
     /// The date when this status will expire. The application might choose to no longer return the status after expiration.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub expires_at: Option<jacquard_common::types::string::Datetime>,
+    pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// True if the status is not expired, false if it is expired. Only present if expiration was set.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub is_active: Option<bool>,
+    pub is_active: std::option::Option<bool>,
     #[serde(borrow)]
     pub record: jacquard_common::types::value::Data<'a>,
     /// The status for the account.

crates/weaver-api/src/app_bsky/actor/profile.rs

···
     /// Small image to be displayed next to posts from account. AKA, 'profile picture'
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     /// Larger horizontal image to display behind profile view.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub banner: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub banner: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Free-form profile description text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub joined_via_starter_pack: Option<
+    pub joined_via_starter_pack: std::option::Option<
         crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     >,
     /// Self-label values, specific to the Bluesky application, on the overall account.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<crate::com_atproto::label::SelfLabels<'a>>,
+    pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pinned_post: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub pinned_post: std::option::Option<
+        crate::com_atproto::repo::strong_ref::StrongRef<'a>,
+    >,
     /// Free-form pronouns text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<jacquard_common::CowStr<'a>>,
+    pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub website: Option<jacquard_common::types::string::Uri<'a>>,
+    pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,
 }
 
 pub mod profile_state {

crates/weaver-api/src/app_bsky/actor/status.rs

···
     pub created_at: jacquard_common::types::string::Datetime,
     /// The duration of the status in minutes. Applications can choose to impose minimum and maximum limits.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub duration_minutes: Option<i64>,
+    pub duration_minutes: std::option::Option<i64>,
     /// An optional embed associated with the status.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embed: Option<crate::app_bsky::embed::external::ExternalRecord<'a>>,
+    pub embed: std::option::Option<crate::app_bsky::embed::external::ExternalRecord<'a>>,
     /// The status for the account.
     #[serde(borrow)]
     pub status: jacquard_common::CowStr<'a>,

crates/weaver-api/src/app_bsky/bookmark.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct BookmarkView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub item: BookmarkViewItem<'a>,
     /// A strong ref to the bookmarked record.

crates/weaver-api/src/app_bsky/embed/external.rs

···
     pub description: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thumb: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub thumb: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     #[serde(borrow)]
     pub title: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
···
     pub description: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thumb: Option<jacquard_common::types::string::Uri<'a>>,
+    pub thumb: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(borrow)]
     pub title: jacquard_common::CowStr<'a>,
     #[serde(borrow)]

crates/weaver-api/src/app_bsky/embed/images.rs

···
     pub alt: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub aspect_ratio: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+    pub aspect_ratio: std::option::Option<crate::app_bsky::embed::AspectRatio<'a>>,
     #[serde(borrow)]
     pub image: jacquard_common::types::blob::BlobRef<'a>,
 }
···
     pub alt: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub aspect_ratio: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+    pub aspect_ratio: std::option::Option<crate::app_bsky::embed::AspectRatio<'a>>,
     /// Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View.
     #[serde(borrow)]
     pub fullsize: jacquard_common::types::string::Uri<'a>,

crates/weaver-api/src/app_bsky/embed/record.rs

···
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embeds: Option<Vec<ViewRecordEmbedsItem<'a>>>,
+    pub embeds: std::option::Option<Vec<ViewRecordEmbedsItem<'a>>>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub like_count: Option<i64>,
+    pub like_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub quote_count: Option<i64>,
+    pub quote_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub reply_count: Option<i64>,
+    pub reply_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub repost_count: Option<i64>,
+    pub repost_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
     /// The record data itself.

crates/weaver-api/src/app_bsky/embed/video.rs

···
     /// Alt text description of the video, for accessibility.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub alt: Option<jacquard_common::CowStr<'a>>,
+    pub alt: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub aspect_ratio: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+    pub aspect_ratio: std::option::Option<crate::app_bsky::embed::AspectRatio<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub captions: Option<Vec<crate::app_bsky::embed::video::Caption<'a>>>,
+    pub captions: std::option::Option<Vec<crate::app_bsky::embed::video::Caption<'a>>>,
     /// The mp4 video file. May be up to 100mb, formerly limited to 50mb.
     #[serde(borrow)]
     pub video: jacquard_common::types::blob::BlobRef<'a>,
···
 pub struct View<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub alt: Option<jacquard_common::CowStr<'a>>,
+    pub alt: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub aspect_ratio: Option<crate::app_bsky::embed::AspectRatio<'a>>,
+    pub aspect_ratio: std::option::Option<crate::app_bsky::embed::AspectRatio<'a>>,
     #[serde(borrow)]
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(borrow)]
     pub playlist: jacquard_common::types::string::Uri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thumbnail: Option<jacquard_common::types::string::Uri<'a>>,
+    pub thumbnail: std::option::Option<jacquard_common::types::string::Uri<'a>>,
 }
 
 pub mod view_state {

crates/weaver-api/src/app_bsky/feed.rs

···
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
 }
 
 pub mod blocked_author_state {
···
     /// Context provided by feed generator that may be passed back alongside interactions.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub feed_context: Option<jacquard_common::CowStr<'a>>,
+    pub feed_context: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub post: crate::app_bsky::feed::PostView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reason: Option<FeedViewPostReason<'a>>,
+    pub reason: std::option::Option<FeedViewPostReason<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reply: Option<crate::app_bsky::feed::ReplyRef<'a>>,
+    pub reply: std::option::Option<crate::app_bsky::feed::ReplyRef<'a>>,
     /// Unique identifier per request that may be passed back alongside interactions.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub req_id: Option<jacquard_common::CowStr<'a>>,
+    pub req_id: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod feed_view_post_state {
···
 #[serde(rename_all = "camelCase")]
 pub struct GeneratorView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub accepts_interactions: Option<bool>,
+    pub accepts_interactions: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(borrow)]
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub content_mode: Option<jacquard_common::CowStr<'a>>,
+    pub content_mode: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub creator: crate::app_bsky::actor::ProfileView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description_facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub description_facets: std::option::Option<
+        Vec<crate::app_bsky::richtext::facet::Facet<'a>>,
+    >,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(borrow)]
···
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub like_count: Option<i64>,
+    pub like_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
 }
 
 pub mod generator_view_state {
···
     #[serde(borrow)]
     pub author: crate::app_bsky::actor::ProfileViewBasic<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub bookmark_count: Option<i64>,
+    pub bookmark_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub cid: jacquard_common::types::string::Cid<'a>,
     /// Debug information for internal development
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub debug: Option<jacquard_common::types::value::Data<'a>>,
+    pub debug: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embed: Option<PostViewEmbed<'a>>,
+    pub embed: std::option::Option<PostViewEmbed<'a>>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub like_count: Option<i64>,
+    pub like_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub quote_count: Option<i64>,
+    pub quote_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub record: jacquard_common::types::value::Data<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub reply_count: Option<i64>,
+    pub reply_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub repost_count: Option<i64>,
+    pub repost_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub threadgate: Option<crate::app_bsky::feed::ThreadgateView<'a>>,
+    pub threadgate: std::option::Option<crate::app_bsky::feed::ThreadgateView<'a>>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::feed::ViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::feed::ViewerState<'a>>,
 }
 
 pub mod post_view_state {
···
     pub by: crate::app_bsky::actor::ProfileViewBasic<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub cid: Option<jacquard_common::types::string::Cid<'a>>,
+    pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub uri: Option<jacquard_common::types::string::AtUri<'a>>,
+    pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
 }
 
 pub mod reason_repost_state {
···
     /// When parent is a reply to another post, this is the author of that post.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub grandparent_author: Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
+    pub grandparent_author: std::option::Option<
+        crate::app_bsky::actor::ProfileViewBasic<'a>,
+    >,
     #[serde(borrow)]
     pub parent: ReplyRefParent<'a>,
     #[serde(borrow)]
···
     /// Context that will be passed through to client and may be passed to feed generator back alongside interactions.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub feed_context: Option<jacquard_common::CowStr<'a>>,
+    pub feed_context: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub post: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reason: Option<SkeletonFeedPostReason<'a>>,
+    pub reason: std::option::Option<SkeletonFeedPostReason<'a>>,
 }
 
 pub mod skeleton_feed_post_state {
···
 pub struct ThreadViewPost<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub parent: Option<ThreadViewPostParent<'a>>,
+    pub parent: std::option::Option<ThreadViewPostParent<'a>>,
     #[serde(borrow)]
     pub post: crate::app_bsky::feed::PostView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub replies: Option<Vec<ThreadViewPostRepliesItem<'a>>>,
+    pub replies: std::option::Option<Vec<ThreadViewPostRepliesItem<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thread_context: Option<crate::app_bsky::feed::ThreadContext<'a>>,
+    pub thread_context: std::option::Option<crate::app_bsky::feed::ThreadContext<'a>>,
 }
 
 pub mod thread_view_post_state {

crates/weaver-api/src/app_bsky/feed/generator.rs

···
 pub struct Generator<'a> {
     /// Declaration that a feed accepts feedback interactions from a client through app.bsky.feed.sendInteractions
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub accepts_interactions: Option<bool>,
+    pub accepts_interactions: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub content_mode: Option<jacquard_common::CowStr<'a>>,
+    pub content_mode: std::option::Option<jacquard_common::CowStr<'a>>,
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description_facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub description_facets: std::option::Option<
+        Vec<crate::app_bsky::richtext::facet::Facet<'a>>,
+    >,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(borrow)]
···
     /// Self-label values
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<crate::com_atproto::label::SelfLabels<'a>>,
+    pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,
 }
 
 pub mod generator_state {

crates/weaver-api/src/app_bsky/feed/like.rs

···
     pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub via: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub via: std::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
 }
 
 pub mod like_state {

crates/weaver-api/src/app_bsky/feed/post.rs

···
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embed: Option<PostEmbed<'a>>,
+    pub embed: std::option::Option<PostEmbed<'a>>,
     /// DEPRECATED: replaced by app.bsky.richtext.facet.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub entities: Option<Vec<crate::app_bsky::feed::post::Entity<'a>>>,
+    pub entities: std::option::Option<Vec<crate::app_bsky::feed::post::Entity<'a>>>,
     /// Annotations of text (mentions, URLs, hashtags, etc)
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub facets: std::option::Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
     /// Self-label values for this post. Effectively content warnings.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<crate::com_atproto::label::SelfLabels<'a>>,
+    pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,
     /// Indicates human language of post primary text content.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub langs: Option<Vec<jacquard_common::types::string::Language>>,
+    pub langs: std::option::Option<Vec<jacquard_common::types::string::Language>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reply: Option<crate::app_bsky::feed::post::ReplyRef<'a>>,
+    pub reply: std::option::Option<crate::app_bsky::feed::post::ReplyRef<'a>>,
     /// Additional hashtags, in addition to any included in post text and facets.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,
+    pub tags: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
     /// The primary post content. May be an empty string, if there are embeds.
     #[serde(borrow)]
     pub text: jacquard_common::CowStr<'a>,

crates/weaver-api/src/app_bsky/feed/postgate.rs

···
     /// List of AT-URIs embedding this post that the author has detached from.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub detached_embedding_uris: Option<Vec<jacquard_common::types::string::AtUri<'a>>>,
+    pub detached_embedding_uris: std::option::Option<
+        Vec<jacquard_common::types::string::AtUri<'a>>,
+    >,
     /// List of rules defining who can embed this post. If value is an empty array or is undefined, no particular rules apply and anyone can embed.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embedding_rules: Option<Vec<crate::app_bsky::feed::postgate::DisableRule<'a>>>,
+    pub embedding_rules: std::option::Option<
+        Vec<crate::app_bsky::feed::postgate::DisableRule<'a>>,
+    >,
     /// Reference (AT-URI) to the post record.
     #[serde(borrow)]
     pub post: jacquard_common::types::string::AtUri<'a>,

crates/weaver-api/src/app_bsky/feed/repost.rs

···
     pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub via: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub via: std::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
 }
 
 pub mod repost_state {

crates/weaver-api/src/app_bsky/feed/threadgate.rs

···
     /// List of rules defining who can reply to this post. If value is an empty array, no one can reply. If value is undefined, anyone can reply.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub allow: Option<Vec<ThreadgateAllowItem<'a>>>,
+    pub allow: std::option::Option<Vec<ThreadgateAllowItem<'a>>>,
     pub created_at: jacquard_common::types::string::Datetime,
     /// List of hidden reply URIs.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub hidden_replies: Option<Vec<jacquard_common::types::string::AtUri<'a>>>,
+    pub hidden_replies: std::option::Option<
+        Vec<jacquard_common::types::string::AtUri<'a>>,
+    >,
     /// Reference (AT-URI) to the post record.
     #[serde(borrow)]
     pub post: jacquard_common::types::string::AtUri<'a>,

crates/weaver-api/src/app_bsky/graph.rs

···
 pub struct ListView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(borrow)]
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(borrow)]
     pub creator: crate::app_bsky::actor::ProfileView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description_facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub description_facets: std::option::Option<
+        Vec<crate::app_bsky::richtext::facet::Facet<'a>>,
+    >,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub list_item_count: Option<i64>,
+    pub list_item_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub name: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
···
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::graph::ListViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::graph::ListViewerState<'a>>,
 }
 
 pub mod list_view_state {
···
 pub struct ListViewBasic<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(borrow)]
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub indexed_at: Option<jacquard_common::types::string::Datetime>,
+    pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub list_item_count: Option<i64>,
+    pub list_item_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub name: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
···
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::graph::ListViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::graph::ListViewerState<'a>>,
 }
 
 pub mod list_view_basic_state {
···
     /// if the actor is followed by this DID, contains the AT-URI of the follow record
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub followed_by: Option<jacquard_common::types::string::AtUri<'a>>,
+    pub followed_by: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
     /// if the actor follows this DID, this is the AT-URI of the follow record
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub following: Option<jacquard_common::types::string::AtUri<'a>>,
+    pub following: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
 }
 
 pub mod relationship_state {
···
     pub creator: crate::app_bsky::actor::ProfileViewBasic<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub feeds: Option<Vec<crate::app_bsky::feed::GeneratorView<'a>>>,
+    pub feeds: std::option::Option<Vec<crate::app_bsky::feed::GeneratorView<'a>>>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub joined_all_time_count: Option<i64>,
+    pub joined_all_time_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub joined_week_count: Option<i64>,
+    pub joined_week_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub list: Option<crate::app_bsky::graph::ListViewBasic<'a>>,
+    pub list: std::option::Option<crate::app_bsky::graph::ListViewBasic<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub list_items_sample: Option<Vec<crate::app_bsky::graph::ListItemView<'a>>>,
+    pub list_items_sample: std::option::Option<
+        Vec<crate::app_bsky::graph::ListItemView<'a>>,
+    >,
     #[serde(borrow)]
     pub record: jacquard_common::types::value::Data<'a>,
     #[serde(borrow)]
···
     pub creator: crate::app_bsky::actor::ProfileViewBasic<'a>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub joined_all_time_count: Option<i64>,
+    pub joined_all_time_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub joined_week_count: Option<i64>,
+    pub joined_week_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub list_item_count: Option<i64>,
+    pub list_item_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub record: jacquard_common::types::value::Data<'a>,
     #[serde(borrow)]

crates/weaver-api/src/app_bsky/graph/follow.rs

···
     pub subject: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub via: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub via: std::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
 }
 
 pub mod follow_state {

crates/weaver-api/src/app_bsky/graph/get_lists_with_membership.rs

···
     pub list: crate::app_bsky::graph::ListView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub list_item: Option<crate::app_bsky::graph::ListItemView<'a>>,
+    pub list_item: std::option::Option<crate::app_bsky::graph::ListItemView<'a>>,
 }
 
 pub mod list_with_membership_state {

crates/weaver-api/src/app_bsky/graph/get_starter_packs_with_membership.rs

···
 pub struct StarterPackWithMembership<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub list_item: Option<crate::app_bsky::graph::ListItemView<'a>>,
+    pub list_item: std::option::Option<crate::app_bsky::graph::ListItemView<'a>>,
     #[serde(borrow)]
     pub starter_pack: crate::app_bsky::graph::StarterPackView<'a>,
 }

crates/weaver-api/src/app_bsky/graph/list.rs

···
 pub struct List<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description_facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub description_facets: std::option::Option<
+        Vec<crate::app_bsky::richtext::facet::Facet<'a>>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<crate::com_atproto::label::SelfLabels<'a>>,
+    pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,
     /// Display name for list; can not be empty.
     #[serde(borrow)]
     pub name: jacquard_common::CowStr<'a>,

crates/weaver-api/src/app_bsky/graph/starterpack.rs

···
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description_facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub description_facets: std::option::Option<
+        Vec<crate::app_bsky::richtext::facet::Facet<'a>>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub feeds: Option<Vec<crate::app_bsky::graph::starterpack::FeedItem<'a>>>,
+    pub feeds: std::option::Option<
+        Vec<crate::app_bsky::graph::starterpack::FeedItem<'a>>,
+    >,
     /// Reference (AT-URI) to the list record.
     #[serde(borrow)]
     pub list: jacquard_common::types::string::AtUri<'a>,

crates/weaver-api/src/app_bsky/labeler.rs

···
     /// Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub label_value_definitions: Option<
+    pub label_value_definitions: std::option::Option<
         Vec<crate::com_atproto::label::LabelValueDefinition<'a>>,
     >,
     /// The label values which this labeler publishes. May include global or custom labels.
···
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub like_count: Option<i64>,
+    pub like_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::labeler::LabelerViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::labeler::LabelerViewerState<'a>>,
 }
 
 pub mod labeler_view_state {
···
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub like_count: Option<i64>,
+    pub like_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub policies: crate::app_bsky::labeler::LabelerPolicies<'a>,
     /// The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reason_types: Option<Vec<crate::com_atproto::moderation::ReasonType<'a>>>,
+    pub reason_types: std::option::Option<
+        Vec<crate::com_atproto::moderation::ReasonType<'a>>,
+    >,
     /// Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_collections: Option<Vec<jacquard_common::types::string::Nsid<'a>>>,
+    pub subject_collections: std::option::Option<
+        Vec<jacquard_common::types::string::Nsid<'a>>,
+    >,
     /// The set of subject types (account, record, etc) this service accepts reports on.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_types: Option<Vec<crate::com_atproto::moderation::SubjectType<'a>>>,
+    pub subject_types: std::option::Option<
+        Vec<crate::com_atproto::moderation::SubjectType<'a>>,
+    >,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::labeler::LabelerViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::labeler::LabelerViewerState<'a>>,
 }
 
 pub mod labeler_view_detailed_state {

crates/weaver-api/src/app_bsky/labeler/service.rs

···
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<crate::com_atproto::label::SelfLabels<'a>>,
+    pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,
     #[serde(borrow)]
     pub policies: crate::app_bsky::labeler::LabelerPolicies<'a>,
     /// The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reason_types: Option<Vec<crate::com_atproto::moderation::ReasonType<'a>>>,
+    pub reason_types: std::option::Option<
+        Vec<crate::com_atproto::moderation::ReasonType<'a>>,
+    >,
     /// Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_collections: Option<Vec<jacquard_common::types::string::Nsid<'a>>>,
+    pub subject_collections: std::option::Option<
+        Vec<jacquard_common::types::string::Nsid<'a>>,
+    >,
     /// The set of subject types (account, record, etc) this service accepts reports on.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_types: Option<Vec<crate::com_atproto::moderation::SubjectType<'a>>>,
+    pub subject_types: std::option::Option<
+        Vec<crate::com_atproto::moderation::SubjectType<'a>>,
+    >,
 }
 
 pub mod service_state {

crates/weaver-api/src/app_bsky/notification/list_notifications.rs

···
     pub is_read: bool,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     /// The reason why this notification was delivered - e.g. your post was liked, or you received a new follower.
     #[serde(borrow)]
     pub reason: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reason_subject: Option<jacquard_common::types::string::AtUri<'a>>,
+    pub reason_subject: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
     #[serde(borrow)]
     pub record: jacquard_common::types::value::Data<'a>,
     #[serde(borrow)]

crates/weaver-api/src/app_bsky/notification/register_push.rs

···
 pub struct RegisterPush<'a> {
     /// Set to true when the actor is age restricted
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub age_restricted: Option<bool>,
+    pub age_restricted: std::option::Option<bool>,
     #[serde(borrow)]
     pub app_id: jacquard_common::CowStr<'a>,
     #[serde(borrow)]

crates/weaver-api/src/app_bsky/unspecced.rs

···
     /// The IP address used when completing the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub complete_ip: Option<jacquard_common::CowStr<'a>>,
+    pub complete_ip: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The user agent used when completing the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub complete_ua: Option<jacquard_common::CowStr<'a>>,
+    pub complete_ua: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The date and time of this write operation.
     pub created_at: jacquard_common::types::string::Datetime,
     /// The email used for AA.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub email: Option<jacquard_common::CowStr<'a>>,
+    pub email: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The IP address used when initiating the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub init_ip: Option<jacquard_common::CowStr<'a>>,
+    pub init_ip: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The user agent used when initiating the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub init_ua: Option<jacquard_common::CowStr<'a>>,
+    pub init_ua: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The status of the age assurance process.
     #[serde(borrow)]
     pub status: jacquard_common::CowStr<'a>,
···
 pub struct SkeletonTrend<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub category: Option<jacquard_common::CowStr<'a>>,
+    pub category: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub dids: Vec<jacquard_common::types::string::Did<'a>>,
     #[serde(borrow)]
···
     pub started_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<jacquard_common::CowStr<'a>>,
+    pub status: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub topic: jacquard_common::CowStr<'a>,
 }
···
     pub actors: Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub category: Option<jacquard_common::CowStr<'a>>,
+    pub category: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub display_name: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
···
     pub started_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<jacquard_common::CowStr<'a>>,
+    pub status: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub topic: jacquard_common::CowStr<'a>,
 }

crates/weaver-api/src/app_bsky/video.rs

···
 pub struct JobStatus<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub blob: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub blob: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub error: Option<jacquard_common::CowStr<'a>>,
+    pub error: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub job_id: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub message: Option<jacquard_common::CowStr<'a>>,
+    pub message: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Progress within the current processing state.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub progress: Option<i64>,
+    pub progress: std::option::Option<i64>,
     /// The state of the video processing job. All values not listed as a known value indicate that the job is in process.
     #[serde(borrow)]
     pub state: jacquard_common::CowStr<'a>,

crates/weaver-api/src/chat_bsky/actor.rs

···
 pub struct ProfileViewBasic<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
+    pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     /// Set to true when the actor cannot actively participate in conversations
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub chat_disabled: Option<bool>,
+    pub chat_disabled: std::option::Option<bool>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
+    pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
+    pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
 }
 
 pub mod profile_view_basic_state {

crates/weaver-api/src/chat_bsky/convo.rs

···
     pub id: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub last_message: Option<ConvoViewLastMessage<'a>>,
+    pub last_message: std::option::Option<ConvoViewLastMessage<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub last_reaction: Option<crate::chat_bsky::convo::MessageAndReactionView<'a>>,
+    pub last_reaction: std::option::Option<
+        crate::chat_bsky::convo::MessageAndReactionView<'a>,
+    >,
     #[serde(borrow)]
     pub members: Vec<crate::chat_bsky::actor::ProfileViewBasic<'a>>,
     pub muted: bool,
···
     pub rev: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<jacquard_common::CowStr<'a>>,
+    pub status: std::option::Option<jacquard_common::CowStr<'a>>,
     pub unread_count: i64,
 }
 
···
 pub struct MessageView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embed: Option<crate::app_bsky::embed::record::View<'a>>,
+    pub embed: std::option::Option<crate::app_bsky::embed::record::View<'a>>,
     /// Annotations of text (mentions, URLs, hashtags, etc)
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
+    pub facets: std::option::Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
     #[serde(borrow)]
     pub id: jacquard_common::CowStr<'a>,
     /// Reactions to this message, in ascending order of creation time.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reactions: Option<Vec<crate::chat_bsky::convo::ReactionView<'a>>>,
+    pub reactions: std::option::Option<Vec<crate::chat_bsky::convo::ReactionView<'a>>>,
     #[serde(borrow)]
     pub rev: jacquard_common::CowStr<'a>,
     #[serde(borrow)]

crates/weaver-api/src/chat_bsky/moderation/update_actor_access.rs

···
     pub allow_access: bool,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub r#ref: Option<jacquard_common::CowStr<'a>>,
+    pub r#ref: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod update_actor_access_state {

crates/weaver-api/src/com_atproto/admin.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct AccountView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub deactivated_at: Option<jacquard_common::types::string::Datetime>,
+    pub deactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub email: Option<jacquard_common::CowStr<'a>>,
+    pub email: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub email_confirmed_at: Option<jacquard_common::types::string::Datetime>,
+    pub email_confirmed_at: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invite_note: Option<jacquard_common::CowStr<'a>>,
+    pub invite_note: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invited_by: Option<crate::com_atproto::server::InviteCode<'a>>,
+    pub invited_by: std::option::Option<crate::com_atproto::server::InviteCode<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invites: Option<Vec<crate::com_atproto::server::InviteCode<'a>>>,
+    pub invites: std::option::Option<Vec<crate::com_atproto::server::InviteCode<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub invites_disabled: Option<bool>,
+    pub invites_disabled: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub related_records: Option<Vec<jacquard_common::types::value::Data<'a>>>,
+    pub related_records: std::option::Option<
+        Vec<jacquard_common::types::value::Data<'a>>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub threat_signatures: Option<Vec<crate::com_atproto::admin::ThreatSignature<'a>>>,
+    pub threat_signatures: std::option::Option<
+        Vec<crate::com_atproto::admin::ThreatSignature<'a>>,
+    >,
 }
 
 pub mod account_view_state {
···
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub record_uri: Option<jacquard_common::types::string::AtUri<'a>>,
+    pub record_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
 }
 
 pub mod repo_blob_ref_state {
···
     pub applied: bool,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub r#ref: Option<jacquard_common::CowStr<'a>>,
+    pub r#ref: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod status_attr_state {

crates/weaver-api/src/com_atproto/admin/disable_account_invites.rs

···
     /// Optional reason for disabled invites.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub note: Option<jacquard_common::CowStr<'a>>,
+    pub note: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod disable_account_invites_state {

crates/weaver-api/src/com_atproto/admin/enable_account_invites.rs

···
     /// Optional reason for enabled invites.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub note: Option<jacquard_common::CowStr<'a>>,
+    pub note: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod enable_account_invites_state {

crates/weaver-api/src/com_atproto/admin/send_email.rs

···
     /// Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub content: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
···
     pub sender_did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject: Option<jacquard_common::CowStr<'a>>,
+    pub subject: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod send_email_state {

crates/weaver-api/src/com_atproto/admin/update_subject_status.rs

···
 pub struct UpdateSubjectStatus<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub deactivated: Option<crate::com_atproto::admin::StatusAttr<'a>>,
+    pub deactivated: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,
     #[serde(borrow)]
     pub subject: UpdateSubjectStatusSubject<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub takedown: Option<crate::com_atproto::admin::StatusAttr<'a>>,
+    pub takedown: std::option::Option<crate::com_atproto::admin::StatusAttr<'a>>,
 }
 
 pub mod update_subject_status_state {

crates/weaver-api/src/com_atproto/label.rs

···
     /// Optionally, CID specifying the specific version of 'uri' resource this label applies to.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub cid: Option<jacquard_common::types::string::Cid<'a>>,
+    pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     /// Timestamp when this label was created.
     pub cts: jacquard_common::types::string::Datetime,
     /// Timestamp at which this label expires (no longer applies).
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub exp: Option<jacquard_common::types::string::Datetime>,
+    pub exp: std::option::Option<jacquard_common::types::string::Datetime>,
     /// If true, this is a negation label, overwriting a previous label.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub neg: Option<bool>,
+    pub neg: std::option::Option<bool>,
     /// Signature of dag-cbor encoded label.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub sig: Option<bytes::Bytes>,
+    pub sig: std::option::Option<bytes::Bytes>,
     /// DID of the actor who created this label.
     #[serde(borrow)]
     pub src: jacquard_common::types::string::Did<'a>,
···
     pub val: jacquard_common::CowStr<'a>,
     /// The AT Protocol version of the label object.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub ver: Option<i64>,
+    pub ver: std::option::Option<i64>,
 }
 
 pub mod label_state {
···
 pub struct LabelValueDefinition<'a> {
     /// Does the user need to have adult content enabled in order to configure this label?
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub adult_only: Option<bool>,
+    pub adult_only: std::option::Option<bool>,
     /// What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.
     #[serde(borrow)]
     pub blurs: jacquard_common::CowStr<'a>,
     /// The default setting for this label.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub default_setting: Option<jacquard_common::CowStr<'a>>,
+    pub default_setting: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).
     #[serde(borrow)]
     pub identifier: jacquard_common::CowStr<'a>,

crates/weaver-api/src/com_atproto/moderation/create_report.rs

···
 pub struct CreateReport<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub mod_tool: Option<crate::com_atproto::moderation::create_report::ModTool<'a>>,
+    pub mod_tool: std::option::Option<
+        crate::com_atproto::moderation::create_report::ModTool<'a>,
+    >,
     /// Additional context about the content and violation.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reason: Option<jacquard_common::CowStr<'a>>,
+    pub reason: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Indicates the broad category of violation the report is for.
     #[serde(borrow)]
     pub reason_type: crate::com_atproto::moderation::ReasonType<'a>,

crates/weaver-api/src/com_atproto/repo/apply_writes.rs

···
     /// NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub rkey: Option<
+    pub rkey: std::option::Option<
         jacquard_common::types::string::RecordKey<
             jacquard_common::types::string::Rkey<'a>,
         >,
···
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub validation_status: Option<jacquard_common::CowStr<'a>>,
+    pub validation_status: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod create_result_state {
···
     /// If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub swap_commit: Option<jacquard_common::types::string::Cid<'a>>,
+    pub swap_commit: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     /// Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub validate: Option<bool>,
+    pub validate: std::option::Option<bool>,
     #[serde(borrow)]
     pub writes: Vec<ApplyWritesWritesItem<'a>>,
 }
···
     pub uri: jacquard_common::types::string::AtUri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub validation_status: Option<jacquard_common::CowStr<'a>>,
+    pub validation_status: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod update_result_state {

crates/weaver-api/src/com_atproto/repo/create_record.rs

···
     /// The Record Key.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub rkey: Option<
+    pub rkey: std::option::Option<
         jacquard_common::types::string::RecordKey<
             jacquard_common::types::string::Rkey<'a>,
         >,
···
     /// Compare and swap with the previous commit by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub swap_commit: Option<jacquard_common::types::string::Cid<'a>>,
+    pub swap_commit: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     /// Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub validate: Option<bool>,
+    pub validate: std::option::Option<bool>,
 }
 
 pub mod create_record_state {

crates/weaver-api/src/com_atproto/repo/delete_record.rs

···
     /// Compare and swap with the previous commit by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub swap_commit: Option<jacquard_common::types::string::Cid<'a>>,
+    pub swap_commit: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     /// Compare and swap with the previous record by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub swap_record: Option<jacquard_common::types::string::Cid<'a>>,
+    pub swap_record: std::option::Option<jacquard_common::types::string::Cid<'a>>,
 }
 
 pub mod delete_record_state {

crates/weaver-api/src/com_atproto/repo/put_record.rs

···
     /// Compare and swap with the previous commit by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub swap_commit: Option<jacquard_common::types::string::Cid<'a>>,
+    pub swap_commit: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     /// Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub swap_record: Option<jacquard_common::types::string::Cid<'a>>,
+    pub swap_record: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     /// Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub validate: Option<bool>,
+    pub validate: std::option::Option<bool>,
 }
 
 pub mod put_record_state {

crates/weaver-api/src/com_atproto/server/create_account.rs

···
     /// Pre-existing atproto DID, being imported to a new account.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub did: Option<jacquard_common::types::string::Did<'a>>,
+    pub did: std::option::Option<jacquard_common::types::string::Did<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub email: Option<jacquard_common::CowStr<'a>>,
+    pub email: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Requested handle for the account.
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invite_code: Option<jacquard_common::CowStr<'a>>,
+    pub invite_code: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Initial account password. May need to meet instance-specific password strength requirements.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub password: Option<jacquard_common::CowStr<'a>>,
+    pub password: std::option::Option<jacquard_common::CowStr<'a>>,
     /// A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub plc_op: Option<jacquard_common::types::value::Data<'a>>,
+    pub plc_op: std::option::Option<jacquard_common::types::value::Data<'a>>,
     /// DID PLC rotation key (aka, recovery key) to be included in PLC creation operation.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub recovery_key: Option<jacquard_common::CowStr<'a>>,
+    pub recovery_key: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification_code: Option<jacquard_common::CowStr<'a>>,
+    pub verification_code: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification_phone: Option<jacquard_common::CowStr<'a>>,
+    pub verification_phone: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod create_account_state {

crates/weaver-api/src/com_atproto/server/create_app_password.rs

···
     #[serde(borrow)]
     pub password: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub privileged: Option<bool>,
+    pub privileged: std::option::Option<bool>,
 }
 
 pub mod app_password_state {

crates/weaver-api/src/com_atproto/server/create_invite_code.rs

···
 pub struct CreateInviteCode<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub for_account: Option<jacquard_common::types::string::Did<'a>>,
+    pub for_account: std::option::Option<jacquard_common::types::string::Did<'a>>,
     pub use_count: i64,
 }
 

crates/weaver-api/src/com_atproto/server/create_invite_codes.rs

···
     pub code_count: i64,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub for_accounts: Option<Vec<jacquard_common::types::string::Did<'a>>>,
+    pub for_accounts: std::option::Option<Vec<jacquard_common::types::string::Did<'a>>>,
     pub use_count: i64,
 }
 

crates/weaver-api/src/com_atproto/server/list_app_passwords.rs

···
     #[serde(borrow)]
     pub name: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub privileged: Option<bool>,
+    pub privileged: std::option::Option<bool>,
 }
 
 pub mod app_password_state {

crates/weaver-api/src/com_atproto/sync/list_repos.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct Repo<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub active: Option<bool>,
+    pub active: std::option::Option<bool>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     /// Current repo commit CID
···
     /// If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<jacquard_common::CowStr<'a>>,
+    pub status: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod repo_state {

crates/weaver-api/src/com_atproto/sync/subscribe_repos.rs

···
     /// If active=false, this optional field indicates a reason for why the account is not active.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<jacquard_common::CowStr<'a>>,
+    pub status: std::option::Option<jacquard_common::CowStr<'a>>,
     pub time: jacquard_common::types::string::Datetime,
 }
 
···
     /// The root CID of the MST tree for the previous commit from this repo (indicated by the 'since' revision field in this message). Corresponds to the 'data' field in the repo commit object. NOTE: this field is effectively required for the 'inductive' version of firehose.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub prev_data: Option<jacquard_common::types::cid::CidLink<'a>>,
+    pub prev_data: std::option::Option<jacquard_common::types::cid::CidLink<'a>>,
     /// DEPRECATED -- unused
     pub rebase: bool,
     /// The repo this event comes from. Note that all other message types name this field 'did'.
···
     /// The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub handle: Option<jacquard_common::types::string::Handle<'a>>,
+    pub handle: std::option::Option<jacquard_common::types::string::Handle<'a>>,
     pub seq: i64,
     pub time: jacquard_common::types::string::Datetime,
 }
···
     /// For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub prev: Option<jacquard_common::types::cid::CidLink<'a>>,
+    pub prev: std::option::Option<jacquard_common::types::cid::CidLink<'a>>,
 }
 
 pub mod repo_op_state {

crates/weaver-api/src/sh_weaver/actor.rs

···
     pub did: jacquard_common::types::string::Did<'a>,
     /// signed bytes of the corresponding notebook record in the author's repo
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub signature: Option<bytes::Bytes>,
+    pub signature: std::option::Option<bytes::Bytes>,
 }
 
 pub mod author_state {
···
 pub struct ProfileView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub banner: Option<jacquard_common::types::string::Uri<'a>>,
+    pub banner: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     /// Include link to this account on Bluesky.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub bluesky: Option<bool>,
+    pub bluesky: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub indexed_at: Option<jacquard_common::types::string::Datetime>,
+    pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub links: Option<Vec<jacquard_common::types::string::Uri<'a>>>,
+    pub links: std::option::Option<Vec<jacquard_common::types::string::Uri<'a>>>,
     /// Free-form location text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub location: Option<jacquard_common::CowStr<'a>>,
+    pub location: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Notebooks or other records pinned for display.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pinned: Option<crate::sh_weaver::actor::PinnedList<'a>>,
+    pub pinned: std::option::Option<crate::sh_weaver::actor::PinnedList<'a>>,
     /// Pronouns to use in user-generated content.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<crate::sh_weaver::actor::PronounsList<'a>>,
+    pub pronouns: std::option::Option<crate::sh_weaver::actor::PronounsList<'a>>,
     /// Include link to this account on stream.place.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub streamplace: Option<bool>,
+    pub streamplace: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub subscribed_count: Option<i64>,
+    pub subscribed_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub subscriber_count: Option<i64>,
+    pub subscriber_count: std::option::Option<i64>,
     /// Include link to this account on Tangled.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub tangled: Option<bool>,
+    pub tangled: std::option::Option<bool>,
 }
 
 pub mod profile_view_state {
···
 pub struct ProfileViewBasic<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub indexed_at: Option<jacquard_common::types::string::Datetime>,
+    pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     /// Pronouns to use in user-generated content.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<crate::sh_weaver::actor::PronounsList<'a>>,
+    pub pronouns: std::option::Option<crate::sh_weaver::actor::PronounsList<'a>>,
 }
 
 pub mod profile_view_basic_state {
···
     /// Free-form profile description text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub links: Option<Vec<jacquard_common::types::string::Uri<'a>>>,
+    pub links: std::option::Option<Vec<jacquard_common::types::string::Uri<'a>>>,
     /// Free-form location text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub location: Option<jacquard_common::CowStr<'a>>,
+    pub location: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Any ATURI, it is up to appviews to validate these fields.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pinned_repositories: Option<Vec<jacquard_common::types::string::AtUri<'a>>>,
+    pub pinned_repositories: std::option::Option<
+        Vec<jacquard_common::types::string::AtUri<'a>>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub stats: Option<Vec<jacquard_common::CowStr<'a>>>,
+    pub stats: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
 }
 
 pub mod tangled_profile_view_state {

crates/weaver-api/src/sh_weaver/actor/profile.rs

···
     /// Small image to be displayed next to posts from account. AKA, 'profile picture'
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub avatar: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub avatar: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     /// Larger horizontal image to display behind profile view.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub banner: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub banner: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     /// Include link to this account on Bluesky.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub bluesky: Option<bool>,
+    pub bluesky: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Free-form profile description text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub display_name: Option<jacquard_common::CowStr<'a>>,
+    pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Self-label values, specific to the application, on the overall account.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<crate::com_atproto::label::SelfLabels<'a>>,
+    pub labels: std::option::Option<crate::com_atproto::label::SelfLabels<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub links: Option<Vec<jacquard_common::types::string::Uri<'a>>>,
+    pub links: std::option::Option<Vec<jacquard_common::types::string::Uri<'a>>>,
     /// Free-form location text.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub location: Option<jacquard_common::CowStr<'a>>,
+    pub location: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Notebooks or other records pinned for display.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pinned: Option<crate::sh_weaver::actor::PinnedList<'a>>,
+    pub pinned: std::option::Option<crate::sh_weaver::actor::PinnedList<'a>>,
     /// Pronouns to use in user-generated content.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pronouns: Option<crate::sh_weaver::actor::PronounsList<'a>>,
+    pub pronouns: std::option::Option<crate::sh_weaver::actor::PronounsList<'a>>,
     /// Include link to this account on stream.place.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub streamplace: Option<bool>,
+    pub streamplace: std::option::Option<bool>,
     /// Include link to this account on Tangled.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub tangled: Option<bool>,
+    pub tangled: std::option::Option<bool>,
 }
 
 pub mod profile_state {

crates/weaver-api/src/sh_weaver/edit/cursor.rs

···
     pub id: crate::sh_weaver::edit::cursor::Id<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub side: Option<crate::sh_weaver::edit::cursor::CursorSide<'a>>,
+    pub side: std::option::Option<crate::sh_weaver::edit::cursor::CursorSide<'a>>,
 }
 
 pub mod cursor_state {

crates/weaver-api/src/sh_weaver/embed/external.rs

···
     pub description: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thumb: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub thumb: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     #[serde(borrow)]
     pub title: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
···
     pub description: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thumb: Option<jacquard_common::types::string::Uri<'a>>,
+    pub thumb: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     #[serde(borrow)]
     pub title: jacquard_common::CowStr<'a>,
     #[serde(borrow)]

crates/weaver-api/src/sh_weaver/embed/images.rs

···
     /// Blurhash string for the image, used for low-resolution placeholders. This must be a valid Blurhash string.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub blurhash: Option<jacquard_common::CowStr<'a>>,
+    pub blurhash: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub dimensions: Option<ImageDimensions<'a>>,
+    pub dimensions: std::option::Option<ImageDimensions<'a>>,
     #[serde(borrow)]
     pub image: jacquard_common::types::blob::BlobRef<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub name: Option<jacquard_common::CowStr<'a>>,
+    pub name: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod image_state {
···
     pub alt: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub dimensions: Option<ViewImageDimensions<'a>>,
+    pub dimensions: std::option::Option<ViewImageDimensions<'a>>,
     /// Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View.
     #[serde(borrow)]
     pub fullsize: jacquard_common::types::string::Uri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub name: Option<jacquard_common::CowStr<'a>>,
+    pub name: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View.
     #[serde(borrow)]
     pub thumb: jacquard_common::types::string::Uri<'a>,

crates/weaver-api/src/sh_weaver/embed/record_with_media.rs

···
     pub media: ViewMedia<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub records: Option<crate::sh_weaver::embed::records::View<'a>>,
+    pub records: std::option::Option<crate::sh_weaver::embed::records::View<'a>>,
 }
 
 pub mod view_state {

crates/weaver-api/src/sh_weaver/embed/records.rs

···
 pub struct RecordEmbed<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub name: Option<jacquard_common::CowStr<'a>>,
+    pub name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub record: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
 }
···
 pub struct RecordEmbedView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub name: Option<jacquard_common::CowStr<'a>>,
+    pub name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub record_view: RecordEmbedViewRecordView<'a>,
 }
···
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embeds: Option<Vec<crate::sh_weaver::embed::records::RecordEmbedView<'a>>>,
+    pub embeds: std::option::Option<
+        Vec<crate::sh_weaver::embed::records::RecordEmbedView<'a>>,
+    >,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub like_count: Option<i64>,
+    pub like_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub quote_count: Option<i64>,
+    pub quote_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub reply_count: Option<i64>,
+    pub reply_count: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub repost_count: Option<i64>,
+    pub repost_count: std::option::Option<i64>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
     /// The record data itself.

crates/weaver-api/src/sh_weaver/embed/video.rs

···
     /// Alt text description of the video, for accessibility.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub alt: Option<jacquard_common::CowStr<'a>>,
+    pub alt: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub captions: Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
+    pub captions: std::option::Option<Vec<crate::sh_weaver::embed::video::Caption<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub dimensions: Option<VideoDimensions<'a>>,
+    pub dimensions: std::option::Option<VideoDimensions<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub name: Option<jacquard_common::CowStr<'a>>,
+    pub name: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The mp4 video file. May be up to 100mb, formerly limited to 50mb.
     #[serde(borrow)]
     pub video: jacquard_common::types::blob::BlobRef<'a>,
···
 pub struct View<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub alt: Option<jacquard_common::CowStr<'a>>,
+    pub alt: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub cid: jacquard_common::types::string::Cid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub dimensions: Option<ViewDimensions<'a>>,
+    pub dimensions: std::option::Option<ViewDimensions<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub name: Option<jacquard_common::CowStr<'a>>,
+    pub name: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub playlist: jacquard_common::types::string::Uri<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub thumbnail: Option<jacquard_common::types::string::Uri<'a>>,
+    pub thumbnail: std::option::Option<jacquard_common::types::string::Uri<'a>>,
 }
 
 pub mod view_state {

crates/weaver-api/src/sh_weaver/notebook.rs

···
     pub record: crate::sh_weaver::actor::ProfileDataView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub uri: Option<jacquard_common::types::string::AtUri<'a>>,
+    pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
 }
 
 pub mod author_list_view_state {
···
     pub index: i64,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub next: Option<crate::sh_weaver::notebook::BookEntryRef<'a>>,
+    pub next: std::option::Option<crate::sh_weaver::notebook::BookEntryRef<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub prev: Option<crate::sh_weaver::notebook::BookEntryRef<'a>>,
+    pub prev: std::option::Option<crate::sh_weaver::notebook::BookEntryRef<'a>>,
 }
 
 pub mod book_entry_view_state {
···
     pub record: jacquard_common::types::value::Data<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub rendered_view: Option<crate::sh_weaver::notebook::RenderedView<'a>>,
+    pub rendered_view: std::option::Option<crate::sh_weaver::notebook::RenderedView<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
+    pub tags: std::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub title: Option<crate::sh_weaver::notebook::Title<'a>>,
+    pub title: std::option::Option<crate::sh_weaver::notebook::Title<'a>>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
 }
···
     pub record: jacquard_common::types::value::Data<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
+    pub tags: std::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub title: Option<crate::sh_weaver::notebook::Title<'a>>,
+    pub title: std::option::Option<crate::sh_weaver::notebook::Title<'a>>,
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,
 }
···
 pub struct RenderedView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub css: Option<jacquard_common::types::blob::BlobRef<'a>>,
+    pub css: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     #[serde(borrow)]
     pub html: jacquard_common::types::blob::BlobRef<'a>,
 }

crates/weaver-api/src/sh_weaver/notebook/authors.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct AuthorListItem<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub index: Option<i64>,
+    pub index: std::option::Option<i64>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub profile: Option<AuthorListItemProfile<'a>>,
+    pub profile: std::option::Option<AuthorListItemProfile<'a>>,
 }
 
 pub mod author_list_item_state {
···
     #[serde(borrow)]
     pub author_list: Vec<crate::sh_weaver::notebook::authors::AuthorListItem<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
 }
 
 pub mod authors_state {

crates/weaver-api/src/sh_weaver/notebook/book.rs

···
     pub authors: Vec<crate::sh_weaver::actor::Author<'a>>,
     /// Client-declared timestamp when this was originally created.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub entry_list: Vec<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub path: Option<crate::sh_weaver::notebook::Path<'a>>,
+    pub path: std::option::Option<crate::sh_weaver::notebook::Path<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
+    pub tags: std::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub theme: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub theme: std::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub title: Option<crate::sh_weaver::notebook::Title<'a>>,
+    pub title: std::option::Option<crate::sh_weaver::notebook::Title<'a>>,
 }
 
 pub mod book_state {

crates/weaver-api/src/sh_weaver/notebook/chapter.rs

···
     pub authors: Vec<crate::sh_weaver::actor::Author<'a>>,
     /// Client-declared timestamp when this was originally created.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub entry_list: Vec<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
     /// The notebook this chapter belongs to.
···
     pub notebook: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
+    pub tags: std::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub title: Option<crate::sh_weaver::notebook::Title<'a>>,
+    pub title: std::option::Option<crate::sh_weaver::notebook::Title<'a>>,
 }
 
 pub mod chapter_state {

crates/weaver-api/src/sh_weaver/notebook/entry.rs

···
     /// The set of images and records, if any, embedded in the notebook entry.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub embeds: Option<EntryEmbeds<'a>>,
+    pub embeds: std::option::Option<EntryEmbeds<'a>>,
     #[serde(borrow)]
     pub path: crate::sh_weaver::notebook::Path<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
+    pub tags: std::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(borrow)]
     pub title: crate::sh_weaver::notebook::Title<'a>,
 }

crates/weaver-api/src/sh_weaver/notebook/page.rs

···
 pub struct Page<'a> {
     /// Client-declared timestamp when this was originally created.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub entry_list: Vec<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
     /// The notebook this page belongs to.
···
     pub notebook: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<crate::sh_weaver::notebook::Tags<'a>>,
+    pub tags: std::option::Option<crate::sh_weaver::notebook::Tags<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub title: Option<crate::sh_weaver::notebook::Title<'a>>,
+    pub title: std::option::Option<crate::sh_weaver::notebook::Title<'a>>,
 }
 
 pub mod page_state {

crates/weaver-api/src/sh_weaver/notebook/theme.rs

···
     pub dark_scheme: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub default_theme: Option<jacquard_common::CowStr<'a>>,
+    pub default_theme: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub fonts: ThemeFonts<'a>,
     /// Syntax highlighting theme for light mode

crates/weaver-api/src/tools_ozone/communication.rs

···
     pub id: jacquard_common::CowStr<'a>,
     /// Message language.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub lang: Option<jacquard_common::types::string::Language>,
+    pub lang: std::option::Option<jacquard_common::types::string::Language>,
     /// DID of the user who last updated the template.
     #[serde(borrow)]
     pub last_updated_by: jacquard_common::types::string::Did<'a>,
···
     /// Content of the template, can contain markdown and variable placeholders.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject: Option<jacquard_common::CowStr<'a>>,
+    pub subject: std::option::Option<jacquard_common::CowStr<'a>>,
     pub updated_at: jacquard_common::types::string::Datetime,
 }
 

crates/weaver-api/src/tools_ozone/moderation.rs

···
     pub active: bool,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<jacquard_common::CowStr<'a>>,
+    pub status: std::option::Option<jacquard_common::CowStr<'a>>,
     pub timestamp: jacquard_common::types::string::Datetime,
 }
 
···
                             }),
                         );
                         map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "isDelivered",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
+                                description: None,
+                                default: None,
+                                r#const: None,
+                            }),
+                        );
+                        map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static("policies"),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
                                 description: Some(
···
                                 r#enum: None,
                                 r#const: None,
                                 known_values: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "targetServices",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
+                                description: Some(
+                                    ::jacquard_common::CowStr::new_static(
+                                        "List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services.",
+                                    ),
+                                ),
+                                items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
+                                    description: None,
+                                    format: None,
+                                    default: None,
+                                    min_length: None,
+                                    max_length: None,
+                                    min_graphemes: None,
+                                    max_graphemes: None,
+                                    r#enum: None,
+                                    r#const: None,
+                                    known_values: None,
+                                }),
+                                min_length: None,
+                                max_length: None,
                             }),
                         );
                         map
···
     /// The IP address used when completing the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub complete_ip: Option<jacquard_common::CowStr<'a>>,
+    pub complete_ip: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The user agent used when completing the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub complete_ua: Option<jacquard_common::CowStr<'a>>,
+    pub complete_ua: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The date and time of this write operation.
     pub created_at: jacquard_common::types::string::Datetime,
     /// The IP address used when initiating the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub init_ip: Option<jacquard_common::CowStr<'a>>,
+    pub init_ip: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The user agent used when initiating the AA flow.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub init_ua: Option<jacquard_common::CowStr<'a>>,
+    pub init_ua: std::option::Option<jacquard_common::CowStr<'a>>,
     /// The status of the age assurance process.
     #[serde(borrow)]
     pub status: jacquard_common::CowStr<'a>,
···
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub details: Option<BlobViewDetails<'a>>,
+    pub details: std::option::Option<BlobViewDetails<'a>>,
     #[serde(borrow)]
     pub mime_type: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub moderation: Option<crate::tools_ozone::moderation::Moderation<'a>>,
+    pub moderation: std::option::Option<crate::tools_ozone::moderation::Moderation<'a>>,
     pub size: i64,
 }
 
···
 pub struct IdentityEvent<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub handle: Option<jacquard_common::types::string::Handle<'a>>,
+    pub handle: std::option::Option<jacquard_common::types::string::Handle<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub pds_host: Option<jacquard_common::types::string::Uri<'a>>,
+    pub pds_host: std::option::Option<jacquard_common::types::string::Uri<'a>>,
     pub timestamp: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub tombstone: Option<bool>,
+    pub tombstone: std::option::Option<bool>,
 }
 
 pub mod identity_event_state {
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub content: std::option::Option<jacquard_common::CowStr<'a>>,
+    /// Indicates whether the email was successfully delivered to the user's inbox.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    pub is_delivered: std::option::Option<bool>,
     /// Names/Keywords of the policies that necessitated the email.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
···
 pub struct ModEventLabel<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub create_label_vals: Vec<jacquard_common::CowStr<'a>>,
     /// Indicates how long the label will remain on the subject. Only applies on labels that are being added.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub duration_in_hours: Option<i64>,
+    pub duration_in_hours: std::option::Option<i64>,
     #[serde(borrow)]
     pub negate_label_vals: Vec<jacquard_common::CowStr<'a>>,
 }
···
 pub struct ModEventMute<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Indicates how long the subject should remain muted.
     pub duration_in_hours: i64,
 }
···
 pub struct ModEventPriorityScore<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     pub score: i64,
 }
 
···
 pub struct ModEventReport<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub is_reporter_muted: Option<bool>,
+    pub is_reporter_muted: std::option::Option<bool>,
     #[serde(borrow)]
     pub report_type: crate::com_atproto::moderation::ReasonType<'a>,
 }
···
     /// Additional comment about added/removed tags.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated.
     #[serde(borrow)]
     pub remove: Vec<jacquard_common::CowStr<'a>>,
···
     /// When the strike should expire. If not provided, the strike never expires.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub strike_expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
+    /// List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub target_services: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
 }
 
 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ModEventTakedown<'a> {
···
     pub created_by: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub creator_handle: Option<jacquard_common::CowStr<'a>>,
+    pub creator_handle: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub event: ModEventViewEvent<'a>,
     pub id: i64,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub mod_tool: Option<crate::tools_ozone::moderation::ModTool<'a>>,
+    pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,
     #[serde(borrow)]
     pub subject: ModEventViewSubject<'a>,
     #[serde(borrow)]
     pub subject_blob_cids: Vec<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_handle: Option<jacquard_common::CowStr<'a>>,
+    pub subject_handle: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod mod_event_view_state {
···
     pub id: i64,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub mod_tool: Option<crate::tools_ozone::moderation::ModTool<'a>>,
+    pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,
     #[serde(borrow)]
     pub subject: ModEventViewDetailSubject<'a>,
     #[serde(borrow)]
···
 pub struct RecordEvent<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub cid: Option<jacquard_common::types::string::Cid<'a>>,
+    pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub op: jacquard_common::CowStr<'a>,
     pub timestamp: jacquard_common::types::string::Datetime,
···
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(borrow)]
     pub moderation: crate::tools_ozone::moderation::ModerationDetail<'a>,
     #[serde(borrow)]
···
 #[serde(rename_all = "camelCase")]
 pub struct RepoView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub deactivated_at: Option<jacquard_common::types::string::Datetime>,
+    pub deactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub email: Option<jacquard_common::CowStr<'a>>,
+    pub email: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invite_note: Option<jacquard_common::CowStr<'a>>,
+    pub invite_note: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invited_by: Option<crate::com_atproto::server::InviteCode<'a>>,
+    pub invited_by: std::option::Option<crate::com_atproto::server::InviteCode<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub invites_disabled: Option<bool>,
+    pub invites_disabled: std::option::Option<bool>,
     #[serde(borrow)]
     pub moderation: crate::tools_ozone::moderation::Moderation<'a>,
     #[serde(borrow)]
     pub related_records: Vec<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub threat_signatures: Option<Vec<crate::com_atproto::admin::ThreatSignature<'a>>>,
+    pub threat_signatures: std::option::Option<
+        Vec<crate::com_atproto::admin::ThreatSignature<'a>>,
+    >,
 }
 
 pub mod repo_view_state {
···
 #[serde(rename_all = "camelCase")]
 pub struct RepoViewDetail<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub deactivated_at: Option<jacquard_common::types::string::Datetime>,
+    pub deactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub email: Option<jacquard_common::CowStr<'a>>,
+    pub email: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub email_confirmed_at: Option<jacquard_common::types::string::Datetime>,
+    pub email_confirmed_at: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(borrow)]
     pub handle: jacquard_common::types::string::Handle<'a>,
     pub indexed_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invite_note: Option<jacquard_common::CowStr<'a>>,
+    pub invite_note: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invited_by: Option<crate::com_atproto::server::InviteCode<'a>>,
+    pub invited_by: std::option::Option<crate::com_atproto::server::InviteCode<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub invites: Option<Vec<crate::com_atproto::server::InviteCode<'a>>>,
+    pub invites: std::option::Option<Vec<crate::com_atproto::server::InviteCode<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub invites_disabled: Option<bool>,
+    pub invites_disabled: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
+    pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
     #[serde(borrow)]
     pub moderation: crate::tools_ozone::moderation::ModerationDetail<'a>,
     #[serde(borrow)]
     pub related_records: Vec<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub threat_signatures: Option<Vec<crate::com_atproto::admin::ThreatSignature<'a>>>,
+    pub threat_signatures: std::option::Option<
+        Vec<crate::com_atproto::admin::ThreatSignature<'a>>,
+    >,
 }
 
 pub mod repo_view_detail_state {
···
     /// Serialized event object that will be propagated to the event when performed
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub event_data: Option<jacquard_common::types::value::Data<'a>>,
+    pub event_data: std::option::Option<jacquard_common::types::value::Data<'a>>,
     /// Earliest time to execute the action (for randomized scheduling)
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub execute_after: Option<jacquard_common::types::string::Datetime>,
+    pub execute_after: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Exact time to execute the action
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub execute_at: Option<jacquard_common::types::string::Datetime>,
+    pub execute_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Latest time to execute the action (for randomized scheduling)
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub execute_until: Option<jacquard_common::types::string::Datetime>,
+    pub execute_until: std::option::Option<jacquard_common::types::string::Datetime>,
     /// ID of the moderation event created when action was successfully executed
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub execution_event_id: Option<i64>,
+    pub execution_event_id: std::option::Option<i64>,
     /// Auto-incrementing row ID
     pub id: i64,
     /// When the action was last attempted to be executed
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub last_executed_at: Option<jacquard_common::types::string::Datetime>,
+    pub last_executed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Reason for the last execution failure
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub last_failure_reason: Option<jacquard_common::CowStr<'a>>,
+    pub last_failure_reason: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Whether execution time should be randomized within the specified range
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub randomize_execution: Option<bool>,
+    pub randomize_execution: std::option::Option<bool>,
     /// Current status of the scheduled action
     #[serde(borrow)]
     pub status: jacquard_common::CowStr<'a>,
     /// When the scheduled action was last updated
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub updated_at: Option<jacquard_common::types::string::Datetime>,
+    pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
 }
 
 pub mod scheduled_action_view_state {
···
     /// Statistics related to the account subject
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub account_stats: Option<crate::tools_ozone::moderation::AccountStats<'a>>,
+    pub account_stats: std::option::Option<
+        crate::tools_ozone::moderation::AccountStats<'a>,
+    >,
     /// Strike information for the account (account-level only)
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub account_strike: Option<crate::tools_ozone::moderation::AccountStrike<'a>>,
+    pub account_strike: std::option::Option<
+        crate::tools_ozone::moderation::AccountStrike<'a>,
+    >,
     /// Current age assurance state of the subject.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub age_assurance_state: Option<jacquard_common::CowStr<'a>>,
+    pub age_assurance_state: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Whether or not the last successful update to age assurance was made by the user or admin.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub age_assurance_updated_by: Option<jacquard_common::CowStr<'a>>,
+    pub age_assurance_updated_by: std::option::Option<jacquard_common::CowStr<'a>>,
     /// True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub appealed: Option<bool>,
+    pub appealed: std::option::Option<bool>,
     /// Sticky comment on the subject.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Timestamp referencing the first moderation status impacting event was emitted on the subject
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub hosting: Option<SubjectStatusViewHosting<'a>>,
+    pub hosting: std::option::Option<SubjectStatusViewHosting<'a>>,
     pub id: i64,
     /// Timestamp referencing when the author of the subject appealed a moderation action
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub last_appealed_at: Option<jacquard_common::types::string::Datetime>,
+    pub last_appealed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub last_reported_at: Option<jacquard_common::types::string::Datetime>,
+    pub last_reported_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub last_reviewed_at: Option<jacquard_common::types::string::Datetime>,
+    pub last_reviewed_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub last_reviewed_by: Option<jacquard_common::types::string::Did<'a>>,
+    pub last_reviewed_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub mute_reporting_until: Option<jacquard_common::types::string::Datetime>,
+    pub mute_reporting_until: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub mute_until: Option<jacquard_common::types::string::Datetime>,
+    pub mute_until: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Numeric value representing the level of priority. Higher score means higher priority.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub priority_score: Option<i64>,
+    pub priority_score: std::option::Option<i64>,
     /// Statistics related to the record subjects authored by the subject's account
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub records_stats: Option<crate::tools_ozone::moderation::RecordsStats<'a>>,
+    pub records_stats: std::option::Option<
+        crate::tools_ozone::moderation::RecordsStats<'a>,
+    >,
     #[serde(borrow)]
     pub review_state: crate::tools_ozone::moderation::SubjectReviewState<'a>,
     #[serde(borrow)]
     pub subject: SubjectStatusViewSubject<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_blob_cids: Option<Vec<jacquard_common::types::string::Cid<'a>>>,
+    pub subject_blob_cids: std::option::Option<
+        Vec<jacquard_common::types::string::Cid<'a>>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_repo_handle: Option<jacquard_common::CowStr<'a>>,
+    pub subject_repo_handle: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub suspend_until: Option<jacquard_common::types::string::Datetime>,
+    pub suspend_until: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,
+    pub tags: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub takendown: Option<bool>,
+    pub takendown: std::option::Option<bool>,
     /// Timestamp referencing when the last update was made to the moderation status of the subject
     pub updated_at: jacquard_common::types::string::Datetime,
 }
···
 pub struct SubjectView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub profile: Option<jacquard_common::types::value::Data<'a>>,
+    pub profile: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub record: Option<crate::tools_ozone::moderation::RecordViewDetail<'a>>,
+    pub record: std::option::Option<
+        crate::tools_ozone::moderation::RecordViewDetail<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub repo: Option<crate::tools_ozone::moderation::RepoViewDetail<'a>>,
+    pub repo: std::option::Option<crate::tools_ozone::moderation::RepoViewDetail<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub status: Option<crate::tools_ozone::moderation::SubjectStatusView<'a>>,
+    pub status: std::option::Option<
+        crate::tools_ozone::moderation::SubjectStatusView<'a>,
+    >,
     #[serde(borrow)]
     pub subject: jacquard_common::CowStr<'a>,
     #[serde(borrow)]

crates/weaver-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs

···
     pub error: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub error_code: Option<jacquard_common::CowStr<'a>>,
+    pub error_code: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod failed_cancellation_state {
···
     /// Optional comment describing the reason for cancellation
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Array of DID subjects to cancel scheduled actions for
     #[serde(borrow)]
     pub subjects: Vec<jacquard_common::types::string::Did<'a>>,

crates/weaver-api/src/tools_ozone/moderation/emit_event.rs

···
     /// An optional external ID for the event, used to deduplicate events from external systems. Fails when an event of same type with the same external ID exists for the same subject.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub external_id: Option<jacquard_common::CowStr<'a>>,
+    pub external_id: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub mod_tool: Option<crate::tools_ozone::moderation::ModTool<'a>>,
+    pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,
     #[serde(borrow)]
     pub subject: EmitEventSubject<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_blob_cids: Option<Vec<jacquard_common::types::string::Cid<'a>>>,
+    pub subject_blob_cids: std::option::Option<
+        Vec<jacquard_common::types::string::Cid<'a>>,
+    >,
 }
 
 pub mod emit_event_state {

crates/weaver-api/src/tools_ozone/moderation/list_scheduled_actions.rs

···
     /// Cursor for pagination
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub cursor: Option<jacquard_common::CowStr<'a>>,
+    pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Filter actions scheduled to execute before this time
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub ends_before: Option<jacquard_common::types::string::Datetime>,
+    pub ends_before: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Maximum number of results to return
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub limit: Option<i64>,
+    pub limit: std::option::Option<i64>,
     /// Filter actions scheduled to execute after this time
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub starts_after: Option<jacquard_common::types::string::Datetime>,
+    pub starts_after: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Filter actions by status
     #[serde(borrow)]
     pub statuses: Vec<jacquard_common::CowStr<'a>>,
     /// Filter actions for specific DID subjects
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subjects: Option<Vec<jacquard_common::types::string::Did<'a>>>,
+    pub subjects: std::option::Option<Vec<jacquard_common::types::string::Did<'a>>>,
 }
 
 pub mod list_scheduled_actions_state {

crates/weaver-api/src/tools_ozone/moderation/schedule_action.rs

···
     pub error: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub error_code: Option<jacquard_common::CowStr<'a>>,
+    pub error_code: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub subject: jacquard_common::types::string::Did<'a>,
 }
···
                             }),
                         );
                         map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "emailContent",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: Some(
+                                    ::jacquard_common::CowStr::new_static(
+                                        "Email content to be sent to the user upon takedown.",
+                                    ),
+                                ),
+                                format: None,
+                                default: None,
+                                min_length: None,
+                                max_length: None,
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "emailSubject",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: Some(
+                                    ::jacquard_common::CowStr::new_static(
+                                        "Subject of the email to be sent to the user upon takedown.",
+                                    ),
+                                ),
+                                format: None,
+                                default: None,
+                                min_length: None,
+                                max_length: None,
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
+                        map.insert(
                             ::jacquard_common::smol_str::SmolStr::new_static("policies"),
                             ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
                                 description: Some(
···
                                 max_length: Some(5usize),
                             }),
                         );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "severityLevel",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: Some(
+                                    ::jacquard_common::CowStr::new_static(
+                                        "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).",
+                                    ),
+                                ),
+                                format: None,
+                                default: None,
+                                min_length: None,
+                                max_length: None,
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "strikeCount",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
+                                description: None,
+                                default: None,
+                                minimum: None,
+                                maximum: None,
+                                r#enum: None,
+                                r#const: None,
+                            }),
+                        );
+                        map.insert(
+                            ::jacquard_common::smol_str::SmolStr::new_static(
+                                "strikeExpiresAt",
+                            ),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                description: Some(
+                                    ::jacquard_common::CowStr::new_static(
+                                        "When the strike should expire. If not provided, the strike never expires.",
+                                    ),
+                                ),
+                                format: Some(
+                                    ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
+                                ),
+                                default: None,
+                                min_length: None,
+                                max_length: None,
+                                min_graphemes: None,
+                                max_graphemes: None,
+                                r#enum: None,
+                                r#const: None,
+                                known_values: None,
+                            }),
+                        );
                         map
                     },
                 }),
···
     /// This will be propagated to the moderation event when it is applied
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub mod_tool: Option<crate::tools_ozone::moderation::ModTool<'a>>,
+    pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,
     #[serde(borrow)]
     pub scheduling: crate::tools_ozone::moderation::schedule_action::SchedulingConfig<
         'a,
···
     /// Indicates how long the takedown should be in effect before automatically expiring.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub duration_in_hours: std::option::Option<i64>,
+    /// Email content to be sent to the user upon takedown.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub email_content: std::option::Option<jacquard_common::CowStr<'a>>,
+    /// Subject of the email to be sent to the user upon takedown.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub email_subject: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Names/Keywords of the policies that drove the decision.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub policies: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
+    /// Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    #[serde(borrow)]
+    pub severity_level: std::option::Option<jacquard_common::CowStr<'a>>,
+    /// Number of strikes to assign to the user when takedown is applied.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    pub strike_count: std::option::Option<i64>,
+    /// When the strike should expire. If not provided, the strike never expires.
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
+    pub strike_expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
 }
 
 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Takedown<'a> {

crates/weaver-api/src/tools_ozone/safelink.rs

···
     /// Optional comment about the decision
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     pub created_at: jacquard_common::types::string::Datetime,
     /// DID of the user who created this rule
     #[serde(borrow)]
···
     /// Optional comment about the decision
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Timestamp when the rule was created
     pub created_at: jacquard_common::types::string::Datetime,
     /// DID of the user added the rule.

crates/weaver-api/src/tools_ozone/safelink/add_rule.rs

···
     /// Optional comment about the decision
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Author DID. Only respected when using admin auth
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub created_by: Option<jacquard_common::types::string::Did<'a>>,
+    pub created_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
     #[serde(borrow)]
     pub pattern: crate::tools_ozone::safelink::PatternType<'a>,
     #[serde(borrow)]

crates/weaver-api/src/tools_ozone/safelink/remove_rule.rs

···
     /// Optional comment about why the rule is being removed
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Optional DID of the user. Only respected when using admin auth.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub created_by: Option<jacquard_common::types::string::Did<'a>>,
+    pub created_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
     #[serde(borrow)]
     pub pattern: crate::tools_ozone::safelink::PatternType<'a>,
     /// The URL or domain to remove the rule for

crates/weaver-api/src/tools_ozone/safelink/update_rule.rs

···
     /// Optional comment about the update
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub comment: Option<jacquard_common::CowStr<'a>>,
+    pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Optional DID to credit as the creator. Only respected for admin_token authentication.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub created_by: Option<jacquard_common::types::string::Did<'a>>,
+    pub created_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
     #[serde(borrow)]
     pub pattern: crate::tools_ozone::safelink::PatternType<'a>,
     #[serde(borrow)]

crates/weaver-api/src/tools_ozone/set.rs

···
     pub created_at: jacquard_common::types::string::Datetime,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub name: jacquard_common::CowStr<'a>,
     pub set_size: i64,

crates/weaver-api/src/tools_ozone/setting.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct DefsOption<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub created_by: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(borrow)]
···
     pub last_updated_by: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub manager_role: Option<jacquard_common::CowStr<'a>>,
+    pub manager_role: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub scope: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub updated_at: Option<jacquard_common::types::string::Datetime>,
+    pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub value: jacquard_common::types::value::Data<'a>,
 }

crates/weaver-api/src/tools_ozone/setting/upsert_option.rs

···
 pub struct UpsertOption<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub description: Option<jacquard_common::CowStr<'a>>,
+    pub description: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub key: jacquard_common::types::string::Nsid<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub manager_role: Option<jacquard_common::CowStr<'a>>,
+    pub manager_role: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(borrow)]
     pub scope: jacquard_common::CowStr<'a>,
     #[serde(borrow)]

crates/weaver-api/src/tools_ozone/signature/find_related_accounts.rs

···
     pub account: crate::com_atproto::admin::AccountView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub similarities: Option<Vec<crate::tools_ozone::signature::SigDetail<'a>>>,
+    pub similarities: std::option::Option<
+        Vec<crate::tools_ozone::signature::SigDetail<'a>>,
+    >,
 }
 
 pub mod related_account_state {

crates/weaver-api/src/tools_ozone/team.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct Member<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub disabled: Option<bool>,
+    pub disabled: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub last_updated_by: Option<jacquard_common::CowStr<'a>>,
+    pub last_updated_by: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub profile: Option<crate::app_bsky::actor::ProfileViewDetailed<'a>>,
+    pub profile: std::option::Option<crate::app_bsky::actor::ProfileViewDetailed<'a>>,
     #[serde(borrow)]
     pub role: jacquard_common::CowStr<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub updated_at: Option<jacquard_common::types::string::Datetime>,
+    pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
 }
 
 pub mod member_state {

crates/weaver-api/src/tools_ozone/team/update_member.rs

···
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub disabled: Option<bool>,
+    pub disabled: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub role: Option<jacquard_common::CowStr<'a>>,
+    pub role: std::option::Option<jacquard_common::CowStr<'a>>,
 }
 
 pub mod update_member_state {

crates/weaver-api/src/tools_ozone/verification.rs

···
     pub issuer: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub issuer_profile: Option<jacquard_common::types::value::Data<'a>>,
+    pub issuer_profile: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub issuer_repo: Option<VerificationViewIssuerRepo<'a>>,
+    pub issuer_repo: std::option::Option<VerificationViewIssuerRepo<'a>>,
     /// Describes the reason for revocation, also indicating that the verification is no longer valid.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub revoke_reason: Option<jacquard_common::CowStr<'a>>,
+    pub revoke_reason: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Timestamp when the verification was revoked.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub revoked_at: Option<jacquard_common::types::string::Datetime>,
+    pub revoked_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// The user who revoked this verification.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub revoked_by: Option<jacquard_common::types::string::Did<'a>>,
+    pub revoked_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
     /// The subject of the verification.
     #[serde(borrow)]
     pub subject: jacquard_common::types::string::Did<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_profile: Option<jacquard_common::types::value::Data<'a>>,
+    pub subject_profile: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_repo: Option<VerificationViewSubjectRepo<'a>>,
+    pub subject_repo: std::option::Option<VerificationViewSubjectRepo<'a>>,
     /// The AT-URI of the verification record.
     #[serde(borrow)]
     pub uri: jacquard_common::types::string::AtUri<'a>,

crates/weaver-api/src/tools_ozone/verification/grant_verifications.rs

···
 pub struct VerificationInput<'a> {
     /// Timestamp for verification record. Defaults to current time when not specified.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub created_at: Option<jacquard_common::types::string::Datetime>,
+    pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
     /// Display name of the subject the verification applies to at the moment of verifying.
     #[serde(borrow)]
     pub display_name: jacquard_common::CowStr<'a>,

crates/weaver-api/src/tools_ozone/verification/revoke_verifications.rs

···
     /// Reason for revoking the verification. This is optional and can be omitted if not needed.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub revoke_reason: Option<jacquard_common::CowStr<'a>>,
+    pub revoke_reason: std::option::Option<jacquard_common::CowStr<'a>>,
     /// Array of verification record uris to revoke
     #[serde(borrow)]
     pub uris: Vec<jacquard_common::types::string::AtUri<'a>>,

crates/weaver-app/.env-dev

···
+WEAVER_APP_ENV="dev"
+WEAVER_APP_HOST="http://localhost"
+WEAVER_APP_DOMAIN=""
+WEAVER_PORT=8080
+WEAVER_APP_SCOPES="atproto transition:generic"
+WEAVER_CLIENT_NAME="Weaver"
+
+WEAVER_LOGO_URI=""
+WEAVER_TOS_URI=""
+WEAVER_PRIVACY_POLICY_URI=""

crates/weaver-app/.env-prod

···
-WEAVER_APP_ENV="prod"
-WEAVER_APP_HOST="https://alpha.weaver.sh"
-WEAVER_APP_DOMAIN="https://alpha.weaver.sh"
-WEAVER_PORT=8080
-WEAVER_APP_SCOPES="atproto transition:generic"
-WEAVER_CLIENT_NAME="Weaver"
-
-WEAVER_LOGO_URI=""
-WEAVER_TOS_URI=""
-WEAVER_PRIVACY_POLICY_URI=""

crates/weaver-app/Cargo.toml

···
 weaver-common = { path = "../weaver-common" }
 jacquard = { workspace = true}#, features = ["streaming"] }
 jacquard-lexicon = { workspace = true }
+jacquard-identity = { workspace = true }
 jacquard-axum = { workspace = true, optional = true }
 weaver-api = { path = "../weaver-api"}#, features = ["streaming"] }
 markdown-weaver = { workspace = true }
···
 http = "1.3"
 reqwest = { version = "0.12", default-features = false, features = ["json"] }
 
-dioxus-free-icons = { version = "0.10.0" }
 # diesel = { version = "2.3",  features = ["sqlite", "returning_clauses_for_sqlite_3_35", "chrono", "serde_json"] }
 # diesel_migrations = { version = "2.3", features = ["sqlite"] }
 tokio = { version = "1.28", features = ["sync"] }
 serde_html_form = "0.2.8"
 tracing.workspace = true
+serde_ipld_dagcbor = { version = "0.6" }
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 webbrowser = "1.0.6"

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

···
 mod state;
 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"))]
···
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-pub async fn restore_session() -> Result<(), String> {
+pub async fn restore_session(_fetcher: Fetcher) -> Result<(), String> {
     Ok(())
 }
 
 #[cfg(target_arch = "wasm32")]
-pub async fn restore_session() -> Result<(), CapturedError> {
-    use crate::fetch::CachedFetcher;
+pub async fn restore_session(fetcher: Fetcher) -> Result<(), CapturedError> {
     use dioxus::prelude::*;
     use gloo_storage::{LocalStorage, Storage};
     use jacquard::types::string::Did;
···
     let (did_str, session_id) =
         found_session.ok_or(CapturedError::from_display("No saved session found"))?;
     let did = Did::new_owned(did_str)?;
-    let fetcher = use_context::<CachedFetcher>();
 
     let session = fetcher
         .client

crates/weaver-app/src/blobcache.rs

···
             }
             AtIdentifier::Handle(handle) => self.client.pds_for_handle(&handle).await?,
         };
-        let blob = self
-            .client
-            .xrpc(pds_url)
-            .send(&GetBlob::new().cid(cid.clone()).did(repo_did).build())
-            .await?
-            .buffer()
-            .clone();
+        // let blob = if let Ok(blob_stream) = self
+        //     .client
+        //     .xrpc(pds_url)
+        //     .send(
+        //         &GetBlob::new()
+        //             .cid(cid.clone())
+        //             .did(repo_did.clone())
+        //             .build(),
+        //     )
+        //     .await
+        // {
+        //     blob_stream.buffer().clone()
+        // } else {
+        //     reqwest::get(format!(
+        //         "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@jpeg",
+        //         repo_did, cid
+        //     ))
+        //     .await?
+        //     .bytes()
+        //     .await?
+        //     .clone()
+        // };
+        //
+        let blob = reqwest::get(format!(
+            "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@jpeg",
+            repo_did, cid
+        ))
+        .await?
+        .bytes()
+        .await?
+        .clone();
 
         self.cache.insert(cid.clone(), blob);
         if let Some(name) = name {

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

···
     use weaver_renderer::css::{generate_base_css, generate_syntax_css};
     use weaver_renderer::theme::{default_resolved_theme, resolve_theme};
 
-    let fetcher = use_context::<fetch::CachedFetcher>();
+    let fetcher = use_context::<fetch::Fetcher>();
 
     let css_content = use_resource(move || {
         let ident = ident.clone();
···
 }
 
 #[cfg(feature = "fullstack-server")]
-#[get("/css/{ident}/{notebook}", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
+#[get("/css/{ident}/{notebook}", fetcher: Extension<Arc<fetch::Fetcher>>)]
 pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<Response> {
     use dioxus::fullstack::http::header::CONTENT_TYPE;
     use jacquard::client::AgentSessionExt;

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

···
 use crate::blobcache::BlobCache;
 use crate::{
     components::avatar::{Avatar, AvatarImage},
-    data::use_handle,
+    data::{NotebookHandle, use_handle},
 };
 
 use crate::Route;
···
 };
 #[allow(unused_imports)]
 use std::sync::Arc;
-use weaver_api::sh_weaver::notebook::{BookEntryView, entry};
+use weaver_api::sh_weaver::notebook::{BookEntryView, EntryView, entry};
+
+#[component]
+pub fn EntryPage(
+    ident: ReadSignal<AtIdentifier<'static>>,
+    book_title: ReadSignal<SmolStr>,
+    title: ReadSignal<SmolStr>,
+) -> Element {
+    rsx! {
+        {std::iter::once(rsx! {Entry {ident, book_title, title}})}
+    }
+}
 
 #[component]
 pub fn Entry(
···
     title: ReadSignal<SmolStr>,
 ) -> Element {
     // Use feature-gated hook for SSR support
-    let entry = crate::data::use_entry_data(ident(), book_title(), title())?;
+    let entry = crate::data::use_entry_data(ident(), book_title(), title());
+    let handle = use_context::<NotebookHandle>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
 
     // Handle blob caching when entry data is available
-    use_effect(move || {
-        if let Some((_book_entry_view, entry_record)) = &*entry.read() {
-            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 images = images.clone();
-                        spawn(async move {
-                            let fetcher = use_context::<fetch::CachedFetcher>();
-                            let _ = crate::service_worker::register_entry_blobs(
-                                &ident(),
-                                book_title().as_str(),
-                                &images,
-                                &fetcher,
-                            )
-                            .await;
-                        });
-                    }
-                    #[cfg(feature = "fullstack-server")]
-                    {
-                        let ident = ident();
-                        let images = images.clone();
-                        spawn(async move {
-                            for image in &images.images {
-                                use crate::data::cache_blob;
-
-                                let cid = image.image.blob().cid();
-                                cache_blob(
-                                    ident.to_smolstr(),
-                                    cid.to_smolstr(),
-                                    image.name.as_ref().map(|n| n.to_smolstr()),
+    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
-                                .ok();
-                            }
-                        });
+                                .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()
+                } }
             }
-        }
-    });
-
-    match &*entry.read_unchecked() {
-        Some((book_entry_view, entry_record)) => {
-            rsx! { EntryPage {
-                book_entry_view: book_entry_view.clone(),
-                entry_record: entry_record.clone(),
-                ident: use_handle(ident())?(),
-                book_title: book_title()
-            } }
+            _ => rsx! { p { "Loading..." } },
         }
-        _ => rsx! { p { "Loading..." } },
+    } else {
+        rsx! { p { "Loading..." } }
     }
 }
 
 /// Full entry page with metadata, content, and navigation
 #[component]
-fn EntryPage(
+fn EntryPageView(
     book_entry_view: BookEntryView<'static>,
     entry_record: entry::Entry<'static>,
     ident: AtIdentifier<'static>,
···
     author_count: usize,
 ) -> Element {
     use crate::Route;
-    use jacquard::{IntoStatic, from_data};
+    use jacquard::from_data;
     use weaver_api::sh_weaver::notebook::entry::Entry;
 
     let entry_view = &entry.entry;
···
         .map(|t| t.as_ref())
         .unwrap_or("Untitled");
 
-    let ident = use_handle(entry_view.uri.authority().clone().into_static())?;
-
+    let ident = use_context::<NotebookHandle>();
     // Format date
     let formatted_date = entry_view
         .indexed_at
···
     rsx! {
         div { class: "entry-card",
             Link {
-                to: Route::Entry {
-                    ident: ident(),
+                to: Route::EntryPage {
+                    ident: ident.as_ref().unwrap().clone(),
                     book_title: book_title.clone(),
                     title: title.to_string().into()
                 },
···
                                                 }
                                             }
                                             span { class: "author-name", "{display_name}" }
-                                            span { class: "meta-label", "@{ident}" }
+                                            span { class: "meta-label", "@{ident.as_ref().unwrap()}" }
                                         }
                                     }
                                     ProfileDataViewInner::ProfileViewDetailed(profile) => {
···
                                                 }
                                             }
                                             span { class: "author-name", "{display_name}" }
-                                            span { class: "meta-label", "@{ident}" }
+                                            span { class: "meta-label", "@{ident.as_ref().unwrap()}" }
                                         }
                                     }
                                     ProfileDataViewInner::TangledProfileView(profile) => {
···
 /// Metadata header showing title, authors, date, tags
 #[component]
 fn EntryMetadata(
-    entry_view: weaver_api::sh_weaver::notebook::EntryView<'static>,
+    entry_view: EntryView<'static>,
     ident: AtIdentifier<'static>,
     created_at: Datetime,
 ) -> Element {
···
 #[component]
 fn NavButton(
     direction: &'static str,
-    entry: weaver_api::sh_weaver::notebook::EntryView<'static>,
+    entry: EntryView<'static>,
     ident: AtIdentifier<'static>,
     book_title: SmolStr,
 ) -> Element {
···
 
     rsx! {
         Link {
-            to: Route::Entry {
+            to: Route::EntryPage {
                 ident: ident.clone(),
                 book_title: book_title.clone(),
                 title: entry_title.to_string().into()

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);
     rsx! {
-        // We can create elements inside the rsx macro with the element name followed by a block of attributes and children.
         div {
             Outlet::<Route> {}
         }
     }
 }
 
+pub fn use_repo_notebook_context()
+-> Option<Resource<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>> {
+    try_use_context::<Resource<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>>()
+}
+
 #[component]
 pub fn RepositoryIndex(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
     use crate::components::ProfileDisplay;
-
-    // Fetch notebooks for this specific DID with SSR support
-    let notebooks = data::use_notebooks_for_did(ident()).ok();
-
+    let notebooks = use_repo_notebook_context();
     rsx! {
         document::Stylesheet { href: NOTEBOOK_CARD_CSS }
 
···
             // Main content area
             main { class: "repository-main",
                 div { class: "notebooks-list",
-                    if let Some(notebooks_memo) = &notebooks {
-                        match &*notebooks_memo.read_unchecked() {
-                            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..." }
-                            }
-                        }
-                    } else {
-                        div { "Loading notebooks..." }
-                    }
+                   if let Some(notebooks) = notebooks {
+                       match &*notebooks.read() {
+                           Some(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()
+                                               }
+                                           }
+                                       }
+                                   }
+                               }
+                           },
+                           _ => rsx! {
+                               div { "Loading notebooks..." }
+                           }
+                       }
+                   }
                 }
             }
         }
···
 ) -> Element {
     use jacquard::IntoStatic;
 
-    let fetcher = use_context::<fetch::CachedFetcher>();
+    let fetcher = use_context::<fetch::Fetcher>();
 
     let title = notebook
         .title
···
             div { class: "notebook-card-container",
 
                 Link {
-                    to: Route::Entry {
+                    to: Route::EntryPage {
                         ident: ident.clone(),
                         book_title: title.to_string().into(),
                         title: "".into() // Will redirect to first entry
···
 
                                             rsx! {
                                                 Link {
-                                                    to: Route::Entry {
+                                                    to: Route::EntryPage {
                                                         ident: ident.clone(),
                                                         book_title: book_title.clone(),
                                                         title: entry_title.to_string().into()
···
 
                                             rsx! {
                                                 Link {
-                                                    to: Route::Entry {
+                                                    to: Route::EntryPage {
                                                         ident: ident.clone(),
                                                         book_title: book_title.clone(),
                                                         title: entry_title.to_string().into()
···
 
                                             rsx! {
                                                 Link {
-                                                    to: Route::Entry {
+                                                    to: Route::EntryPage {
                                                         ident: ident.clone(),
                                                         book_title: book_title.clone(),
                                                         title: entry_title.to_string().into()

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

···
 use jacquard::oauth::session::ClientData;
 use jacquard::{oauth::types::AuthorizeOptions, smol_str::SmolStr};
 
-use crate::CONFIG;
+use crate::{CONFIG, Route};
 use crate::{
     components::{
         button::{Button, ButtonVariant},
         dialog::{DialogContent, DialogRoot, DialogTitle},
         input::Input,
     },
-    fetch::CachedFetcher,
+    fetch::Fetcher,
 };
 
+fn handle_submit(
+    full_route: Route,
+    fetcher: Fetcher,
+    mut error: Signal<Option<String>>,
+    mut is_loading: Signal<bool>,
+    handle_input: Signal<String>,
+    mut open: Signal<bool>,
+) {
+    let handle = handle_input.read().clone();
+    if handle.is_empty() {
+        error.set(Some("Please enter a handle".to_string()));
+        return;
+    }
+
+    is_loading.set(true);
+    error.set(None);
+
+    #[cfg(target_arch = "wasm32")]
+    {
+        use gloo_storage::Storage;
+        gloo_storage::LocalStorage::set("cached_route", format!("{}", full_route)).ok();
+        spawn(async move {
+            match start_oauth_flow(handle, fetcher).await {
+                Ok(_) => {
+                    open.set(false);
+                }
+                Err(e) => {
+                    error!("Authentication failed: {}", e);
+                    error.set(Some(format!("Authentication failed: {}", e)));
+                    is_loading.set(false);
+                }
+            }
+        });
+    }
+}
+
 #[component]
 pub fn LoginModal(open: Signal<bool>) -> Element {
     let mut handle_input = use_signal(|| String::new());
-    let mut error = use_signal(|| Option::<String>::None);
-    let mut is_loading = use_signal(|| false);
-
-    let mut handle_submit = move || {
-        let handle = handle_input.read().clone();
-        if handle.is_empty() {
-            error.set(Some("Please enter a handle".to_string()));
-            return;
-        }
-
-        is_loading.set(true);
-        error.set(None);
-
-        let fetcher = use_context::<CachedFetcher>();
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            use crate::Route;
-            use gloo_storage::Storage;
-            let full_route = use_route::<Route>();
-            gloo_storage::LocalStorage::set("cached_route", format!("{}", full_route)).ok();
-        }
+    let error = use_signal(|| Option::<String>::None);
+    let is_loading = use_signal(|| false);
+    let full_route = use_route::<Route>();
+    let fetcher = use_context::<Fetcher>();
+    let submit_route = full_route.clone();
+    let submit_fetcher = fetcher.clone();
+    let submit_closure1 = move || {
+        let submit_route = submit_route.clone();
+        let submit_fetcher = submit_fetcher.clone();
+        handle_submit(
+            submit_route,
+            submit_fetcher,
+            error,
+            is_loading,
+            handle_input,
+            open,
+        );
+    };
 
-        use_effect(move || {
-            let handle = handle.clone();
-            let fetcher = fetcher.clone();
-            spawn(async move {
-                match start_oauth_flow(handle, fetcher).await {
-                    Ok(_) => {
-                        open.set(false);
-                    }
-                    Err(e) => {
-                        error!("Authentication failed: {}", e);
-                        error.set(Some(format!("Authentication failed: {}", e)));
-                        is_loading.set(false);
-                    }
-                }
-            });
-        });
+    let submit_closure2 = move || {
+        let submit_route = full_route.clone();
+        let submit_fetcher = fetcher.clone();
+        handle_submit(
+            submit_route,
+            submit_fetcher,
+            error,
+            is_loading,
+            handle_input,
+            open,
+        );
     };
 
     rsx! {
···
                         oninput: move |e: FormEvent| handle_input.set(e.value()),
                         onkeypress: move |k: KeyboardEvent| {
                             if k.key() == Key::Enter {
-                                handle_submit();
+                                submit_closure1();
                             }
                         },
                         placeholder: "Enter your handle",
···
                         r#type: "submit",
                         disabled: is_loading(),
                         onclick: move |_| {
-                            handle_submit();
+                            submit_closure2();
                         },
                         if is_loading() { "Authenticating..." } else { "Sign In" }
                     }
···
     }
 }
 
-async fn start_oauth_flow(handle: String, fetcher: CachedFetcher) -> Result<(), SmolStr> {
+async fn start_oauth_flow(handle: String, fetcher: Fetcher) -> Result<(), SmolStr> {
     info!("Starting OAuth flow for handle: {}", handle);
 
     let client_data = ClientData {

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

···
 
 mod entry;
 #[allow(unused_imports)]
-pub use entry::{Entry, EntryCard, EntryMarkdown};
+pub use entry::{Entry, EntryCard, EntryMarkdown, EntryPage};
 
 pub mod identity;
 #[allow(unused_imports)]
···
 pub use notebook_cover::NotebookCover;
 
 pub mod login;
+
+pub mod record_editor;
+pub mod record_view;
 
 use dioxus::prelude::*;
 
···
         .with_hash_suffix(false)
         .into_asset_options()
 );
-pub mod input;
-pub mod dialog;
-pub mod button;
 pub mod accordion;
+pub mod button;
+pub mod dialog;
+pub mod input;

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

···
 #![allow(non_snake_case)]
 
-use crate::components::avatar::{Avatar, AvatarImage};
+use crate::{
+    components::avatar::{Avatar, AvatarImage},
+    data::NotebookHandle,
+};
 use dioxus::prelude::*;
 use weaver_api::sh_weaver::notebook::NotebookView;
 
···
                     h1 { class: "notebook-cover-title", "{title}" }
                     div { "Error loading notebook details" }
                 }
-            }
+            };
         }
     };
 
···
 
 #[component]
 fn NotebookAuthor(author: weaver_api::sh_weaver::notebook::AuthorListView<'static>) -> Element {
-    use crate::data::use_handle;
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 
     // Author already has profile data hydrated
···
                 .as_ref()
                 .map(|n| n.as_ref())
                 .unwrap_or("Unknown");
-            let handle = use_handle(p.did.clone().into())?;
 
             rsx! {
                 div { class: "notebook-author",
···
                     }
                     div { class: "notebook-author-info",
                         div { class: "notebook-author-name", "{display_name}" }
-                        div { class: "notebook-author-handle", "@{handle()}" }
+                        div { class: "notebook-author-handle", "@{p.handle}" }
                     }
                 }
             }
···
                 .as_ref()
                 .map(|n| n.as_ref())
                 .unwrap_or("Unknown");
-            let handle = use_handle(p.did.clone().into())?;
 
             rsx! {
                 div { class: "notebook-author",
···
                     }
                     div { class: "notebook-author-info",
                         div { class: "notebook-author-name", "{display_name}" }
-                        div { class: "notebook-author-handle", "@{handle()}" }
+                        div { class: "notebook-author-handle", "@{p.handle}" }
                     }
                 }
             }

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

···
 #![allow(non_snake_case)]
 
-use crate::{
-    components::{
-        avatar::{Avatar, AvatarImage},
-        BskyIcon, TangledIcon,
-    },
-    data::use_handle,
+use crate::components::{
+    BskyIcon, TangledIcon,
+    avatar::{Avatar, AvatarImage},
+    identity::use_repo_notebook_context,
 };
 use dioxus::prelude::*;
 use jacquard::types::ident::AtIdentifier;
···
 const PROFILE_CSS: Asset = asset!("/assets/styling/profile.css");
 
 #[component]
-pub fn ProfileDisplay(ident: AtIdentifier<'static>) -> Element {
+pub fn ProfileDisplay(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
     // Fetch profile data
-    let profile = crate::data::use_profile_data(ident.clone())?;
+    let profile = crate::data::use_profile_data(ident());
 
-    match profile().as_ref() {
-        Some(profile_view) => rsx! {
-            document::Stylesheet { href: PROFILE_CSS }
+    match &*profile?.read() {
+        Some(profile_view) => {
+            let profile_view = use_signal(|| profile_view.clone());
+            rsx! {
+                document::Stylesheet { href: PROFILE_CSS }
 
-            div { class: "profile-display",
-                // Banner if present
-                {match &profile_view.inner {
-                    ProfileDataViewInner::ProfileView(p) => {
-                        if let Some(ref banner) = p.banner {
-                            rsx! {
-                                div { class: "profile-banner",
-                                    img { src: "{banner.as_ref()}", alt: "Profile banner" }
+                div { class: "profile-display",
+                    // Banner if present
+                    {match &profile_view.read().inner {
+                        ProfileDataViewInner::ProfileView(p) => {
+                            if let Some(ref banner) = p.banner {
+                                rsx! {
+                                    div { class: "profile-banner",
+                                        img { src: "{banner.as_ref()}", alt: "Profile banner" }
+                                    }
                                 }
+                            } else {
+                                rsx! { }
                             }
-                        } else {
-                            rsx! { }
                         }
-                    }
-                    ProfileDataViewInner::ProfileViewDetailed(p) => {
-                        if let Some(ref banner) = p.banner {
-                            rsx! {
-                                div { class: "profile-banner",
-                                    img { src: "{banner.as_ref()}", alt: "Profile banner" }
+                        ProfileDataViewInner::ProfileViewDetailed(p) => {
+                            if let Some(ref banner) = p.banner {
+                                rsx! {
+                                    div { class: "profile-banner",
+                                        img { src: "{banner.as_ref()}", alt: "Profile banner" }
+                                    }
                                 }
+                            } else {
+                                rsx! { }
                             }
-                        } else {
-                            rsx! { }
                         }
-                    }
-                    _ => rsx! { }
-                }}
+                        _ => rsx! { }
+                    }}
 
-                div { class: "profile-content",
-                    // Avatar and identity
-                    ProfileIdentity { profile_view: profile_view.clone(), ident: ident.clone() }
-                    div {
-                        class: "profile-extras",
-                        // Stats
-                        ProfileStats { ident: ident.clone() }
+                    div { class: "profile-content",
+                        // Avatar and identity
+                        ProfileIdentity { profile_view, ident }
+                        div {
+                            class: "profile-extras",
+                            // Stats
+                            ProfileStats { ident }
 
-                        // Links
-                        ProfileLinks { profile_view: profile_view.clone(), ident: ident.clone() }
-                    }
+                            // Links
+                            ProfileLinks { profile_view, ident }
+                        }
 
 
+                    }
                 }
             }
-        },
-        None => rsx! {
+        }
+        _ => rsx! {
             div { class: "profile-display profile-loading",
                 "Loading profile..."
             }
···
 
 #[component]
 fn ProfileIdentity(
-    profile_view: weaver_api::sh_weaver::actor::ProfileDataView<'static>,
-    ident: AtIdentifier<'static>,
+    profile_view: ReadSignal<weaver_api::sh_weaver::actor::ProfileDataView<'static>>,
+    ident: ReadSignal<AtIdentifier<'static>>,
 ) -> Element {
-    match &profile_view.inner {
+    match &profile_view.read().inner {
         ProfileDataViewInner::ProfileView(profile) => {
             let display_name = profile
                 .display_name
···
                                     span { class: "profile-pronouns", " ({pronouns})" }
                                 }
                             }
-                            div { class: "profile-handle", "@{use_handle(ident.clone())?}" }
+                            div { class: "profile-handle", "@{profile.handle}" }
 
                             if let Some(ref location) = profile.location {
                                 div { class: "profile-location", "{location}" }
···
 
                         div { class: "profile-name-section",
                             h1 { class: "profile-display-name", "{display_name}" }
-                            div { class: "profile-handle", "@{use_handle(ident.clone())?}" }
+                            div { class: "profile-handle", "@{profile.handle}" }
                         }
                     }
 
···
 }
 
 #[component]
-fn ProfileStats(ident: AtIdentifier<'static>) -> Element {
+fn ProfileStats(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
     // Fetch notebook count
-    let notebooks = crate::data::use_notebooks_for_did(ident.clone())?;
+    let notebooks = use_repo_notebook_context();
 
-    let notebook_count = notebooks().as_ref().map(|n| n.len()).unwrap_or(0);
+    let notebook_count = if let Some(notebooks) = notebooks {
+        if let Some(Some(notebooks)) = &*notebooks.read() {
+            notebooks.len()
+        } else {
+            0
+        }
+    } else {
+        0
+    };
 
     rsx! {
         div { class: "profile-stats",
···
 
 #[component]
 fn ProfileLinks(
-    profile_view: weaver_api::sh_weaver::actor::ProfileDataView<'static>,
-    ident: AtIdentifier<'static>,
+    profile_view: ReadSignal<weaver_api::sh_weaver::actor::ProfileDataView<'static>>,
+
+    ident: ReadSignal<AtIdentifier<'static>>,
 ) -> Element {
-    match &profile_view.inner {
+    match &profile_view.read().inner {
         ProfileDataViewInner::ProfileView(profile) => {
             rsx! {
                 div { class: "profile-links",

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

···
+use crate::Route;
+use crate::components::accordion::{Accordion, AccordionContent, AccordionItem, AccordionTrigger};
+use crate::components::dialog::{DialogContent, DialogDescription, DialogRoot, DialogTitle};
+use crate::components::record_view::{PathLabel, SchemaView, ViewMode};
+use crate::fetch::Fetcher;
+use crate::record_utils::{create_array_item_default, infer_data_from_text, try_parse_as_type};
+use dioxus::prelude::{FormData, *};
+use http::StatusCode;
+use humansize::format_size;
+use jacquard::api::com_atproto::repo::get_record::GetRecordOutput;
+use jacquard::bytes::Bytes;
+use jacquard::client::AgentError;
+use jacquard::{atproto, prelude::*};
+use jacquard::{
+    client::AgentSessionExt,
+    common::{Data, IntoStatic},
+    types::{aturi::AtUri, ident::AtIdentifier, string::Nsid},
+};
+use jacquard_lexicon::lexicon::LexiconDoc;
+use jacquard_lexicon::validation::ValidationResult;
+use mime_sniffer::MimeTypeSniffer;
+use weaver_api::com_atproto::repo::{
+    create_record::CreateRecord, delete_record::DeleteRecord, put_record::PutRecord,
+};
+// ============================================================================
+// Pretty Editor: Component Hierarchy
+// ============================================================================
+
+/// Main dispatcher - routes to specific field editors based on Data type
+#[component]
+fn EditableDataView(
+    root: Signal<Data<'static>>,
+    path: String,
+    did: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let root_read = root.read();
+
+    match root_read
+        .get_at_path(&path_for_memo)
+        .map(|d| d.clone().into_static())
+    {
+        Some(Data::Object(_)) => {
+            rsx! { EditableObjectField { root, path: path.clone(), did, remove_button } }
+        }
+        Some(Data::Array(_)) => rsx! { EditableArrayField { root, path: path.clone(), did } },
+        Some(Data::String(_)) => {
+            rsx! { EditableStringField { root, path: path.clone(), remove_button } }
+        }
+        Some(Data::Integer(_)) => {
+            rsx! { EditableIntegerField { root, path: path.clone(), remove_button } }
+        }
+        Some(Data::Boolean(_)) => {
+            rsx! { EditableBooleanField { root, path: path.clone(), remove_button } }
+        }
+        Some(Data::Null) => rsx! { EditableNullField { root, path: path.clone(), remove_button } },
+        Some(Data::Blob(_)) => {
+            rsx! { EditableBlobField { root, path: path.clone(), did, remove_button } }
+        }
+        Some(Data::Bytes(_)) => {
+            rsx! { EditableBytesField { root, path: path.clone(), remove_button } }
+        }
+        Some(Data::CidLink(_)) => {
+            rsx! { EditableCidLinkField { root, path: path.clone(), remove_button } }
+        }
+
+        None => rsx! { div { class: "field-error", "❌ Path not found: {path}" } },
+    }
+}
+
+// ============================================================================
+// Primitive Field Editors
+// ============================================================================
+
+/// String field with type preservation
+#[component]
+fn EditableStringField(
+    root: Signal<Data<'static>>,
+    path: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    use jacquard::types::LexiconStringType;
+
+    let path_for_text = path.clone();
+    let path_for_type = path.clone();
+
+    // Get current string value
+    let current_text = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_text)
+            .and_then(|d| d.as_str())
+            .map(|s| s.to_string())
+            .unwrap_or_default()
+    });
+
+    // Get string type (Copy, cheap to store)
+    let string_type = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_type)
+            .and_then(|d| match d {
+                Data::String(s) => Some(s.string_type()),
+                _ => None,
+            })
+            .unwrap_or(LexiconStringType::String)
+    });
+
+    // Local state for invalid input
+    let mut input_text = use_signal(|| current_text());
+    let mut parse_error = use_signal(|| None::<String>);
+
+    // Sync input when current changes
+    use_effect(move || {
+        input_text.set(current_text());
+    });
+
+    let path_for_mutation = path.clone();
+    let handle_input = move |evt: Event<FormData>| {
+        let new_text = evt.value();
+        input_text.set(new_text.clone());
+
+        match try_parse_as_type(&new_text, string_type()) {
+            Ok(new_atproto_str) => {
+                parse_error.set(None);
+                let mut new_data = root.read().clone();
+                new_data.set_at_path(&path_for_mutation, Data::String(new_atproto_str));
+                root.set(new_data);
+            }
+            Err(e) => {
+                parse_error.set(Some(e));
+            }
+        }
+    };
+
+    let type_label = format!("{:?}", string_type()).to_lowercase();
+    let is_plain_string = string_type() == LexiconStringType::String;
+
+    // Dynamic width based on content length
+    let input_width = use_memo(move || {
+        let len = input_text().len();
+        let min_width = match string_type() {
+            LexiconStringType::Cid => 60,
+            LexiconStringType::Nsid => 40,
+            LexiconStringType::Did => 50,
+            LexiconStringType::AtUri => 50,
+            _ => 20,
+        };
+        format!("{}ch", len.max(min_width))
+    });
+
+    rsx! {
+        div { class: "record-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                if type_label != "string" {
+                    span { class: "string-type-tag", " [{type_label}]" }
+                }
+                {remove_button}
+            }
+            if is_plain_string {
+                textarea {
+                    value: "{input_text}",
+                    oninput: handle_input,
+                    class: if parse_error().is_some() { "invalid" } else { "" },
+                    rows: "1",
+                }
+            } else {
+                input {
+                    r#type: "text",
+                    value: "{input_text}",
+                    style: "width: {input_width}",
+                    oninput: handle_input,
+                    class: if parse_error().is_some() { "invalid" } else { "" },
+                }
+            }
+            if let Some(err) = parse_error() {
+                span { class: "field-error", " ❌ {err}" }
+            }
+        }
+    }
+}
+
+/// Integer field with validation
+#[component]
+fn EditableIntegerField(
+    root: Signal<Data<'static>>,
+    path: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let current_value = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .and_then(|d| d.as_integer())
+            .unwrap_or(0)
+    });
+
+    let mut input_text = use_signal(|| current_value().to_string());
+    let mut parse_error = use_signal(|| None::<String>);
+
+    use_effect(move || {
+        input_text.set(current_value().to_string());
+    });
+
+    let path_for_mutation = path.clone();
+
+    rsx! {
+        div { class: "record-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                {remove_button}
+            }
+            input {
+                r#type: "number",
+                value: "{input_text}",
+                oninput: move |evt| {
+                    let text = evt.value();
+                    input_text.set(text.clone());
+
+                    match text.parse::<i64>() {
+                        Ok(num) => {
+                            parse_error.set(None);
+                            let mut data_edit = root.write_unchecked();
+                             data_edit.set_at_path(&path_for_mutation, Data::Integer(num));
+                        }
+                        Err(_) => {
+                            parse_error.set(Some("Must be a valid integer".to_string()));
+                        }
+                    }
+                }
+            }
+            if let Some(err) = parse_error() {
+                span { class: "field-error", " ❌ {err}" }
+            }
+        }
+    }
+}
+
+/// Boolean field (toggle button)
+#[component]
+fn EditableBooleanField(
+    root: Signal<Data<'static>>,
+    path: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let current_value = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .and_then(|d| d.as_boolean())
+            .unwrap_or(false)
+    });
+
+    let path_for_mutation = path.clone();
+    rsx! {
+        div { class: "record-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                {remove_button}
+            }
+            button {
+                class: if current_value() { "boolean-toggle boolean-toggle-true" } else { "boolean-toggle boolean-toggle-false" },
+                onclick: move |_| {
+                    root.with_mut(|data| {
+                        if let Some(target) = data.get_at_path_mut(path_for_mutation.as_str()) {
+                            if let Some(bool_val) = target.as_boolean() {
+                                *target = Data::Boolean(!bool_val);
+                            }
+                        }
+                    });
+                },
+                "{current_value()}"
+            }
+        }
+    }
+}
+
+/// Null field with type inference
+#[component]
+fn EditableNullField(
+    root: Signal<Data<'static>>,
+    path: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let mut input_text = use_signal(|| String::new());
+    let mut parse_error = use_signal(|| None::<String>);
+
+    let path_for_mutation = path.clone();
+    rsx! {
+        div { class: "record-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                span { class: "field-value muted", "null" }
+                {remove_button}
+            }
+            input {
+                r#type: "text",
+                placeholder: "Enter value (or {{}}, [], true, 123)...",
+                value: "{input_text}",
+                oninput: move |evt| {
+                    input_text.set(evt.value());
+                },
+                onkeydown: move |evt| {
+                    use dioxus::prelude::keyboard_types::Key;
+                    if evt.key() == Key::Enter {
+                        let text = input_text();
+                        match infer_data_from_text(&text) {
+                            Ok(new_value) => {
+                                root.with_mut(|data| {
+                                    if let Some(target) = data.get_at_path_mut(path_for_mutation.as_str()) {
+                                        *target = new_value;
+                                    }
+                                });
+                                input_text.set(String::new());
+                                parse_error.set(None);
+                            }
+                            Err(e) => {
+                                parse_error.set(Some(e));
+                            }
+                        }
+                    }
+                }
+            }
+            if let Some(err) = parse_error() {
+                span { class: "field-error", " ❌ {err}" }
+            }
+        }
+    }
+}
+
+/// Blob field - shows CID, size (editable), mime type (read-only), file upload
+#[component]
+fn EditableBlobField(
+    root: Signal<Data<'static>>,
+    path: String,
+    did: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let blob_data = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .and_then(|d| match d {
+                Data::Blob(blob) => Some((
+                    blob.r#ref.to_string(),
+                    blob.size,
+                    blob.mime_type.as_str().to_string(),
+                )),
+                _ => None,
+            })
+    });
+
+    let mut cid_input = use_signal(|| String::new());
+    let mut size_input = use_signal(|| String::new());
+    let mut cid_error = use_signal(|| None::<String>);
+    let mut size_error = use_signal(|| None::<String>);
+    let mut uploading = use_signal(|| false);
+    let mut upload_error = use_signal(|| None::<String>);
+    let mut preview_data_url = use_signal(|| None::<String>);
+
+    // Sync inputs when blob data changes
+    use_effect(move || {
+        if let Some((cid, size, _)) = blob_data() {
+            cid_input.set(cid);
+            size_input.set(size.to_string());
+        }
+    });
+
+    let fetcher = use_context::<Fetcher>();
+    let path_for_upload = path.clone();
+    let handle_file = move |evt: Event<FormData>| {
+        let fetcher = fetcher.clone();
+        let path_upload_clone = path_for_upload.clone();
+        spawn(async move {
+            uploading.set(true);
+            upload_error.set(None);
+
+            let files = evt.files();
+            for file_data in files {
+                match file_data.read_bytes().await {
+                    Ok(bytes_data) => {
+                        // Convert to jacquard Bytes and sniff MIME type
+                        let bytes = Bytes::from(bytes_data.to_vec());
+                        let mime_str = bytes
+                            .sniff_mime_type()
+                            .unwrap_or("application/octet-stream");
+                        let mime_type = jacquard::types::blob::MimeType::new_owned(mime_str);
+
+                        // Create data URL for immediate preview if it's an image
+                        if mime_str.starts_with("image/") {
+                            let base64_data = base64::Engine::encode(
+                                &base64::engine::general_purpose::STANDARD,
+                                &bytes,
+                            );
+                            let data_url = format!("data:{};base64,{}", mime_str, base64_data);
+                            preview_data_url.set(Some(data_url.clone()));
+
+                            // Try to decode dimensions and populate aspectRatio field
+                            #[cfg(target_arch = "wasm32")]
+                            {
+                                let path_clone = path_upload_clone.clone();
+                                spawn(async move {
+                                    if let Some((width, height)) =
+                                        decode_image_dimensions(&data_url).await
+                                    {
+                                        populate_aspect_ratio(
+                                            root,
+                                            &path_clone,
+                                            width as i64,
+                                            height as i64,
+                                        );
+                                    }
+                                });
+                            }
+                        }
+
+                        // Upload blob
+                        let client = fetcher.get_client();
+                        match client.upload_blob(bytes, mime_type).await {
+                            Ok(new_blob) => {
+                                // Update blob in record
+                                let path_ref = path_upload_clone.clone();
+                                root.with_mut(|record_data| {
+                                    if let Some(Data::Blob(blob)) =
+                                        record_data.get_at_path_mut(&path_ref)
+                                    {
+                                        *blob = new_blob;
+                                    }
+                                });
+                                upload_error.set(None);
+                            }
+                            Err(e) => {
+                                upload_error.set(Some(format!("Upload failed: {:?}", e)));
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        upload_error.set(Some(format!("Failed to read file: {}", e)));
+                    }
+                }
+            }
+
+            uploading.set(false);
+        });
+    };
+
+    let path_for_cid = path.clone();
+    let handle_cid_change = move |evt: Event<FormData>| {
+        let text = evt.value();
+        cid_input.set(text.clone());
+
+        match jacquard::types::cid::CidLink::new_owned(text.as_bytes()) {
+            Ok(new_cid_link) => {
+                cid_error.set(None);
+                root.with_mut(|data| {
+                    if let Some(Data::Blob(blob)) = data.get_at_path_mut(&path_for_cid) {
+                        blob.r#ref = new_cid_link;
+                    }
+                });
+            }
+            Err(_) => {
+                cid_error.set(Some("Invalid CID format".to_string()));
+            }
+        }
+    };
+
+    let path_for_size = path.clone();
+    let handle_size_change = move |evt: Event<FormData>| {
+        let text = evt.value();
+        size_input.set(text.clone());
+
+        match text.parse::<usize>() {
+            Ok(new_size) => {
+                size_input.set(format_size(new_size, humansize::BINARY));
+                size_error.set(None);
+                root.with_mut(|data| {
+                    if let Some(Data::Blob(blob)) = data.get_at_path_mut(&path_for_size) {
+                        blob.size = new_size;
+                    }
+                });
+            }
+            Err(_) => {
+                size_error.set(Some("Must be a non-negative integer".to_string()));
+            }
+        }
+    };
+
+    let placeholder_cid = "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    let is_placeholder = blob_data()
+        .map(|(cid, _, _)| cid == placeholder_cid)
+        .unwrap_or(true);
+    let is_image = blob_data()
+        .map(|(_, _, mime)| mime.starts_with("image/"))
+        .unwrap_or(false);
+
+    // Use preview data URL if available (fresh upload), otherwise CDN
+    let image_url = if let Some(data_url) = preview_data_url() {
+        Some(data_url)
+    } else if !is_placeholder && is_image {
+        blob_data().map(|(cid, _, mime)| {
+            let format = mime.strip_prefix("image/").unwrap_or("jpeg");
+            format!(
+                "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@{}",
+                did, cid, format
+            )
+        })
+    } else {
+        None
+    };
+
+    rsx! {
+        div { class: "record-field blob-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                span { class: "string-type-tag", " [blob]" }
+                {remove_button}
+            }
+            div { class: "blob-fields",
+                div { class: "blob-field-row blob-field-cid",
+                    label { "CID:" }
+                    input {
+                        r#type: "text",
+                        value: "{cid_input}",
+                        oninput: handle_cid_change,
+                        class: if cid_error().is_some() { "invalid" } else { "" },
+                    }
+                    if let Some(err) = cid_error() {
+                        span { class: "field-error", " ❌ {err}" }
+                    }
+                }
+                div { class: "blob-field-row",
+                    label { "Size:" }
+                    input {
+                        r#type: "number",
+                        value: "{size_input}",
+                        oninput: handle_size_change,
+                        class: if size_error().is_some() { "invalid" } else { "" },
+                    }
+                    if let Some(err) = size_error() {
+                        span { class: "field-error", " ❌ {err}" }
+                    }
+                }
+                div { class: "blob-field-row",
+                    label { "MIME Type:" }
+                    span { class: "readonly",
+                        "{blob_data().map(|(_, _, mime)| mime).unwrap_or_default()}"
+                    }
+                }
+                if let Some(url) = image_url {
+                    img {
+                        src: "{url}",
+                        alt: "Blob preview",
+                        class: "blob-image",
+                    }
+                }
+                div { class: "blob-upload-section",
+                    input {
+                        r#type: "file",
+                        accept: if is_image { "image/*" } else { "*/*" },
+                        onchange: handle_file,
+                        disabled: uploading(),
+                    }
+                    if uploading() {
+                        span { class: "upload-status", "Uploading..." }
+                    }
+                    if let Some(err) = upload_error() {
+                        div { class: "field-error", "❌ {err}" }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Decode image dimensions from data URL using browser Image API
+#[cfg(target_arch = "wasm32")]
+async fn decode_image_dimensions(data_url: &str) -> Option<(u32, u32)> {
+    use wasm_bindgen::JsCast;
+    use wasm_bindgen::prelude::*;
+    use wasm_bindgen_futures::JsFuture;
+
+    let window = web_sys::window()?;
+    let document = window.document()?;
+
+    let img = document.create_element("img").ok()?;
+    let img = img.dyn_into::<web_sys::HtmlImageElement>().ok()?;
+
+    img.set_src(data_url);
+
+    // Wait for image to load
+    let promise = js_sys::Promise::new(&mut |resolve, _reject| {
+        let onload = Closure::wrap(Box::new(move || {
+            resolve.call0(&JsValue::NULL).ok();
+        }) as Box<dyn FnMut()>);
+
+        img.set_onload(Some(onload.as_ref().unchecked_ref()));
+        onload.forget();
+    });
+
+    JsFuture::from(promise).await.ok()?;
+
+    Some((img.natural_width(), img.natural_height()))
+}
+
+/// Find and populate aspectRatio field for a blob
+#[allow(unused)]
+fn populate_aspect_ratio(
+    mut root: Signal<Data<'static>>,
+    blob_path: &str,
+    width: i64,
+    height: i64,
+) {
+    // Query for all aspectRatio fields and collect the path we want
+    let aspect_path_to_update = {
+        let data = root.read();
+        let query_result = data.query("...aspectRatio");
+
+        query_result.multiple().and_then(|matches| {
+            // Find aspectRatio that's a sibling of our blob
+            // e.g. blob at "embed.images[0].image" -> look for "embed.images[0].aspectRatio"
+            let blob_parent = blob_path.rsplit_once('.').map(|(parent, _)| parent);
+            matches.iter().find_map(|query_match| {
+                let aspect_parent = query_match.path.rsplit_once('.').map(|(parent, _)| parent);
+
+                // Check if they share the same parent
+                if blob_parent == aspect_parent {
+                    Some(query_match.path.clone())
+                } else {
+                    None
+                }
+            })
+        })
+    };
+
+    // Update the aspectRatio if we found a matching field
+    if let Some(aspect_path) = aspect_path_to_update {
+        let aspect_obj = atproto! {{
+            "width": width,
+            "height": height
+        }};
+
+        root.with_mut(|record_data| {
+            record_data.set_at_path(&aspect_path, aspect_obj);
+        });
+    }
+}
+
+/// Bytes field with hex/base64 auto-detection
+#[component]
+fn EditableBytesField(
+    root: Signal<Data<'static>>,
+    path: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let current_bytes = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .and_then(|d| match d {
+                Data::Bytes(b) => Some(bytes_to_hex(b)),
+                _ => None,
+            })
+    });
+
+    let mut input_text = use_signal(|| String::new());
+    let mut parse_error = use_signal(|| None::<String>);
+    let mut detected_format = use_signal(|| None::<String>);
+
+    // Sync input when bytes change
+    use_effect(move || {
+        if let Some(hex) = current_bytes() {
+            input_text.set(hex);
+        }
+    });
+
+    let path_for_mutation = path.clone();
+    let handle_input = move |evt: Event<FormData>| {
+        let text = evt.value();
+        input_text.set(text.clone());
+
+        match parse_bytes_input(&text) {
+            Ok((bytes, format)) => {
+                parse_error.set(None);
+                detected_format.set(Some(format));
+                root.with_mut(|data| {
+                    if let Some(target) = data.get_at_path_mut(&path_for_mutation) {
+                        *target = Data::Bytes(bytes);
+                    }
+                });
+            }
+            Err(e) => {
+                parse_error.set(Some(e));
+                detected_format.set(None);
+            }
+        }
+    };
+
+    let byte_count = current_bytes()
+        .map(|hex| hex.chars().filter(|c| c.is_ascii_hexdigit()).count() / 2)
+        .unwrap_or(0);
+    let size_label = if byte_count > 128 {
+        format_size(byte_count, humansize::BINARY)
+    } else {
+        format!("{} bytes", byte_count)
+    };
+
+    rsx! {
+        div { class: "record-field bytes-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                span { class: "string-type-tag", " [bytes: {size_label}]" }
+                if let Some(format) = detected_format() {
+                    span { class: "bytes-format-tag", " ({format})" }
+                }
+                {remove_button}
+            }
+            textarea {
+                value: "{input_text}",
+                placeholder: "Paste hex (1a2b3c...) or base64 (YWJj...)",
+                oninput: handle_input,
+                class: if parse_error().is_some() { "invalid" } else { "" },
+                rows: "3",
+            }
+            if let Some(err) = parse_error() {
+                span { class: "field-error", " ❌ {err}" }
+            }
+        }
+    }
+}
+
+/// Parse bytes from hex or base64, auto-detecting format
+fn parse_bytes_input(text: &str) -> Result<(Bytes, String), String> {
+    let trimmed = text.trim();
+    if trimmed.is_empty() {
+        return Err("Input is empty".to_string());
+    }
+
+    // Remove common whitespace/separators
+    let cleaned: String = trimmed
+        .chars()
+        .filter(|c| !c.is_whitespace() && *c != ':' && *c != '-')
+        .collect();
+
+    // Try hex first (more restrictive)
+    if cleaned.chars().all(|c| c.is_ascii_hexdigit()) {
+        parse_hex_bytes(&cleaned).map(|b| (b, "hex".to_string()))
+    } else {
+        // Try base64
+        parse_base64_bytes(&cleaned).map(|b| (b, "base64".to_string()))
+    }
+}
+
+/// Parse hex string to bytes
+fn parse_hex_bytes(hex: &str) -> Result<Bytes, String> {
+    if hex.len() % 2 != 0 {
+        return Err("Hex string must have even length".to_string());
+    }
+
+    let mut bytes = Vec::with_capacity(hex.len() / 2);
+    for chunk in hex.as_bytes().chunks(2) {
+        let hex_byte = std::str::from_utf8(chunk).map_err(|e| format!("Invalid UTF-8: {}", e))?;
+        let byte =
+            u8::from_str_radix(hex_byte, 16).map_err(|e| format!("Invalid hex digit: {}", e))?;
+        bytes.push(byte);
+    }
+
+    Ok(Bytes::from(bytes))
+}
+
+/// Parse base64 string to bytes
+fn parse_base64_bytes(b64: &str) -> Result<Bytes, String> {
+    use base64::Engine;
+    let engine = base64::engine::general_purpose::STANDARD;
+
+    engine
+        .decode(b64)
+        .map(Bytes::from)
+        .map_err(|e| format!("Invalid base64: {}", e))
+}
+
+/// Convert bytes to hex display string (with spacing every 4 chars)
+fn bytes_to_hex(bytes: &Bytes) -> String {
+    bytes
+        .iter()
+        .enumerate()
+        .map(|(i, b)| {
+            let hex = format!("{:02x}", b);
+            if i > 0 && i % 2 == 0 {
+                format!(" {}", hex)
+            } else {
+                hex
+            }
+        })
+        .collect()
+}
+
+/// CidLink field with validation
+#[component]
+fn EditableCidLinkField(
+    root: Signal<Data<'static>>,
+    path: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let current_cid = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .map(|d| match d {
+                Data::CidLink(cid) => cid.to_string(),
+                _ => String::new(),
+            })
+            .unwrap_or_default()
+    });
+
+    let mut input_text = use_signal(|| String::new());
+    let mut parse_error = use_signal(|| None::<String>);
+
+    use_effect(move || {
+        input_text.set(current_cid());
+    });
+
+    let input_width = use_memo(move || {
+        let len = input_text().len();
+        format!("{}ch", len.max(60))
+    });
+
+    let path_for_mutation = path.clone();
+    let handle_input = move |evt: Event<FormData>| {
+        let text = evt.value();
+        input_text.set(text.clone());
+
+        match jacquard::types::cid::Cid::new_owned(text.as_bytes()) {
+            Ok(new_cid) => {
+                parse_error.set(None);
+                root.with_mut(|data| {
+                    if let Some(target) = data.get_at_path_mut(&path_for_mutation) {
+                        *target = Data::CidLink(new_cid);
+                    }
+                });
+            }
+            Err(_) => {
+                parse_error.set(Some("Invalid CID format".to_string()));
+            }
+        }
+    };
+
+    rsx! {
+        div { class: "record-field cidlink-field",
+            div { class: "field-header",
+                PathLabel { path: path.clone() }
+                span { class: "string-type-tag", " [cid-link]" }
+                {remove_button}
+            }
+            input {
+                r#type: "text",
+                value: "{input_text}",
+                style: "width: {input_width}",
+                placeholder: "bafyrei...",
+                oninput: handle_input,
+                class: if parse_error().is_some() { "invalid" } else { "" },
+            }
+            if let Some(err) = parse_error() {
+                span { class: "field-error", " ❌ {err}" }
+            }
+        }
+    }
+}
+
+// ============================================================================
+// Field with Remove Button Wrapper
+// ============================================================================
+
+/// Wraps a field with an optional remove button in the header
+#[component]
+fn FieldWithRemove(
+    root: Signal<Data<'static>>,
+    path: String,
+    did: String,
+    is_removable: bool,
+    parent_path: String,
+    field_key: String,
+) -> Element {
+    let remove_button = if is_removable {
+        Some(rsx! {
+            button {
+                class: "field-remove-button",
+                onclick: move |_| {
+                    let mut new_data = root.read().clone();
+                    if let Some(Data::Object(obj)) = new_data.get_at_path_mut(parent_path.as_str()) {
+                        obj.0.remove(field_key.as_str());
+                    }
+                    root.set(new_data);
+                },
+                "Remove"
+            }
+        })
+    } else {
+        None
+    };
+
+    rsx! {
+        EditableDataView {
+            root: root,
+            path: path.clone(),
+            did: did.clone(),
+            remove_button: remove_button,
+        }
+    }
+}
+
+// ============================================================================
+// Array Field Editor (enables recursion)
+// ============================================================================
+
+/// Array field - iterates items and renders child EditableDataView for each
+#[component]
+fn EditableArrayField(root: Signal<Data<'static>>, path: String, did: String) -> Element {
+    let path_for_memo = path.clone();
+    let array_len = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .and_then(|d| d.as_array())
+            .map(|arr| arr.0.len())
+            .unwrap_or(0)
+    });
+
+    let path_for_add = path.clone();
+
+    rsx! {
+        div { class: "record-section array-section",
+            Accordion {
+                id: "edit-array-{path}",
+                collapsible: true,
+                AccordionItem {
+                    default_open: true,
+                    index: 0,
+                    AccordionTrigger {
+                        div { class: "section-header",
+                            div { class: "section-label",
+                                {
+                                    let parts: Vec<&str> = path.split('.').collect();
+                                    let final_part = parts.last().unwrap_or(&"");
+                                    rsx! { "{final_part}" }
+                                }
+                            }
+                            span { class: "array-length", "[{array_len}]" }
+                        }
+                    }
+                    AccordionContent {
+                        div { class: "section-content",
+                            for idx in 0..array_len() {
+                                {
+                                    let item_path = format!("{}[{}]", path, idx);
+                                    let path_for_remove = path.clone();
+
+                                    rsx! {
+                                        div {
+                                            class: "array-item",
+                                            key: "{item_path}",
+
+                                            EditableDataView {
+                                                root: root,
+                                                path: item_path.clone(),
+                                                did: did.clone(),
+                                                remove_button: rsx! {
+                                                    button {
+                                                        class: "field-remove-button",
+                                                        onclick: move |_| {
+                                                            root.with_mut(|data| {
+                                                                if let Some(Data::Array(arr)) = data.get_at_path_mut(&path_for_remove) {
+                                                                    arr.0.remove(idx);
+                                                                }
+                                                            });
+                                                        },
+                                                        "Remove"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            div {
+                                class: "array-item",
+                                div {
+                                    class: "add-field-widget",
+                                    button {
+                                        onclick: move |_| {
+                                            root.with_mut(|data| {
+                                                if let Some(Data::Array(arr)) = data.get_at_path_mut(&path_for_add) {
+                                                    let new_item = create_array_item_default(arr);
+                                                    arr.0.push(new_item);
+                                                }
+                                            });
+                                        },
+                                        "+ Add Item"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ============================================================================
+// Object Field Editor (enables recursion)
+// ============================================================================
+
+/// Object field - iterates fields and renders child EditableDataView for each
+#[component]
+fn EditableObjectField(
+    root: Signal<Data<'static>>,
+    path: String,
+    did: String,
+    #[props(default)] remove_button: Option<Element>,
+) -> Element {
+    let path_for_memo = path.clone();
+    let field_keys = use_memo(move || {
+        root.read()
+            .get_at_path(&path_for_memo)
+            .and_then(|d| d.as_object())
+            .map(|obj| obj.0.keys().cloned().collect::<Vec<_>>())
+            .unwrap_or_default()
+    });
+
+    let is_root = path.is_empty();
+
+    rsx! {
+        if !is_root {
+            div { class: "record-section object-section",
+                Accordion {
+                    id: "edit-object-{path}",
+                    collapsible: true,
+                    AccordionItem {
+                        default_open: true,
+                        index: 0,
+                        AccordionTrigger {
+                            div { class: "section-header",
+                                div { class: "section-label",
+                                    {
+                                        let parts: Vec<&str> = path.split('.').collect();
+                                        let final_part = parts.last().unwrap_or(&"");
+                                        rsx! { "{final_part}" }
+                                    }
+                                }
+                                {remove_button}
+                            }
+                        }
+                        AccordionContent {
+                            div { class: "section-content",
+                                for key in field_keys() {
+                                {
+                                    let field_path = if path.is_empty() {
+                                        key.to_string()
+                                    } else {
+                                        format!("{}.{}", path, key)
+                                    };
+                                    let is_type_field = key == "$type";
+
+                                    rsx! {
+                                        FieldWithRemove {
+                                            key: "{field_path}",
+                                            root: root,
+                                            path: field_path.clone(),
+                                            did: did.clone(),
+                                            is_removable: !is_type_field,
+                                            parent_path: path.clone(),
+                                            field_key: key.clone(),
+                                        }
+                                    }
+                                }
+                                }
+
+                                AddFieldWidget { root: root, path: path.clone() }
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            for key in field_keys() {
+                {
+                    let field_path = key.to_string();
+                    let is_type_field = key == "$type";
+
+                    rsx! {
+                        FieldWithRemove {
+                            key: "{field_path}",
+                            root: root,
+                            path: field_path.clone(),
+                            did: did.clone(),
+                            is_removable: !is_type_field,
+                            parent_path: path.clone(),
+                            field_key: key.clone(),
+                        }
+                    }
+                }
+            }
+
+            AddFieldWidget { root: root, path: path.clone() }
+        }
+    }
+}
+
+/// Widget for adding new fields to objects
+#[component]
+fn AddFieldWidget(root: Signal<Data<'static>>, path: String) -> Element {
+    let mut field_name = use_signal(|| String::new());
+    let mut field_value = use_signal(|| String::new());
+    let mut error = use_signal(|| None::<String>);
+    let mut show_form = use_signal(|| false);
+
+    let path_for_enter = path.clone();
+    let path_for_button = path.clone();
+
+    rsx! {
+        div { class: "add-field-widget",
+            if !show_form() {
+                button {
+                    class: "add-button",
+                    onclick: move |_| show_form.set(true),
+                    "+ Add Field"
+                }
+            } else {
+                div { class: "add-field-form",
+                    input {
+                        r#type: "text",
+                        placeholder: "Field name",
+                        value: "{field_name}",
+                        oninput: move |evt| field_name.set(evt.value()),
+                    }
+                    input {
+                        r#type: "text",
+                        placeholder: r#"Value: {{}}, [], true, 123, "text""#,
+                        value: "{field_value}",
+                        oninput: move |evt| field_value.set(evt.value()),
+                        onkeydown: move |evt| {
+                            use dioxus::prelude::keyboard_types::Key;
+                            if evt.key() == Key::Enter {
+                                let name = field_name();
+                                let value_text = field_value();
+
+                                if name.is_empty() {
+                                    error.set(Some("Field name required".to_string()));
+                                    return;
+                                }
+
+                                let new_value = match infer_data_from_text(&value_text) {
+                                    Ok(data) => data,
+                                    Err(e) => {
+                                        error.set(Some(e));
+                                        return;
+                                    }
+                                };
+
+                                let mut new_data = root.read().clone();
+                                if let Some(Data::Object(obj)) = new_data.get_at_path_mut(path_for_enter.as_str()) {
+                                    obj.0.insert(name.into(), new_value);
+                                }
+                                root.set(new_data);
+
+                                // Reset form
+                                field_name.set(String::new());
+                                field_value.set(String::new());
+                                show_form.set(false);
+                                error.set(None);
+                            }
+                        }
+                    }
+                    button {
+                        class: "add-field-widget-edit",
+                        onclick: move |_| {
+                            let name = field_name();
+                            let value_text = field_value();
+
+                            if name.is_empty() {
+                                error.set(Some("Field name required".to_string()));
+                                return;
+                            }
+
+                            let new_value = match infer_data_from_text(&value_text) {
+                                Ok(data) => data,
+                                Err(e) => {
+                                    error.set(Some(e));
+                                    return;
+                                }
+                            };
+
+                            let mut new_data = root.read().clone();
+                            if let Some(Data::Object(obj)) = new_data.get_at_path_mut(path_for_button.as_str()) {
+                                obj.0.insert(name.into(), new_value);
+                            }
+                            root.set(new_data);
+
+                            // Reset form
+                            field_name.set(String::new());
+                            field_value.set(String::new());
+                            show_form.set(false);
+                            error.set(None);
+                        },
+                        "Add"
+                    }
+                    button {
+                        class: "add-field-widget-edit",
+                        onclick: move |_| {
+                            show_form.set(false);
+                            field_name.set(String::new());
+                            field_value.set(String::new());
+                            error.set(None);
+                        },
+                        "Cancel"
+                    }
+                    if let Some(err) = error() {
+                        div { class: "field-error", "❌ {err}" }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[component]
+pub fn EditableRecordContent(
+    record_value: Data<'static>,
+    uri: ReadSignal<AtUri<'static>>,
+    view_mode: Signal<ViewMode>,
+    edit_mode: Signal<bool>,
+    record_resource: Resource<Result<GetRecordOutput<'static>, AgentError>>,
+    schema: ReadSignal<Option<LexiconDoc<'static>>>,
+) -> Element {
+    let mut edit_data = use_signal(use_reactive!(|record_value| record_value.clone()));
+    let nsid = use_memo(move || edit_data().type_discriminator().map(|s| s.to_string()));
+    let navigator = use_navigator();
+    let fetcher = use_context::<Fetcher>();
+
+    // Validate edit_data whenever it changes and provide via context
+    let mut validation_result = use_signal(|| None);
+    use_effect(move || {
+        let _ = schema(); // Track schema changes
+        if let Some(nsid_str) = nsid() {
+            let data = edit_data();
+            let validator = jacquard_lexicon::validation::SchemaValidator::global();
+            let result = validator.validate_by_nsid(&nsid_str, &data);
+            validation_result.set(Some(result));
+        }
+    });
+    use_context_provider(|| validation_result);
+
+    let update_fetcher = fetcher.clone();
+    let create_fetcher = fetcher.clone();
+    let replace_fetcher = fetcher.clone();
+    let delete_fetcher = fetcher.clone();
+
+    rsx! {
+        div {
+            class: "tab-bar",
+            button {
+                class: if view_mode() == ViewMode::Pretty { "tab-button active" } else { "tab-button" },
+                onclick: move |_| view_mode.set(ViewMode::Pretty),
+                "View"
+            }
+            button {
+                class: if view_mode() == ViewMode::Json { "tab-button active" } else { "tab-button" },
+                onclick: move |_| view_mode.set(ViewMode::Json),
+                "JSON"
+            }
+            button {
+                class: if view_mode() == ViewMode::Schema { "tab-button active" } else { "tab-button" },
+                onclick: move |_| view_mode.set(ViewMode::Schema),
+                "Schema"
+            }
+            ActionButtons {
+                on_update: move |_| {
+                    let fetcher = update_fetcher.clone();
+                    let uri = uri();
+                    let data = edit_data();
+                    spawn(async move {
+                        if let Some((did, _)) = fetcher.session_info().await {
+                            if let (Some(collection_str), Some(rkey)) = (uri.collection(), uri.rkey()) {
+                                let collection = Nsid::new(collection_str.as_str()).ok();
+                                if let Some(collection) = collection {
+                                    let request = PutRecord::new()
+                                        .repo(AtIdentifier::Did(did))
+                                        .collection(collection)
+                                        .rkey(rkey.clone())
+                                        .record(data.clone())
+                                        .build();
+
+                                    match fetcher.send(request).await {
+                                        Ok(output) => {
+                                            if output.status() == StatusCode::OK.as_u16() {
+                                                tracing::info!("Record updated successfully");
+                                                edit_data.set(data.clone());
+                                                edit_mode.set(false);
+                                            } else {
+                                                tracing::error!("Unexpected status code: {:?}", output.status());
+                                            }
+                                        }
+                                        Err(e) => {
+                                            tracing::error!("Failed to update record: {:?}", e);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    });
+                },
+                on_save_new: move |_| {
+                    let fetcher = create_fetcher.clone();
+                    let data = edit_data();
+                    let nav = navigator.clone();
+                    spawn(async move {
+                        if let Some((did, _)) = fetcher.session_info().await {
+                            if let Some(collection_str) = data.type_discriminator() {
+                                let collection = Nsid::new(collection_str).ok();
+                                if let Some(collection) = collection {
+                                    let request = CreateRecord::new()
+                                        .repo(AtIdentifier::Did(did))
+                                        .collection(collection)
+                                        .record(data.clone())
+                                        .build();
+
+                                    match fetcher.send(request).await {
+                                        Ok(response) => {
+                                            if let Ok(output) = response.into_output() {
+                                                tracing::info!("Record created: {}", output.uri);
+                                                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, output.uri);
+                                                nav.push(link);
+                                            }
+                                        }
+                                        Err(e) => {
+                                            tracing::error!("Failed to create record: {:?}", e);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    });
+                },
+                on_replace: move |_| {
+                    let fetcher = replace_fetcher.clone();
+                    let uri = uri();
+                    let data = edit_data();
+                    let nav = navigator.clone();
+                    spawn(async move {
+                        if let Some((did, _)) = fetcher.session_info().await {
+                            if let Some(new_collection_str) = data.type_discriminator() {
+                                let new_collection = Nsid::new(new_collection_str).ok();
+                                if let Some(new_collection) = new_collection {
+                                    // Create new record
+                                    let create_req = CreateRecord::new()
+                                        .repo(AtIdentifier::Did(did.clone()))
+                                        .collection(new_collection)
+                                        .record(data.clone())
+                                        .build();
+
+                                    match fetcher.send(create_req).await {
+                                        Ok(response) => {
+                                            if let Ok(create_output) = response.into_output() {
+                                                // Delete old record
+                                                if let (Some(old_collection_str), Some(old_rkey)) = (uri.collection(), uri.rkey()) {
+                                                    let old_collection = Nsid::new(old_collection_str.as_str()).ok();
+                                                    if let Some(old_collection) = old_collection {
+                                                        let delete_req = DeleteRecord::new()
+                                                            .repo(AtIdentifier::Did(did))
+                                                            .collection(old_collection)
+                                                            .rkey(old_rkey.clone())
+                                                            .build();
+
+                                                        if let Err(e) = fetcher.send(delete_req).await {
+                                                            tracing::warn!("Created new record but failed to delete old: {:?}", e);
+                                                        }
+                                                    }
+                                                }
+
+                                                tracing::info!("Record replaced: {}", create_output.uri);
+                                                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, create_output.uri);
+                                                nav.push(link);
+                                            }
+                                        }
+                                        Err(e) => {
+                                            tracing::error!("Failed to replace record: {:?}", e);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    });
+                },
+                on_delete: move |_| {
+                    let fetcher = delete_fetcher.clone();
+                    let uri = uri();
+                    let nav = navigator.clone();
+                    spawn(async move {
+                        if let Some((did, _)) = fetcher.session_info().await {
+                            if let (Some(collection_str), Some(rkey)) = (uri.collection(), uri.rkey()) {
+                                let collection = Nsid::new(collection_str.as_str()).ok();
+                                if let Some(collection) = collection {
+                                    let request = DeleteRecord::new()
+                                        .repo(AtIdentifier::Did(did))
+                                        .collection(collection)
+                                        .rkey(rkey.clone())
+                                        .build();
+
+                                    match fetcher.send(request).await {
+                                        Ok(_) => {
+                                            tracing::info!("Record deleted");
+                                            nav.push(Route::Home {});
+                                        }
+                                        Err(e) => {
+                                            tracing::error!("Failed to delete record: {:?}", e);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    });
+                },
+                on_cancel: move |_| {
+                    edit_data.set(record_value.clone());
+                    edit_mode.set(false);
+                },
+            }
+        }
+        div {
+            class: "tab-content",
+            match view_mode() {
+                ViewMode::Pretty => rsx! {
+                    div { class: "pretty-record",
+                        EditableDataView {
+                            root: edit_data,
+                            path: String::new(),
+                            did: uri().authority().to_string(),
+                        }
+                    }
+                },
+                ViewMode::Json => rsx! {
+                    JsonEditor { data: edit_data, nsid, schema }
+                },
+                ViewMode::Schema => rsx! {
+                    SchemaView { schema }
+                },
+            }
+        }
+    }
+}
+
+#[component]
+pub fn JsonEditor(
+    data: Signal<Data<'static>>,
+    nsid: ReadSignal<Option<String>>,
+    schema: ReadSignal<Option<LexiconDoc<'static>>>,
+) -> Element {
+    let mut json_text =
+        use_signal(|| serde_json::to_string_pretty(&*data.read()).unwrap_or_default());
+
+    let height = use_memo(move || {
+        let line_count = json_text().lines().count();
+        let min_lines = 10;
+        let lines = line_count.max(min_lines);
+        // line-height is 1.5, font-size is 0.9rem (approx 14.4px), so each line is ~21.6px
+        // Add padding (1rem top + 1rem bottom = 2rem = 32px)
+        format!("{}px", lines * 22 + 32)
+    });
+
+    let validation = use_resource(move || {
+        let text = json_text();
+        let nsid_val = nsid();
+        let _ = schema(); // Track schema changes
+
+        async move {
+            // Only validate if we have an NSID
+            let nsid_str = nsid_val?;
+
+            // Parse JSON to Data
+            let parsed = match serde_json::from_str::<Data>(&text) {
+                Ok(val) => val.into_static(),
+                Err(e) => {
+                    return Some((None, Some(e.to_string())));
+                }
+            };
+
+            // Use global validator (schema already registered)
+            let validator = jacquard_lexicon::validation::SchemaValidator::global();
+            let result = validator.validate_by_nsid(&nsid_str, &parsed);
+
+            Some((Some(result), None))
+        }
+    });
+
+    rsx! {
+        div { class: "json-editor",
+            textarea {
+                class: "json-textarea",
+                style: "height: {height};",
+                value: "{json_text}",
+                oninput: move |evt| {
+                    json_text.set(evt.value());
+                    // Update data signal on successful parse
+                    if let Ok(parsed) = serde_json::from_str::<Data>(&evt.value()) {
+                        data.set(parsed.into_static());
+                    }
+                },
+            }
+
+            ValidationPanel {
+                validation: validation,
+            }
+        }
+    }
+}
+
+#[component]
+pub fn ActionButtons(
+    on_update: EventHandler<()>,
+    on_save_new: EventHandler<()>,
+    on_replace: EventHandler<()>,
+    on_delete: EventHandler<()>,
+    on_cancel: EventHandler<()>,
+) -> Element {
+    let mut show_save_dropdown = use_signal(|| false);
+    let mut show_replace_warning = use_signal(|| false);
+    let mut show_delete_confirm = use_signal(|| false);
+
+    rsx! {
+        div { class: "action-buttons-group",
+            button {
+                class: "tab-button action-button",
+                onclick: move |_| on_update.call(()),
+                "Update"
+            }
+
+            div { class: "dropdown-wrapper",
+                button {
+                    class: "tab-button action-button",
+                    onclick: move |_| show_save_dropdown.toggle(),
+                    "Save as New ▼"
+                }
+                if show_save_dropdown() {
+                    div { class: "dropdown-menu",
+                        button {
+                            onclick: move |_| {
+                                show_save_dropdown.set(false);
+                                on_save_new.call(());
+                            },
+                            "Save as New"
+                        }
+                        button {
+                            onclick: move |_| {
+                                show_save_dropdown.set(false);
+                                show_replace_warning.set(true);
+                            },
+                            "Replace"
+                        }
+                    }
+                }
+            }
+
+            if show_replace_warning() {
+                div { class: "inline-warning",
+                    "⚠️ This will delete the current record and create a new one with a different rkey. "
+                    button {
+                        onclick: move |_| {
+                            show_replace_warning.set(false);
+                            on_replace.call(());
+                        },
+                        "Yes"
+                    }
+                    button {
+                        onclick: move |_| show_replace_warning.set(false),
+                        "No"
+                    }
+                }
+            }
+
+            button {
+                class: "tab-button action-button action-button-danger",
+                onclick: move |_| show_delete_confirm.set(true),
+                "Delete"
+            }
+
+            DialogRoot {
+                open: Some(show_delete_confirm()),
+                on_open_change: move |open: bool| {
+                    show_delete_confirm.set(open);
+                },
+                DialogContent {
+                    DialogTitle { "Delete Record?" }
+                    DialogDescription {
+                        "This action cannot be undone."
+                    }
+                    div { class: "dialog-actions",
+                        button {
+                            onclick: move |_| {
+                                show_delete_confirm.set(false);
+                                on_delete.call(());
+                            },
+                            "Delete"
+                        }
+                        button {
+                            onclick: move |_| show_delete_confirm.set(false),
+                            "Cancel"
+                        }
+                    }
+                }
+            }
+
+            button {
+                class: "tab-button action-button",
+                onclick: move |_| on_cancel.call(()),
+                "Cancel"
+            }
+        }
+    }
+}
+
+#[component]
+pub fn ValidationPanel(
+    validation: Resource<Option<(Option<ValidationResult>, Option<String>)>>,
+) -> Element {
+    rsx! {
+        div { class: "validation-panel",
+            if let Some(Some((result_opt, parse_error_opt))) = validation.read().as_ref() {
+                if let Some(parse_err) = parse_error_opt {
+                    div { class: "parse-error",
+                        "❌ Invalid JSON: {parse_err}"
+                    }
+                }
+
+                if let Some(result) = result_opt {
+                    // Structural validity
+                    if result.is_structurally_valid() {
+                        div { class: "validation-success", "✓ Structurally valid" }
+                    } else {
+                        div { class: "parse-error", "❌ Structurally invalid" }
+                    }
+
+                    // Overall validity
+                    if result.is_valid() {
+                        div { class: "validation-success", "✓ Fully valid" }
+                    } else {
+                        div { class: "validation-warning", "⚠ Has errors" }
+                    }
+
+                    // Show errors if any
+                    if !result.is_valid() {
+                        div { class: "validation-errors",
+                            h4 { "Validation Errors:" }
+                            for error in result.all_errors() {
+                                div { class: "error", "{error}" }
+                            }
+                        }
+                    }
+                }
+            } else {
+                div { "Validating..." }
+            }
+        }
+    }
+}

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

···
+use crate::components::accordion::{Accordion, AccordionContent, AccordionItem, AccordionTrigger};
+use crate::record_utils::{get_errors_at_exact_path, get_expected_string_format, get_hex_rep};
+use dioxus::prelude::*;
+use humansize::format_size;
+use jacquard::to_data;
+use jacquard::types::string::AtprotoStr;
+use jacquard::{
+    common::{Data, IntoStatic},
+    types::{aturi::AtUri, cid::Cid},
+};
+use jacquard_lexicon::lexicon::LexiconDoc;
+use jacquard_lexicon::validation::ValidationResult;
+use weaver_renderer::{code_pretty::highlight_code, css::generate_default_css};
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum ViewMode {
+    Pretty,
+    Json,
+    Schema,
+}
+
+/// Layout component for record view - handles header, metadata, and wraps children
+#[component]
+pub fn RecordViewLayout(
+    uri: AtUri<'static>,
+    cid: Option<Cid<'static>>,
+    schema: ReadSignal<Option<LexiconDoc<'static>>>,
+    record_value: Data<'static>,
+    children: Element,
+) -> Element {
+    // Validate the record if schema is available
+    let validation_status = use_memo(move || {
+        let _schema_doc = schema()?;
+        let nsid_str = record_value.type_discriminator()?;
+
+        let validator = jacquard_lexicon::validation::SchemaValidator::global();
+        let result = validator.validate_by_nsid(nsid_str, &record_value);
+
+        Some(result.is_valid())
+    });
+
+    rsx! {
+        div {
+            class: "record-metadata",
+            div { class: "metadata-row",
+                span { class: "metadata-label", "URI" }
+                span { class: "metadata-value",
+                    HighlightedUri { uri: uri.clone() }
+                }
+            }
+            if let Some(cid) = cid {
+                div { class: "metadata-row",
+                    span { class: "metadata-label", "CID" }
+                    code { class: "metadata-value", "{cid}" }
+                }
+            }
+            if let Some(is_valid) = validation_status() {
+                div { class: "metadata-row",
+                    span { class: "metadata-label", "Schema" }
+                    span {
+                        class: if is_valid { "metadata-value schema-valid" } else { "metadata-value schema-invalid" },
+                        if is_valid { "Valid" } else { "Invalid" }
+                    }
+                }
+            }
+        }
+
+        {children}
+
+    }
+}
+
+#[component]
+pub fn SchemaView(schema: ReadSignal<Option<LexiconDoc<'static>>>) -> Element {
+    if let Some(schema_doc) = schema() {
+        // Convert LexiconDoc to Data for display
+        let schema_data = to_data(&schema_doc).ok().map(|d| d.into_static());
+
+        if let Some(data) = schema_data {
+            rsx! {
+                div {
+                    class: "pretty-record",
+                    DataView { data: data.clone(), root_data: data, path: String::new(), did: String::new() }
+                }
+            }
+        } else {
+            rsx! {
+                div { class: "schema-error", "Failed to convert schema to displayable format" }
+            }
+        }
+    } else {
+        rsx! {
+            div { class: "schema-loading", "Loading schema..." }
+        }
+    }
+}
+
+#[component]
+pub fn DataView(
+    data: Data<'static>,
+    root_data: ReadSignal<Data<'static>>,
+    path: String,
+    did: String,
+) -> Element {
+    // Try to get validation result from context and get errors exactly at this path
+    let validation_result = try_use_context::<Signal<Option<ValidationResult>>>();
+
+    let errors = if let Some(vr_signal) = validation_result {
+        get_errors_at_exact_path(&*vr_signal.read(), &path)
+    } else {
+        Vec::new()
+    };
+
+    let has_errors = !errors.is_empty();
+
+    match &data {
+        Data::Null => rsx! {
+            div { class: if has_errors { "record-field field-error" } else { "record-field" },
+                PathLabel { path: path.clone() }
+                span { class: "field-value muted", "null" }
+                if has_errors {
+                    for error in &errors {
+                        div { class: "field-error-message", "{error}" }
+                    }
+                }
+            }
+        },
+        Data::Boolean(b) => rsx! {
+            div { class: if has_errors { "record-field field-error" } else { "record-field" },
+                PathLabel { path: path.clone() }
+                span { class: "field-value", "{b}" }
+                if has_errors {
+                    for error in &errors {
+                        div { class: "field-error-message", "{error}" }
+                    }
+                }
+            }
+        },
+        Data::Integer(i) => rsx! {
+            div { class: if has_errors { "record-field field-error" } else { "record-field" },
+                PathLabel { path: path.clone() }
+                span { class: "field-value", "{i}" }
+                if has_errors {
+                    for error in &errors {
+                        div { class: "field-error-message", "{error}" }
+                    }
+                }
+            }
+        },
+        Data::String(s) => {
+            use jacquard::types::string::AtprotoStr;
+            use jacquard_lexicon::lexicon::LexStringFormat;
+
+            // Get expected format from schema
+            let expected_format = get_expected_string_format(&*root_data.read(), &path);
+
+            // Get actual type from data
+            let actual_type_label = match s {
+                AtprotoStr::Datetime(_) => "datetime",
+                AtprotoStr::Language(_) => "language",
+                AtprotoStr::Tid(_) => "tid",
+                AtprotoStr::Nsid(_) => "nsid",
+                AtprotoStr::Did(_) => "did",
+                AtprotoStr::Handle(_) => "handle",
+                AtprotoStr::AtIdentifier(_) => "at-identifier",
+                AtprotoStr::AtUri(_) => "at-uri",
+                AtprotoStr::Uri(_) => "uri",
+                AtprotoStr::Cid(_) => "cid",
+                AtprotoStr::RecordKey(_) => "record-key",
+                AtprotoStr::String(_) => "string",
+            };
+
+            // Prefer schema format if available, otherwise use actual type
+            let type_label = if let Some(fmt) = expected_format {
+                match fmt {
+                    LexStringFormat::Datetime => "datetime",
+                    LexStringFormat::Uri => "uri",
+                    LexStringFormat::AtUri => "at-uri",
+                    LexStringFormat::Did => "did",
+                    LexStringFormat::Handle => "handle",
+                    LexStringFormat::AtIdentifier => "at-identifier",
+                    LexStringFormat::Nsid => "nsid",
+                    LexStringFormat::Cid => "cid",
+                    LexStringFormat::Language => "language",
+                    LexStringFormat::Tid => "tid",
+                    LexStringFormat::RecordKey => "record-key",
+                }
+            } else {
+                actual_type_label
+            };
+
+            rsx! {
+                div { class: if has_errors { "record-field field-error" } else { "record-field" },
+                    PathLabel { path: path.clone() }
+                    span { class: "field-value",
+
+                        HighlightedString { string_type: s.clone() }
+                        if type_label != "string" {
+                            span { class: "string-type-tag", " [{type_label}]" }
+                        }
+                    }
+                    if has_errors {
+                        for error in &errors {
+                            div { class: "field-error-message", "{error}" }
+                        }
+                    }
+                }
+            }
+        }
+        Data::Bytes(b) => {
+            let hex_string = get_hex_rep(&mut b.to_vec());
+            let byte_size = if b.len() > 128 {
+                format_size(b.len(), humansize::BINARY)
+            } else {
+                format!("{} bytes", b.len())
+            };
+            rsx! {
+                div { class: if has_errors { "record-field field-error" } else { "record-field" },
+                    PathLabel { path: path.clone() }
+                    pre { class: "field-value bytes", "{hex_string} [{byte_size}]" }
+                    if has_errors {
+                        for error in &errors {
+                            div { class: "field-error-message", "{error}" }
+                        }
+                    }
+                }
+            }
+        }
+        Data::CidLink(cid) => rsx! {
+            div { class: if has_errors { "record-field field-error" } else { "record-field" },
+                span { class: "field-label", "{path}" }
+                span { class: "field-value", "{cid}" }
+                if has_errors {
+                    for error in &errors {
+                        div { class: "field-error-message", "{error}" }
+                    }
+                }
+            }
+        },
+        Data::Array(arr) => {
+            let label = path.split('.').last().unwrap_or(&path);
+            rsx! {
+                div { class: "record-section",
+                    Accordion {
+                        id: "array-{path}",
+                        collapsible: true,
+                        AccordionItem {
+                            default_open: true,
+                            index: 0,
+                            AccordionTrigger {
+                                div { class: "section-label", "{label}" span { class: "array-len", "[{arr.len()}]" } }
+                            }
+                            AccordionContent {
+                                if has_errors {
+                                    for error in &errors {
+                                        div { class: "field-error-message", "{error}" }
+                                    }
+                                }
+                                div { class: "section-content",
+                                    for (idx, item) in arr.iter().enumerate() {
+                                        {
+                                            let item_path = format!("{}[{}]", label, idx);
+                                            let is_object = matches!(item, Data::Object(_));
+
+                                            if is_object {
+                                                rsx! {
+                                                    div {
+                                                        class: "array-item",
+                                                    div { class: "record-section",
+                                                        div { class: "section-label", "{item_path}" }
+                                                        div { class: "section-content",
+                                                            DataView {
+                                                                data: item.clone(),
+                                                                root_data,
+                                                                path: item_path.clone(),
+                                                                did: did.clone()
+                                                            }
+                                                        }
+                                                    }
+                                                    }
+                                                }
+                                            } else {
+                                                rsx! {
+                                                    div {
+                                                        class: "array-item",
+                                                    DataView {
+                                                        data: item.clone(),
+                                                        root_data,
+                                                        path: item_path,
+                                                        did: did.clone()
+                                                    }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Data::Object(obj) => {
+            let is_root = path.is_empty();
+            let is_array_item = path.split('.').last().unwrap_or(&path).contains('[');
+
+            if is_root || is_array_item {
+                // Root object or array item: just render children (array items already wrapped)
+                rsx! {
+                    div { class: if !is_root { "record-section" } else {""},
+                        if has_errors {
+                            for error in &errors {
+                                div { class: "field-error-message", "{error}" }
+                            }
+                        }
+                        for (key, value) in obj.iter() {
+                            {
+                                let new_path = if is_root {
+                                    key.to_string()
+                                } else {
+                                    format!("{}.{}", path, key)
+                                };
+                                let did_clone = did.clone();
+                                rsx! {
+                                    DataView { data: value.clone(), root_data, path: new_path, did: did_clone }
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                // Nested object (not array item): wrap in section
+                let label = path.split('.').last().unwrap_or(&path);
+                rsx! {
+                    div { class: "record-section",
+                        Accordion {
+                            id: "object-{path}",
+                            collapsible: true,
+                            AccordionItem {
+                                default_open: true,
+                                index: 0,
+                                AccordionTrigger {
+                                    div { class: "section-label", "{label}" }
+                                }
+                                AccordionContent {
+                                    if has_errors {
+                                        for error in &errors {
+                                            div { class: "field-error-message", "{error}" }
+                                        }
+                                    }
+                                    div { class: "section-content",
+                                        for (key, value) in obj.iter() {
+                                            {
+                                                let new_path = format!("{}.{}", path, key);
+                                                let did_clone = did.clone();
+                                                rsx! {
+                                                    DataView { data: value.clone(), root_data, path: new_path, did: did_clone }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Data::Blob(blob) => {
+            let is_image = blob.mime_type.starts_with("image/");
+            let format = blob.mime_type.strip_prefix("image/").unwrap_or("jpeg");
+            let image_url = format!(
+                "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@{}",
+                did,
+                blob.cid(),
+                format
+            );
+
+            let blob_size = format_size(blob.size, humansize::BINARY);
+            rsx! {
+                div { class: "record-field",
+                    span { class: "field-label", "{path}" }
+                    span { class: "field-value mime", "[mimeType: {blob.mime_type}, size: {blob_size}]" }
+                    if is_image {
+                        img {
+                            src: "{image_url}",
+                            alt: "Blob image",
+                            class: "blob-image",
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[component]
+pub fn HighlightedUri(uri: AtUri<'static>) -> Element {
+    let s = uri.as_str();
+    let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, s);
+
+    if let Some(rest) = s.strip_prefix("at://") {
+        let parts: Vec<&str> = rest.splitn(3, '/').collect();
+        return rsx! {
+            a {
+                href: link,
+                class: "uri-link",
+                span { class: "string-at-uri",
+                    span { class: "aturi-scheme", "at://" }
+                    span { class: "aturi-authority", "{uri.authority()}" }
+
+                    if parts.len() > 1 {
+                        span { class: "aturi-slash", "/" }
+                        if let Some(collection) = uri.collection() {
+                            span { class: "aturi-collection", "{collection.as_ref()}" }
+                        }
+                    }
+                    if parts.len() > 2 {
+                        span { class: "aturi-slash", "/" }
+                        if let Some(rkey) = uri.rkey() {
+                            span { class: "aturi-rkey", "{rkey.as_ref()}" }
+                        }
+                    }
+                }
+            }
+        };
+    }
+
+    rsx! { a { class: "string-at-uri", href: s } }
+}
+
+#[component]
+pub fn HighlightedString(string_type: AtprotoStr<'static>) -> Element {
+    use jacquard::types::string::AtprotoStr;
+
+    match &string_type {
+        AtprotoStr::Nsid(nsid) => {
+            let parts: Vec<&str> = nsid.as_str().split('.').collect();
+            rsx! {
+                span { class: "string-nsid",
+                    for (i, part) in parts.iter().enumerate() {
+                        span { class: "nsid-segment nsid-segment-{i % 3}", "{part}" }
+                        if i < parts.len() - 1 {
+                            span { class: "nsid-dot", "." }
+                        }
+                    }
+                }
+            }
+        }
+        AtprotoStr::Did(did) => {
+            let s = did.as_str();
+            if let Some(rest) = s.strip_prefix("did:") {
+                if let Some((method, identifier)) = rest.split_once(':') {
+                    return rsx! {
+                        span { class: "string-did",
+                            span { class: "did-scheme", "did:" }
+                            span { class: "did-method", "{method}" }
+                            span { class: "did-separator", ":" }
+                            span { class: "did-identifier", "{identifier}" }
+                        }
+                    };
+                }
+            }
+            rsx! { span { class: "string-did", "{s}" } }
+        }
+        AtprotoStr::Handle(handle) => {
+            let parts: Vec<&str> = handle.as_str().split('.').collect();
+            rsx! {
+                span { class: "string-handle",
+                    for (i, part) in parts.iter().enumerate() {
+                        span { class: "handle-segment handle-segment-{i % 2}", "{part}" }
+                        if i < parts.len() - 1 {
+                            span { class: "handle-dot", "." }
+                        }
+                    }
+                }
+            }
+        }
+        AtprotoStr::AtUri(uri) => {
+            rsx! {
+                HighlightedUri { uri: uri.clone().into_static() }
+            }
+        }
+        AtprotoStr::Uri(uri) => {
+            let s = uri.as_str();
+            if let Ok(at_uri) = AtUri::new(s) {
+                return rsx! {
+                    HighlightedUri { uri: at_uri.into_static() }
+                };
+            }
+
+            // Try to parse scheme
+            if let Some((scheme, rest)) = s.split_once("://") {
+                // Split authority and path
+                let (authority, path) = if let Some(idx) = rest.find('/') {
+                    (&rest[..idx], &rest[idx..])
+                } else {
+                    (rest, "")
+                };
+
+                return rsx! {
+                    a {
+                        href: "{s}",
+                        target: "_blank",
+                        rel: "noopener noreferrer",
+                        class: "uri-link",
+                        span { class: "string-uri",
+                            span { class: "uri-scheme", "{scheme}" }
+                            span { class: "uri-separator", "://" }
+                            span { class: "uri-authority", "{authority}" }
+                            if !path.is_empty() {
+                                span { class: "uri-path", "{path}" }
+                            }
+                        }
+                    }
+                };
+            }
+
+            rsx! { span { class: "string-uri", "{s}" } }
+        }
+        _ => {
+            let value = string_type.as_str();
+            rsx! { "{value}" }
+        }
+    }
+}
+
+#[derive(Props, Clone, PartialEq)]
+pub struct CodeViewProps {
+    #[props(default)]
+    id: Signal<String>,
+    #[props(default)]
+    class: Signal<String>,
+    code: ReadSignal<String>,
+    lang: Option<String>,
+}
+
+#[component]
+pub fn PrettyRecordView(
+    record: Data<'static>,
+    uri: AtUri<'static>,
+    schema: ReadSignal<Option<LexiconDoc<'static>>>,
+) -> Element {
+    let did = uri.authority().to_string();
+    let root_data = use_signal(|| record.clone());
+
+    // Validate the record and provide via context - only after schema is loaded
+    let mut validation_result = use_signal(|| None);
+    use_effect(move || {
+        // Wait for schema to be loaded
+        if schema().is_some() {
+            if let Some(nsid_str) = root_data.read().type_discriminator() {
+                let validator = jacquard_lexicon::validation::SchemaValidator::global();
+                let result = validator.validate_by_nsid(nsid_str, &*root_data.read());
+                validation_result.set(Some(result));
+            }
+        }
+    });
+    use_context_provider(|| validation_result);
+
+    rsx! {
+        div {
+            class: "pretty-record",
+            DataView { data: record, root_data, path: String::new(), did }
+        }
+    }
+}
+
+#[component]
+pub fn CodeView(props: CodeViewProps) -> Element {
+    let code = &*props.code.read();
+
+    let mut html_buf = String::new();
+    highlight_code(props.lang.as_deref(), code, &mut html_buf).unwrap();
+
+    rsx! {
+        document::Style { {generate_default_css().unwrap()}}
+        div {
+            id: "{&*props.id.read()}",
+            class: "{&*props.class.read()}",
+            dangerous_inner_html: "{html_buf}"
+        }
+    }
+}
+
+#[component]
+pub fn PathLabel(path: String) -> Element {
+    if path.is_empty() {
+        return rsx! {};
+    }
+
+    // Find the last separator
+    let last_sep = path.rfind(|c| c == '.');
+
+    if let Some(idx) = last_sep {
+        let prefix = &path[..idx + 1];
+        let final_segment = &path[idx + 1..];
+        rsx! {
+            span { class: "field-label",
+                span { class: "path-prefix", "{prefix}" }
+                span { class: "path-final", "{final_segment}" }
+            }
+        }
+    } else {
+        rsx! {
+            span { class: "field-label","{path}" }
+        }
+    }
+}

crates/weaver-app/src/data.rs

···
 //! In fullstack-server mode, hooks use `use_server_future` with inline async closures.
 //! In client-only mode, hooks use `use_resource` with context-provided fetchers.
 
+use crate::auth::AuthState;
 #[cfg(feature = "server")]
 use crate::blobcache::BlobCache;
 use dioxus::prelude::*;
 #[cfg(feature = "fullstack-server")]
 #[allow(unused_imports)]
 use dioxus::{CapturedError, fullstack::extract::Extension};
-use jacquard::types::{did::Did, string::Handle};
+use jacquard::{
+    IntoStatic,
+    identity::resolver::IdentityError,
+    types::{did::Did, string::Handle},
+};
 #[allow(unused_imports)]
 use jacquard::{
     prelude::IdentityResolver,
     smol_str::SmolStr,
     types::{cid::Cid, string::AtIdentifier},
 };
+use std::cell::Ref;
 #[allow(unused_imports)]
 use std::sync::Arc;
+use weaver_api::com_atproto::repo::strong_ref::StrongRef;
+use weaver_api::sh_weaver::actor::ProfileDataView;
 use weaver_api::sh_weaver::notebook::{BookEntryView, NotebookView, entry::Entry};
 // ============================================================================
 // Wrapper Hooks (feature-gated)
 // ============================================================================
 
 /// Fetches entry data with SSR support in fullstack mode.
-/// Returns a MappedSignal over the server future resource.
 #[cfg(feature = "fullstack-server")]
 pub fn use_entry_data(
     ident: AtIdentifier<'static>,
     book_title: SmolStr,
     title: SmolStr,
 ) -> Result<Memo<Option<(BookEntryView<'static>, Entry<'static>)>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
     let ident = use_signal(|| ident);
     let book_title = use_signal(|| book_title);
···
         })
     })
 }
-
 /// Fetches entry data client-side only (no SSR).
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_entry_data(
···
     book_title: SmolStr,
     title: SmolStr,
 ) -> Result<Memo<Option<(BookEntryView<'static>, Entry<'static>)>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
     let ident = use_signal(|| ident);
     let book_title = use_signal(|| book_title);
     let entry_title = use_signal(|| title);
-    let r = use_resource(move || {
+    let res = use_resource(move || {
         let fetcher = fetcher.clone();
         async move {
             fetcher
···
                 .await
                 .ok()
                 .flatten()
-                .map(|arc| (arc.0.clone(), arc.1.clone()))
+                .map(|arc| {
+                    (
+                        serde_json::to_value(entry.0.clone()).unwrap(),
+                        serde_json::to_value(entry.1.clone()).unwrap(),
+                    )
+                })
         }
     });
-    Ok(use_memo(move || {
-        if let Some(Some((ev, e))) = &*r.read_unchecked() {
-            Some((ev.clone(), e.clone()))
-        } else {
-            None
-        }
-    }))
+    res.map(|r| {
+        use_memo(move || {
+            if let Some(Some((ev, e))) = &*r.read_unchecked() {
+                use jacquard::from_json_value;
+
+                let book_entry = from_json_value::<BookEntryView>(ev.clone()).unwrap();
+                let entry = from_json_value::<Entry>(e.clone()).unwrap();
+
+                Some((book_entry, entry))
+            } else {
+                None
+            }
+        })
+    })
+}
+
+pub fn get_handle(did: Did<'static>) -> AtIdentifier<'static> {
+    let ident = AtIdentifier::Did(did);
+    use_handle(ident.clone())
+        .read()
+        .as_ref()
+        .unwrap_or(&Ok(ident))
+        .as_ref()
+        .unwrap()
+        .clone()
 }
 
 pub fn use_handle(
     ident: AtIdentifier<'static>,
-) -> Result<Memo<AtIdentifier<'static>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+) -> Resource<Result<AtIdentifier<'static>, IdentityError>> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let fetcher = fetcher.clone();
     let ident = use_signal(|| ident);
-    #[cfg(feature = "fullstack-server")]
-    let h_str = {
-        use_server_future(move || {
-            let client = fetcher.get_client();
-            async move {
-                use jacquard::smol_str::ToSmolStr;
-                client
-                    .resolve_ident_owned(&ident())
-                    .await
-                    .map(|doc| doc.handles().first().map(|h| h.to_smolstr()))
-                    .ok()
-                    .flatten()
-            }
-        })
+
+    use_resource(move || {
+        let client = fetcher.get_client();
+        async move {
+            client
+                .resolve_ident_owned(&*ident.read())
+                .await
+                .map(|doc| {
+                    doc.handles()
+                        .first()
+                        .map(|h| AtIdentifier::Handle(h.clone()).into_static())
+                })
+                .map(|h| h.ok_or(IdentityError::invalid_well_known()))?
+        }
+    })
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct NotebookHandle(pub Arc<Option<AtIdentifier<'static>>>);
+
+impl NotebookHandle {
+    pub fn as_ref(&self) -> Option<&AtIdentifier<'static>> {
+        self.0.as_ref().as_ref()
+    }
+}
+
+pub fn use_notebook_handle(ident: Signal<Option<AtIdentifier<'static>>>) -> NotebookHandle {
+    let ident = if let Some(ident) = &*ident.read() {
+        if let Some(Ok(handle)) = &*use_handle(ident.clone()).read() {
+            Some(handle.clone())
+        } else {
+            Some(ident.clone())
+        }
+    } else {
+        ident.read().clone()
     };
-    #[cfg(not(feature = "fullstack-server"))]
-    let h_str = {
-        use_resource(move || {
-            let client = fetcher.get_client();
-            async move {
-                use jacquard::smol_str::ToSmolStr;
-                client
-                    .resolve_ident_owned(&ident())
-                    .await
-                    .map(|doc| doc.handles().first().map(|h| h.to_smolstr()))
-                    .ok()
-                    .flatten()
-            }
-        })
-    };
-    Ok(h_str.map(|h_str| {
-        use_memo(move || {
-            if let Some(Some(e)) = &*h_str.read_unchecked() {
-                use jacquard::IntoStatic;
-
-                AtIdentifier::Handle(Handle::raw(&e).into_static())
-            } else {
-                ident()
-            }
-        })
-    })?)
+    use_context_provider(|| NotebookHandle(Arc::new(ident)))
 }
 
 /// Hook to render markdown client-side only (no SSR).
···
 ) -> Result<Resource<Option<String>>, RenderError> {
     let ident = use_signal(|| ident);
     let content = use_signal(|| content);
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     Ok(use_server_future(move || {
         let client = fetcher.get_client();
         async move {
···
 ) -> Result<Resource<Option<String>>, RenderError> {
     let ident = use_signal(|| ident);
     let content = use_signal(|| content);
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     Ok(use_resource(move || {
         let client = fetcher.get_client();
         async move {
···
     };
 
     let ctx = ClientContext::<()>::new(content.clone(), did);
-    let parser = markdown_weaver::Parser::new(&content.content);
+    let parser =
+        markdown_weaver::Parser::new_ext(&content.content, weaver_renderer::default_md_options());
     let iter = ContextIterator::default(parser);
     let processor = NotebookProcessor::new(ctx, iter);
 
···
 #[cfg(feature = "fullstack-server")]
 pub fn use_profile_data(
     ident: AtIdentifier<'static>,
-) -> Result<Memo<Option<weaver_api::sh_weaver::actor::ProfileDataView<'static>>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+) -> Result<Memo<Option<ProfileDataView<'static>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let ident = use_signal(|| ident);
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
     })?;
     Ok(use_memo(move || {
         if let Some(Some(value)) = &*res.read_unchecked() {
-            jacquard::from_json_value::<weaver_api::sh_weaver::actor::ProfileDataView>(
-                value.clone(),
-            )
-            .ok()
+            jacquard::from_json_value::<ProfileDataView>(value.clone()).ok()
         } else {
             None
         }
···
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_profile_data(
     ident: AtIdentifier<'static>,
-) -> Result<Memo<Option<weaver_api::sh_weaver::actor::ProfileDataView<'static>>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
-    let r = use_resource(use_reactive!(|ident| {
+) -> Result<Memo<Option<ProfileDataView<'static>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let ident = use_signal(|| ident);
+    let res = use_resource(move || {
         let fetcher = fetcher.clone();
         async move {
             fetcher
-                .fetch_profile(&ident)
+                .fetch_profile(&ident())
                 .await
                 .ok()
-                .map(|arc| (*arc).clone())
+                .map(|arc| serde_json::to_value(&*arc).ok())
+                .flatten()
         }
-    }));
+    });
     Ok(use_memo(move || {
-        r.read_unchecked().as_ref().and_then(|v| v.clone())
+        if let Some(Some(value)) = &*res.read_unchecked() {
+            jacquard::from_json_value::<ProfileDataView>(value.clone()).ok()
+        } else {
+            None
+        }
     }))
 }
 
···
 #[cfg(feature = "fullstack-server")]
 pub fn use_notebooks_for_did(
     ident: AtIdentifier<'static>,
-) -> Result<
-    Memo<
-        Option<
-            Vec<(
-                weaver_api::sh_weaver::notebook::NotebookView<'static>,
-                Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>,
-            )>,
-        >,
-    >,
-    RenderError,
-> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+) -> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let ident = use_signal(|| ident);
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
···
             values
                 .iter()
                 .map(|v| {
-                    jacquard::from_json_value::<(
-                        weaver_api::sh_weaver::notebook::NotebookView,
-                        Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef>,
-                    )>(v.clone())
-                    .ok()
+                    jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(v.clone()).ok()
                 })
                 .collect::<Option<Vec<_>>>()
         } else {
···
 #[cfg(not(feature = "fullstack-server"))]
 pub fn use_notebooks_for_did(
     ident: AtIdentifier<'static>,
-) -> Result<
-    Memo<
-        Option<
-            Vec<(
-                weaver_api::sh_weaver::notebook::NotebookView<'static>,
-                Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>,
-            )>,
-        >,
-    >,
-    RenderError,
-> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
-    let r = use_resource(use_reactive!(|ident| {
+) -> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let ident = use_signal(|| ident);
+    let res = use_resource(move || {
         let fetcher = fetcher.clone();
         async move {
             fetcher
-                .fetch_notebooks_for_did(&ident)
+                .fetch_notebooks_for_did(&ident())
                 .await
                 .ok()
-                .map(|notebooks| notebooks.iter().map(|arc| (*arc).clone()).collect())
+                .map(|notebooks| {
+                    notebooks
+                        .iter()
+                        .map(|arc| serde_json::to_value(arc.as_ref()).ok())
+                        .collect::<Option<Vec<_>>>()
+                })
+                .flatten()
         }
-    }));
+    });
     Ok(use_memo(move || {
-        r.read_unchecked().as_ref().and_then(|v| v.clone())
+        if let Some(Some(values)) = &*res.read_unchecked() {
+            values
+                .iter()
+                .map(|v| {
+                    jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(v.clone()).ok()
+                })
+                .collect::<Option<Vec<_>>>()
+        } 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<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>>,
-    RenderError,
-> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+pub fn use_notebooks_from_ufos()
+-> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(move || {
         let fetcher = fetcher.clone();
         async move {
···
             values
                 .iter()
                 .map(|v| {
-                    jacquard::from_json_value::<(
-                        NotebookView,
-                        Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef>,
-                    )>(v.clone())
-                    .ok()
+                    jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(v.clone()).ok()
                 })
                 .collect::<Option<Vec<_>>>()
         } else {
···
 
 /// 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<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>>,
-    RenderError,
-> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
-    let r = use_resource(move || {
+pub fn use_notebooks_from_ufos()
+-> Result<Memo<Option<Vec<(NotebookView<'static>, Vec<StrongRef<'static>>)>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let res = use_resource(move || {
         let fetcher = fetcher.clone();
         async move {
             fetcher
                 .fetch_notebooks_from_ufos()
                 .await
                 .ok()
-                .map(|notebooks| notebooks.iter().map(|arc| (*arc).clone()).collect())
+                .map(|notebooks| {
+                    notebooks
+                        .iter()
+                        .map(|arc| serde_json::to_value(arc.as_ref()).ok())
+                        .collect::<Option<Vec<_>>>()
+                })
+                .flatten()
         }
     });
     Ok(use_memo(move || {
-        r.read_unchecked().as_ref().and_then(|v| v.clone())
+        if let Some(Some(values)) = &*res.read_unchecked() {
+            values
+                .iter()
+                .map(|v| {
+                    jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(v.clone()).ok()
+                })
+                .collect::<Option<Vec<_>>>()
+        } else {
+            None
+        }
     }))
 }
 
···
 pub fn use_notebook(
     ident: AtIdentifier<'static>,
     book_title: SmolStr,
-) -> Result<
-    Memo<Option<(NotebookView<'static>, Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>,
-    RenderError,
-> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+) -> Result<Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let ident = use_signal(|| ident);
     let book_title = use_signal(|| book_title);
     let res = use_server_future(move || {
···
     })?;
     Ok(use_memo(move || {
         if let Some(Some(value)) = &*res.read_unchecked() {
-            jacquard::from_json_value::<(
-                NotebookView,
-                Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef>,
-            )>(value.clone())
-            .ok()
+            jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
         } else {
             None
         }
···
 pub fn use_notebook(
     ident: AtIdentifier<'static>,
     book_title: SmolStr,
-) -> Result<
-    Memo<Option<(NotebookView<'static>, Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>,
-    RenderError,
-> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
-    let r = use_resource(use_reactive!(|(ident, book_title)| {
+) -> Result<Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::Fetcher>();
+    let ident = use_signal(|| ident);
+    let book_title = use_signal(|| book_title);
+    let res = use_resource(move || {
         let fetcher = fetcher.clone();
         async move {
             fetcher
-                .get_notebook(ident, book_title)
+                .get_notebook(ident(), book_title())
                 .await
                 .ok()
                 .flatten()
-                .map(|arc| (*arc).clone())
+                .map(|arc| serde_json::to_value(arc.as_ref()).ok())
+                .flatten()
         }
-    }));
+    });
     Ok(use_memo(move || {
-        r.read_unchecked().as_ref().and_then(|v| v.clone())
+        if let Some(Some(value)) = &*res.read_unchecked() {
+            jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
+        } else {
+            None
+        }
     }))
 }
 
···
     ident: AtIdentifier<'static>,
     book_title: SmolStr,
 ) -> Result<Memo<Option<Vec<BookEntryView<'static>>>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let ident = use_signal(|| ident);
     let book_title = use_signal(|| book_title);
     let res = use_server_future(move || {
···
     ident: AtIdentifier<'static>,
     book_title: SmolStr,
 ) -> Result<Memo<Option<Vec<BookEntryView<'static>>>>, RenderError> {
-    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let fetcher = use_context::<crate::fetch::Fetcher>();
     let r = use_resource(use_reactive!(|(ident, book_title)| {
         let fetcher = fetcher.clone();
         async move {

crates/weaver-app/src/env.rs

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

crates/weaver-app/src/fetch.rs

···
     }
 }
 
+//#[cfg(not(feature = "server"))]
 #[derive(Clone)]
-pub struct CachedFetcher {
+pub struct Fetcher {
     pub client: Arc<Client>,
-    book_cache: cache_impl::Cache<
-        (AtIdentifier<'static>, SmolStr),
-        Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
-    >,
-    entry_cache: cache_impl::Cache<
-        (AtIdentifier<'static>, SmolStr),
-        Arc<(BookEntryView<'static>, Entry<'static>)>,
-    >,
-    profile_cache: cache_impl::Cache<AtIdentifier<'static>, Arc<ProfileDataView<'static>>>,
 }
 
-/// SAFETY: This isn't thread-safe on WASM, but we aren't multithreaded on WASM
-unsafe impl Sync for CachedFetcher {}
-
-/// SAFETY: This isn't thread-safe on WASM, but we aren't multithreaded on WASM
-unsafe impl Send for CachedFetcher {}
-
-impl CachedFetcher {
+//#[cfg(not(feature = "server"))]
+impl Fetcher {
     pub fn new(client: OAuthClient<JacquardResolver, AuthStore>) -> Self {
         Self {
             client: Arc::new(Client::new(client)),
-            book_cache: cache_impl::new_cache(100, Duration::from_secs(1200)),
-            entry_cache: cache_impl::new_cache(100, Duration::from_secs(600)),
-            profile_cache: cache_impl::new_cache(100, Duration::from_secs(1800)),
         }
     }
 
···
         ident: AtIdentifier<'static>,
         title: SmolStr,
     ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
-        if let Some(entry) = cache_impl::get(&self.book_cache, &(ident.clone(), title.clone())) {
-            Ok(Some(entry))
+        let client = self.get_client();
+        if let Some((notebook, entries)) = client
+            .notebook_by_title(&ident, &title)
+            .await
+            .map_err(|e| dioxus::CapturedError::from_display(e))?
+        {
+            let stored = Arc::new((notebook, entries));
+            Ok(Some(stored))
         } else {
-            let client = self.get_client();
-            if let Some((notebook, entries)) = client
-                .notebook_by_title(&ident, &title)
-                .await
-                .map_err(|e| dioxus::CapturedError::from_display(e))?
-            {
-                let stored = Arc::new((notebook, entries));
-                cache_impl::insert(&self.book_cache, (ident, title), stored.clone());
-                Ok(Some(stored))
-            } else {
-                Ok(None)
-            }
+            Ok(None)
         }
     }
 
···
     ) -> Result<Option<Arc<(BookEntryView<'static>, Entry<'static>)>>> {
         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
             let (notebook, entries) = result.as_ref();
-            if let Some(entry) =
-                cache_impl::get(&self.entry_cache, &(ident.clone(), entry_title.clone()))
+            let client = self.get_client();
+            if let Some(entry) = client
+                .entry_by_title(notebook, entries.as_ref(), &entry_title)
+                .await
+                .map_err(|e| dioxus::CapturedError::from_display(e))?
             {
-                Ok(Some(entry))
+                let stored = Arc::new(entry);
+                Ok(Some(stored))
             } else {
-                let client = self.get_client();
-                if let Some(entry) = client
-                    .entry_by_title(notebook, entries.as_ref(), &entry_title)
-                    .await
-                    .map_err(|e| dioxus::CapturedError::from_display(e))?
-                {
-                    let stored = Arc::new(entry);
-                    cache_impl::insert(&self.entry_cache, (ident, entry_title), stored.clone());
-                    Ok(Some(stored))
-                } else {
-                    Ok(None)
-                }
+                Ok(None)
             }
         } else {
             Ok(None)
···
                         .unwrap_or_else(|| SmolStr::new("Untitled"));
 
                     let result = Arc::new((notebook, entries));
-                    // Cache it
-                    cache_impl::insert(&self.book_cache, (ident, title), result.clone());
                     notebooks.push(result);
                 }
                 Err(_) => continue, // Skip notebooks that fail to load
···
                             .unwrap_or_else(|| SmolStr::new("Untitled"));
 
                         let result = Arc::new((notebook, entries));
-                        // Cache it
-                        cache_impl::insert(&self.book_cache, (ident, title), result.clone());
                         notebooks.push(result);
                     }
                     Err(_) => continue, // Skip notebooks that fail to load
···
         &self,
         ident: &AtIdentifier<'_>,
     ) -> Result<Arc<ProfileDataView<'static>>> {
-        use jacquard::IntoStatic;
-
-        let ident_static = ident.clone().into_static();
-
-        if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
-            return Ok(cached);
-        }
-
         let client = self.get_client();
 
         let did = match ident {
···
             .map_err(|e| dioxus::CapturedError::from_display(e))?;
 
         let result = Arc::new(profile_view);
-        cache_impl::insert(&self.profile_cache, ident_static, result.clone());
 
         Ok(result)
     }
 }
 
-impl HttpClient for CachedFetcher {
+// //#[cfg(feature = "server")]
+// #[derive(Clone)]
+// pub struct Fetcher {
+//     pub client: Arc<Client>,
+//     book_cache: cache_impl::Cache<
+//         (AtIdentifier<'static>, SmolStr),
+//         Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
+//     >,
+//     entry_cache: cache_impl::Cache<
+//         (AtIdentifier<'static>, SmolStr),
+//         Arc<(BookEntryView<'static>, Entry<'static>)>,
+//     >,
+//     profile_cache: cache_impl::Cache<AtIdentifier<'static>, Arc<ProfileDataView<'static>>>,
+// }
+
+// // /// SAFETY: This isn't thread-safe on WASM, but we aren't multithreaded on WASM
+// //#[cfg(feature = "server")]
+// unsafe impl Sync for Fetcher {}
+
+// // /// SAFETY: This isn't thread-safe on WASM, but we aren't multithreaded on WASM
+// //#[cfg(feature = "server")]
+// unsafe impl Send for Fetcher {}
+
+// //#[cfg(feature = "server")]
+// impl Fetcher {
+//     pub fn new(client: OAuthClient<JacquardResolver, AuthStore>) -> Self {
+//         Self {
+//             client: Arc::new(Client::new(client)),
+//             book_cache: cache_impl::new_cache(100, Duration::from_secs(30)),
+//             entry_cache: cache_impl::new_cache(100, Duration::from_secs(30)),
+//             profile_cache: cache_impl::new_cache(100, Duration::from_secs(1800)),
+//         }
+//     }
+
+//     pub async fn upgrade_to_authenticated(
+//         &self,
+//         session: OAuthSession<JacquardResolver, crate::auth::AuthStore>,
+//     ) {
+//         let mut session_slot = self.client.session.write().await;
+//         *session_slot = Some(Arc::new(Agent::new(session)));
+//     }
+
+//     pub async fn downgrade_to_unauthenticated(&self) {
+//         let mut session_slot = self.client.session.write().await;
+//         if let Some(session) = session_slot.take() {
+//             session.inner().logout().await.ok();
+//         }
+//     }
+
+//     #[allow(dead_code)]
+//     pub async fn current_did(&self) -> Option<Did<'static>> {
+//         let session_slot = self.client.session.read().await;
+//         if let Some(session) = session_slot.as_ref() {
+//             session.info().await.map(|(d, _)| d)
+//         } else {
+//             None
+//         }
+//     }
+
+//     pub fn get_client(&self) -> Arc<Client> {
+//         self.client.clone()
+//     }
+
+//     pub async fn get_notebook(
+//         &self,
+//         ident: AtIdentifier<'static>,
+//         title: SmolStr,
+//     ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+//         if let Some(entry) = cache_impl::get(&self.book_cache, &(ident.clone(), title.clone())) {
+//             Ok(Some(entry))
+//         } else {
+//             let client = self.get_client();
+//             if let Some((notebook, entries)) = client
+//                 .notebook_by_title(&ident, &title)
+//                 .await
+//                 .map_err(|e| dioxus::CapturedError::from_display(e))?
+//             {
+//                 let stored = Arc::new((notebook, entries));
+//                 cache_impl::insert(&self.book_cache, (ident, title), stored.clone());
+//                 Ok(Some(stored))
+//             } else {
+//                 Ok(None)
+//             }
+//         }
+//     }
+
+//     pub async fn get_entry(
+//         &self,
+//         ident: AtIdentifier<'static>,
+//         book_title: SmolStr,
+//         entry_title: SmolStr,
+//     ) -> Result<Option<Arc<(BookEntryView<'static>, Entry<'static>)>>> {
+//         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
+//             let (notebook, entries) = result.as_ref();
+//             if let Some(entry) =
+//                 cache_impl::get(&self.entry_cache, &(ident.clone(), entry_title.clone()))
+//             {
+//                 Ok(Some(entry))
+//             } else {
+//                 let client = self.get_client();
+//                 if let Some(entry) = client
+//                     .entry_by_title(notebook, entries.as_ref(), &entry_title)
+//                     .await
+//                     .map_err(|e| dioxus::CapturedError::from_display(e))?
+//                 {
+//                     let stored = Arc::new(entry);
+//                     cache_impl::insert(&self.entry_cache, (ident, entry_title), stored.clone());
+//                     Ok(Some(stored))
+//                 } else {
+//                     Ok(None)
+//                 }
+//             }
+//         } else {
+//             Ok(None)
+//         }
+//     }
+
+//     pub async fn fetch_notebooks_from_ufos(
+//         &self,
+//     ) -> Result<Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+//         use jacquard::{IntoStatic, types::aturi::AtUri};
+
+//         let url = "https://ufos-api.microcosm.blue/records?collection=sh.weaver.notebook.book";
+//         let response = reqwest::get(url)
+//             .await
+//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
+
+//         let records: Vec<UfosRecord> = response
+//             .json()
+//             .await
+//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
+
+//         let mut notebooks = Vec::new();
+//         let client = self.get_client();
+
+//         for ufos_record in records {
+//             // Construct URI
+//             let uri_str = format!(
+//                 "at://{}/{}/{}",
+//                 ufos_record.did, ufos_record.collection, ufos_record.rkey
+//             );
+//             let uri = AtUri::new_owned(uri_str)
+//                 .map_err(|e| dioxus::CapturedError::from_display(format!("Invalid URI: {}", e)))?;
+
+//             // Fetch the full notebook view (which hydrates authors)
+//             match client.view_notebook(&uri).await {
+//                 Ok((notebook, entries)) => {
+//                     let ident = uri.authority().clone().into_static();
+//                     let title = notebook
+//                         .title
+//                         .as_ref()
+//                         .map(|t| SmolStr::new(t.as_ref()))
+//                         .unwrap_or_else(|| SmolStr::new("Untitled"));
+
+//                     let result = Arc::new((notebook, entries));
+//                     // Cache it
+//                     cache_impl::insert(&self.book_cache, (ident, title), result.clone());
+//                     notebooks.push(result);
+//                 }
+//                 Err(_) => continue, // Skip notebooks that fail to load
+//             }
+//         }
+
+//         Ok(notebooks)
+//     }
+
+//     pub async fn fetch_notebooks_for_did(
+//         &self,
+//         ident: &AtIdentifier<'_>,
+//     ) -> Result<Vec<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+//         use jacquard::{
+//             IntoStatic,
+//             types::{collection::Collection, nsid::Nsid},
+//             xrpc::XrpcExt,
+//         };
+//         use weaver_api::{
+//             com_atproto::repo::list_records::ListRecords, sh_weaver::notebook::book::Book,
+//         };
+
+//         let client = self.get_client();
+
+//         // Resolve DID and PDS
+//         let (repo_did, pds_url) = match ident {
+//             AtIdentifier::Did(did) => {
+//                 let pds = client
+//                     .pds_for_did(did)
+//                     .await
+//                     .map_err(|e| dioxus::CapturedError::from_display(e))?;
+//                 (did.clone(), pds)
+//             }
+//             AtIdentifier::Handle(handle) => client
+//                 .pds_for_handle(handle)
+//                 .await
+//                 .map_err(|e| dioxus::CapturedError::from_display(e))?,
+//         };
+
+//         // Fetch all notebook records for this repo
+//         let resp = client
+//             .xrpc(pds_url)
+//             .send(
+//                 &ListRecords::new()
+//                     .repo(repo_did)
+//                     .collection(Nsid::raw(Book::NSID))
+//                     .limit(100)
+//                     .build(),
+//             )
+//             .await
+//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
+
+//         let mut notebooks = Vec::new();
+
+//         if let Ok(list) = resp.parse() {
+//             for record in list.records {
+//                 // View the notebook (which hydrates authors)
+//                 match client.view_notebook(&record.uri).await {
+//                     Ok((notebook, entries)) => {
+//                         let ident = record.uri.authority().clone().into_static();
+//                         let title = notebook
+//                             .title
+//                             .as_ref()
+//                             .map(|t| SmolStr::new(t.as_ref()))
+//                             .unwrap_or_else(|| SmolStr::new("Untitled"));
+
+//                         let result = Arc::new((notebook, entries));
+//                         // Cache it
+//                         cache_impl::insert(&self.book_cache, (ident, title), result.clone());
+//                         notebooks.push(result);
+//                     }
+//                     Err(_) => continue, // Skip notebooks that fail to load
+//                 }
+//             }
+//         }
+
+//         Ok(notebooks)
+//     }
+
+//     pub async fn list_notebook_entries(
+//         &self,
+//         ident: AtIdentifier<'static>,
+//         book_title: SmolStr,
+//     ) -> Result<Option<Vec<BookEntryView<'static>>>> {
+//         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
+//             let (notebook, entries) = result.as_ref();
+//             let mut book_entries = Vec::new();
+//             let client = self.get_client();
+
+//             for index in 0..entries.len() {
+//                 match client.view_entry(notebook, entries, index).await {
+//                     Ok(book_entry) => book_entries.push(book_entry),
+//                     Err(_) => continue, // Skip entries that fail to load
+//                 }
+//             }
+
+//             Ok(Some(book_entries))
+//         } else {
+//             Ok(None)
+//         }
+//     }
+
+//     pub async fn fetch_profile(
+//         &self,
+//         ident: &AtIdentifier<'_>,
+//     ) -> Result<Arc<ProfileDataView<'static>>> {
+//         use jacquard::IntoStatic;
+
+//         let ident_static = ident.clone().into_static();
+
+//         if let Some(cached) = cache_impl::get(&self.profile_cache, &ident_static) {
+//             return Ok(cached);
+//         }
+
+//         let client = self.get_client();
+
+//         let did = match ident {
+//             AtIdentifier::Did(d) => d.clone(),
+//             AtIdentifier::Handle(h) => client
+//                 .resolve_handle(h)
+//                 .await
+//                 .map_err(|e| dioxus::CapturedError::from_display(e))?,
+//         };
+
+//         let (_uri, profile_view) = client
+//             .hydrate_profile_view(&did)
+//             .await
+//             .map_err(|e| dioxus::CapturedError::from_display(e))?;
+
+//         let result = Arc::new(profile_view);
+//         cache_impl::insert(&self.profile_cache, ident_static, result.clone());
+
+//         Ok(result)
+//     }
+// }
+
+impl HttpClient for Fetcher {
     #[doc = " Error type returned by the HTTP client"]
     type Error = reqwest::Error;
 
···
     }
 }
 
-impl XrpcClient for CachedFetcher {
+impl XrpcClient for Fetcher {
     #[doc = " Get the base URI for the client."]
     fn base_uri(&self) -> impl Future<Output = CowStr<'static>> + Send {
         self.client.base_uri()
···
     }
 }
 
-impl IdentityResolver for CachedFetcher {
+impl IdentityResolver for Fetcher {
     #[doc = " Access options for validation decisions in default methods"]
     fn options(&self) -> &ResolverOptions {
         self.client.options()
···
     }
 }
 
-impl LexiconSchemaResolver for CachedFetcher {
+impl LexiconSchemaResolver for Fetcher {
     #[cfg(not(target_arch = "wasm32"))]
     async fn resolve_lexicon_schema(
         &self,
···
     }
 }
 
-impl AgentSession for CachedFetcher {
+impl AgentSession for Fetcher {
     #[doc = " Identify the kind of session."]
     fn session_kind(&self) -> AgentKind {
         self.client.session_kind()

crates/weaver-app/src/main.rs

···
 // The dioxus prelude contains a ton of common items used in dioxus apps. It's a good idea to import wherever you
 // need dioxus
-use components::{Entry, Repository, RepositoryIndex};
+use components::{EntryPage, Repository, RepositoryIndex};
 #[allow(unused)]
 use dioxus::{CapturedError, prelude::*};
 
···
     smol_str::SmolStr,
     types::{cid::Cid, string::AtIdentifier},
 };
-#[cfg(feature = "server")]
-use std::sync::Arc;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 #[allow(unused)]
 use views::{
-    Callback, Home, Navbar, Notebook, NotebookIndex, NotebookPage, RecordIndex, RecordView,
+    Callback, Home, Navbar, Notebook, NotebookIndex, NotebookPage, RecordIndex, RecordPage,
 };
 
 use crate::{
···
 mod data;
 mod env;
 mod fetch;
+mod record_utils;
 mod service_worker;
 /// Define a views module that contains the UI for all Layouts and Routes for our app.
 mod views;
···
         #[nest("/record")]
           #[layout(RecordIndex)]
             #[route("/:..uri")]
-            RecordView { uri: Vec<String> },
+            RecordPage { uri: Vec<String> },
                      #[end_layout]
         #[end_nest]
         #[route("/callback?:state&:iss&:code")]
···
               #[route("/")]
               NotebookIndex { ident: AtIdentifier<'static>, book_title: SmolStr },
                 #[route("/:title")]
-                Entry { ident: AtIdentifier<'static>, book_title: SmolStr, title: SmolStr }
+                EntryPage { ident: AtIdentifier<'static>, book_title: SmolStr, title: SmolStr }
 
 }
 const FAVICON: Asset = asset!("/assets/weaver_photo_sm.jpg");
···
         #[cfg(feature = "fullstack-server")]
         let router = {
             use jacquard::client::UnauthenticatedSession;
-            let fetcher = Arc::new(fetch::CachedFetcher::new(OAuthClient::new(
+            let fetcher = Arc::new(fetch::Fetcher::new(OAuthClient::new(
                 AuthStore::new(),
                 ClientData::new_public(CONFIG.oauth.clone()),
             )));
···
             axum::Router::new()
                 // Server side render the application, serve static assets, and register server functions
                 .serve_dioxus_application(
-                    ServeConfig::builder()
-                        // Enable incremental rendering
-                        .incremental(
-                            dioxus::server::IncrementalRendererConfig::new()
-                                .pre_render(true)
-                                .clear_cache(false),
-                        )
-                        .enable_out_of_order_streaming(),
+                    ServeConfig::builder(), // Enable incremental rendering
+                    // .incremental(
+                    //     dioxus::server::IncrementalRendererConfig::new()
+                    //         .pre_render(true)
+                    //         .clear_cache(false),
+                    // )
+                    //.enable_out_of_order_streaming(),
                     App,
                 )
                 .layer(middleware::from_fn({
···
 
 #[component]
 fn App() -> Element {
-    use_context_provider(|| {
-        fetch::CachedFetcher::new(OAuthClient::new(
+    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 fetcher = fetcher.clone();
         spawn(async move {
-            if let Err(e) = auth::restore_session().await {
-                tracing::warn!("Session restoration failed: {}", e);
+            if let Err(e) = auth::restore_session(fetcher).await {
+                tracing::debug!("Session restoration failed: {}", e);
             }
         });
     });
···
         target_os = "unknown",
         not(feature = "fullstack-server")
     ))]
-    use_effect(move || {
-        spawn(async move {
-            let _ = service_worker::register_service_worker().await;
-        });
+    spawn(async move {
+        let _ = service_worker::register_service_worker().await;
     });
 
     rsx! {

crates/weaver-app/src/record_utils.rs

···
+use dioxus::prelude::*;
+use jacquard::bytes::Bytes;
+use jacquard::common::{Data, IntoStatic};
+use jacquard::types::LexiconStringType;
+use jacquard::types::string::AtprotoStr;
+use jacquard_lexicon::validation::{
+    ConstraintError, StructuralError, ValidationError, ValidationResult,
+};
+
+// ============================================================================
+// Validation Helper Functions
+// ============================================================================
+
+/// Parse UI path into segments (fields and indices only)
+fn parse_ui_path(ui_path: &str) -> Vec<UiPathSegment> {
+    if ui_path.is_empty() {
+        return vec![];
+    }
+
+    let mut segments = Vec::new();
+    let mut current = String::new();
+
+    for ch in ui_path.chars() {
+        match ch {
+            '.' => {
+                if !current.is_empty() {
+                    segments.push(UiPathSegment::Field(current.clone()));
+                    current.clear();
+                }
+            }
+            '[' => {
+                if !current.is_empty() {
+                    segments.push(UiPathSegment::Field(current.clone()));
+                    current.clear();
+                }
+            }
+            ']' => {
+                if !current.is_empty() {
+                    if let Ok(idx) = current.parse::<usize>() {
+                        segments.push(UiPathSegment::Index(idx));
+                    }
+                    current.clear();
+                }
+            }
+            c => current.push(c),
+        }
+    }
+
+    if !current.is_empty() {
+        segments.push(UiPathSegment::Field(current));
+    }
+
+    segments
+}
+
+#[derive(Debug, PartialEq)]
+enum UiPathSegment {
+    Field(String),
+    Index(usize),
+}
+
+/// Get all validation errors at exactly this path (not children)
+pub fn get_errors_at_exact_path(
+    validation_result: &Option<ValidationResult>,
+    ui_path: &str,
+) -> Vec<String> {
+    use jacquard_lexicon::validation::PathSegment;
+
+    if let Some(result) = validation_result {
+        let ui_segments = parse_ui_path(ui_path);
+
+        result
+            .all_errors()
+            .filter_map(|err| {
+                let validation_path = match &err {
+                    ValidationError::Structural(s) => match s {
+                        StructuralError::TypeMismatch { path, .. } => Some(path),
+                        StructuralError::MissingRequiredField { path, .. } => Some(path),
+                        StructuralError::MissingUnionDiscriminator { path } => Some(path),
+                        StructuralError::UnionNoMatch { path, .. } => Some(path),
+                        StructuralError::UnresolvedRef { path, .. } => Some(path),
+                        StructuralError::RefCycle { path, .. } => Some(path),
+                        StructuralError::MaxDepthExceeded { path, .. } => Some(path),
+                    },
+                    ValidationError::Constraint(c) => match c {
+                        ConstraintError::MaxLength { path, .. } => Some(path),
+                        ConstraintError::MaxGraphemes { path, .. } => Some(path),
+                        ConstraintError::MinLength { path, .. } => Some(path),
+                        ConstraintError::MinGraphemes { path, .. } => Some(path),
+                        ConstraintError::Maximum { path, .. } => Some(path),
+                        ConstraintError::Minimum { path, .. } => Some(path),
+                    },
+                };
+
+                if let Some(path) = validation_path {
+                    // Convert validation path to UI segments
+                    let validation_ui_segments: Vec<_> = path
+                        .segments()
+                        .iter()
+                        .filter_map(|seg| match seg {
+                            PathSegment::Field(name) => {
+                                Some(UiPathSegment::Field(name.to_string()))
+                            }
+                            PathSegment::Index(idx) => Some(UiPathSegment::Index(*idx)),
+                            PathSegment::UnionVariant(_) => None,
+                        })
+                        .collect();
+
+                    // Exact match only
+                    if validation_ui_segments == ui_segments {
+                        return Some(err.to_string());
+                    }
+                }
+                None
+            })
+            .collect()
+    } else {
+        Vec::new()
+    }
+}
+
+// ============================================================================
+// Pretty Editor: Helper Functions
+// ============================================================================
+
+/// Infer Data type from text input
+pub fn infer_data_from_text(text: &str) -> Result<Data<'static>, String> {
+    let trimmed = text.trim();
+
+    if trimmed == "true" || trimmed == "false" {
+        Ok(Data::Boolean(trimmed == "true"))
+    } else if trimmed == "{}" {
+        use jacquard::types::value::Object;
+        use std::collections::BTreeMap;
+        Ok(Data::Object(Object(BTreeMap::new())))
+    } else if trimmed == "[]" {
+        use jacquard::types::value::Array;
+        Ok(Data::Array(Array(Vec::new())))
+    } else if trimmed == "null" {
+        Ok(Data::Null)
+    } else if let Ok(num) = trimmed.parse::<i64>() {
+        Ok(Data::Integer(num))
+    } else {
+        // Smart string parsing
+        use jacquard::types::value::parsing;
+        Ok(Data::String(parsing::parse_string(trimmed).into_static()))
+    }
+}
+
+/// Parse text as specific AtprotoStr type, preserving type information
+pub fn try_parse_as_type(
+    text: &str,
+    string_type: LexiconStringType,
+) -> Result<AtprotoStr<'static>, String> {
+    use jacquard::types::string::*;
+    use std::str::FromStr;
+
+    match string_type {
+        LexiconStringType::Datetime => Datetime::from_str(text)
+            .map(AtprotoStr::Datetime)
+            .map_err(|e| format!("Invalid datetime: {}", e)),
+        LexiconStringType::Did => Did::new(text)
+            .map(|v| AtprotoStr::Did(v.into_static()))
+            .map_err(|e| format!("Invalid DID: {}", e)),
+        LexiconStringType::Handle => Handle::new(text)
+            .map(|v| AtprotoStr::Handle(v.into_static()))
+            .map_err(|e| format!("Invalid handle: {}", e)),
+        LexiconStringType::AtUri => AtUri::new(text)
+            .map(|v| AtprotoStr::AtUri(v.into_static()))
+            .map_err(|e| format!("Invalid AT-URI: {}", e)),
+        LexiconStringType::AtIdentifier => AtIdentifier::new(text)
+            .map(|v| AtprotoStr::AtIdentifier(v.into_static()))
+            .map_err(|e| format!("Invalid identifier: {}", e)),
+        LexiconStringType::Nsid => Nsid::new(text)
+            .map(|v| AtprotoStr::Nsid(v.into_static()))
+            .map_err(|e| format!("Invalid NSID: {}", e)),
+        LexiconStringType::Tid => Tid::new(text)
+            .map(|v| AtprotoStr::Tid(v.into_static()))
+            .map_err(|e| format!("Invalid TID: {}", e)),
+        LexiconStringType::RecordKey => Rkey::new(text)
+            .map(|rk| AtprotoStr::RecordKey(RecordKey::from(rk)))
+            .map_err(|e| format!("Invalid record key: {}", e)),
+        LexiconStringType::Cid => Cid::new(text.as_bytes())
+            .map(|v| AtprotoStr::Cid(v.into_static()))
+            .map_err(|_| "Invalid CID".to_string()),
+        LexiconStringType::Language => Language::new(text)
+            .map(AtprotoStr::Language)
+            .map_err(|e| format!("Invalid language: {}", e)),
+        LexiconStringType::Uri(_) => Uri::new(text)
+            .map(|u| AtprotoStr::Uri(u.into_static()))
+            .map_err(|e| format!("Invalid URI: {}", e)),
+        LexiconStringType::String => {
+            // Plain strings: use smart inference
+            use jacquard::types::value::parsing;
+            Ok(parsing::parse_string(text).into_static())
+        }
+    }
+}
+
+/// Create default value for new array item by cloning structure of existing items
+pub fn create_array_item_default(arr: &jacquard::types::value::Array) -> Data<'static> {
+    if let Some(existing) = arr.0.first() {
+        clone_structure(existing)
+    } else {
+        // Empty array, default to null (user can change type)
+        Data::Null
+    }
+}
+
+/// Clone structure of Data, setting sensible defaults for leaf values
+pub fn clone_structure(data: &Data) -> Data<'static> {
+    use jacquard::types::string::*;
+    use jacquard::types::value::{Array, Object};
+    use jacquard::types::{LexiconStringType, blob::*};
+    use std::collections::BTreeMap;
+
+    match data {
+        Data::Object(obj) => {
+            let mut new_obj = BTreeMap::new();
+            for (key, value) in obj.0.iter() {
+                new_obj.insert(key.clone(), clone_structure(value));
+            }
+            Data::Object(Object(new_obj))
+        }
+        Data::Array(_) => Data::Array(Array(Vec::new())),
+        Data::String(s) => match s.string_type() {
+            LexiconStringType::Datetime => {
+                // Sensible default: now
+                Data::String(AtprotoStr::Datetime(Datetime::now()))
+            }
+            LexiconStringType::Tid => Data::String(AtprotoStr::Tid(Tid::now_0())),
+            _ => {
+                // Empty string, type inference will handle it
+                Data::String(AtprotoStr::String("".into()))
+            }
+        },
+        Data::Integer(_) => Data::Integer(0),
+        Data::Boolean(_) => Data::Boolean(false),
+        Data::Blob(blob) => {
+            // Placeholder blob
+            Data::Blob(
+                Blob {
+                    r#ref: CidLink::str(
+                        "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                    ),
+                    mime_type: blob.mime_type.clone(),
+                    size: 0,
+                }
+                .into_static(),
+            )
+        }
+        Data::CidLink(_) => Data::CidLink(Cid::str(
+            "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        )),
+        Data::Bytes(_) => Data::Bytes(Bytes::new()),
+        Data::Null => Data::Null,
+    }
+}
+
+/// Get expected string format from schema by navigating path
+pub fn get_expected_string_format(
+    root_data: &Data<'_>,
+    current_path: &str,
+) -> Option<jacquard_lexicon::lexicon::LexStringFormat> {
+    use jacquard_lexicon::lexicon::*;
+
+    // Get root type discriminator
+    let root_nsid = root_data.type_discriminator()?;
+
+    // Look up schema in global registry
+    let validator = jacquard_lexicon::validation::SchemaValidator::global();
+    let registry = validator.registry();
+    let schema = registry.get(root_nsid)?;
+
+    // Navigate to the property at this path
+    let segments: Vec<&str> = if current_path.is_empty() {
+        vec![]
+    } else {
+        current_path.split('.').collect()
+    };
+
+    // Start with the record's main object definition
+    let main_obj = match schema.defs.get("main")? {
+        LexUserType::Record(rec) => match &rec.record {
+            LexRecordRecord::Object(obj) => obj,
+        },
+        _ => return None,
+    };
+
+    // Track current position in schema
+    enum SchemaType<'a> {
+        ObjectProp(&'a LexObjectProperty<'a>),
+        ArrayItem(&'a LexArrayItem<'a>),
+    }
+
+    let mut current_type: Option<SchemaType> = None;
+    let mut current_obj = Some(main_obj);
+
+    for segment in segments {
+        // Handle array indices - strip them to get field name
+        let field_name = segment.trim_end_matches(|c: char| c.is_numeric() || c == '[' || c == ']');
+
+        if field_name.is_empty() {
+            continue; // Pure array index like [0], skip
+        }
+
+        if let Some(obj) = current_obj.take() {
+            if let Some(prop) = obj.properties.get(field_name) {
+                current_type = Some(SchemaType::ObjectProp(prop));
+            }
+        }
+
+        // Process current type
+        match current_type {
+            Some(SchemaType::ObjectProp(LexObjectProperty::Array(arr))) => {
+                // Array - unwrap to item type
+                current_type = Some(SchemaType::ArrayItem(&arr.items));
+            }
+            Some(SchemaType::ObjectProp(LexObjectProperty::Object(obj))) => {
+                // Nested object - descend into it
+                current_obj = Some(obj);
+                current_type = None;
+            }
+            Some(SchemaType::ArrayItem(LexArrayItem::Object(obj))) => {
+                // Array of objects - descend into object
+                current_obj = Some(obj);
+                current_type = None;
+            }
+            _ => {}
+        }
+    }
+
+    // Check if final type is a string with format
+    match current_type? {
+        SchemaType::ObjectProp(LexObjectProperty::String(lex_string)) => lex_string.format,
+        SchemaType::ArrayItem(LexArrayItem::String(lex_string)) => lex_string.format,
+        _ => None,
+    }
+}
+
+pub fn get_hex_rep(byte_array: &mut [u8]) -> String {
+    let build_string_vec: Vec<String> = byte_array
+        .chunks(2)
+        .enumerate()
+        .map(|(i, c)| {
+            let sep = if i % 16 == 0 && i > 0 {
+                "\n"
+            } else if i == 0 {
+                ""
+            } else {
+                " "
+            };
+            if c.len() == 2 {
+                format!("{}{:02x}{:02x}", sep, c[0], c[1])
+            } else {
+                format!("{}{:02x}", sep, c[0])
+            }
+        })
+        .collect();
+    build_string_vec.join("")
+}

crates/weaver-app/src/service_worker.rs

···
     ident: &jacquard::types::ident::AtIdentifier<'_>,
     book_title: &str,
     images: &weaver_api::sh_weaver::embed::images::Images<'_>,
-    fetcher: &crate::fetch::CachedFetcher,
+    fetcher: &crate::fetch::Fetcher,
 ) -> Result<(), JsValue> {
     use jacquard::prelude::IdentityResolver;
     use std::collections::HashMap;

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

···
 use crate::auth::AuthState;
-use crate::fetch::CachedFetcher;
+use crate::fetch::Fetcher;
 use dioxus::prelude::*;
 use jacquard::{
     IntoStatic,
···
     iss: ReadSignal<SmolStr>,
     code: ReadSignal<SmolStr>,
 ) -> Element {
-    let fetcher = use_context::<CachedFetcher>();
+    let fetcher = use_context::<Fetcher>();
     let mut auth = use_context::<Signal<AuthState>>();
     #[cfg(feature = "web")]
     let result = {
···
     };
     #[cfg(not(feature = "web"))]
     let result = { use_resource(move || async { Ok::<(), OAuthError>(()) }) };
+    #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+    let nav = use_navigator();
 
     match &*result.read_unchecked() {
         Some(Ok(())) => {
···
                 let mut prev = gloo_storage::LocalStorage::get::<String>("cached_route").ok();
                 if let Some(prev) = prev.take() {
                     tracing::info!("Navigating to previous page");
-                    let nav = use_navigator();
+
                     gloo_storage::LocalStorage::delete("cached_route");
                     nav.replace(prev);
                 }

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().ok();
+    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::RecordView {
+                navigator.push(Route::RecordPage {
                     uri: vec![parsed.to_string()],
                 });
             }
···
                 }
             }
             div { class: "notebooks-list",
-                if let Some(notebooks_memo) = &notebooks {
-                    match &*notebooks_memo.read_unchecked() {
-                        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()
-                                            }
+                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..." }
                         }
+                    },
+                    _ => rsx! {
+                        div { "Loading notebooks..." }
                     }
-                } else {
-                    div { "Loading notebooks..." }
                 }
             }
         }

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

···
 pub use notebook::{Notebook, NotebookIndex};
 
 mod record;
-pub use record::{RecordIndex, RecordView};
+pub use record::{RecordIndex, RecordPage, RecordView};
 
 mod callback;
 pub use callback::Callback;
+
+mod editor;

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

···
 use crate::Route;
 use crate::components::button::{Button, ButtonVariant};
 use crate::components::login::LoginModal;
-use crate::data::use_handle;
-use crate::fetch::CachedFetcher;
+use crate::data::{get_handle, use_notebook_handle};
+use crate::fetch::Fetcher;
 use dioxus::prelude::*;
-use jacquard::types::string::AtIdentifier;
 
 const THEME_DEFAULTS_CSS: Asset = asset!("/assets/styling/theme-defaults.css");
 const NAVBAR_CSS: Asset = asset!("/assets/styling/navbar.css");
···
     let route = use_route::<Route>();
     let mut auth_state = use_context::<Signal<crate::auth::AuthState>>();
     let mut show_login_modal = use_signal(|| false);
-    let fetcher = use_context::<CachedFetcher>();
+    let fetcher = use_context::<Fetcher>();
+    let route_handle = use_signal(|| 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);
 
     rsx! {
         document::Link { rel: "stylesheet", href: THEME_DEFAULTS_CSS }
···
 
                 // Show repository breadcrumb if we're on a repository page
                 match route {
-                    Route::RepositoryIndex { ident } => rsx! {
-                        span { class: "breadcrumb-separator", " > " }
-                        span { class: "breadcrumb breadcrumb-current", "@{use_handle(ident.clone())?}" }
-                    },
-                    Route::NotebookIndex { ident, book_title } => rsx! {
-                        span { class: "breadcrumb-separator", " > " }
-                        Link {
-                            to: Route::RepositoryIndex { ident: ident.clone() },
-                            class: "breadcrumb",
-                            "@{use_handle(ident.clone())?}"
+                    Route::RepositoryIndex { .. } => {
+                        let handle = notebook_handle.as_ref().unwrap();
+                        rsx! {
+                            span { class: "breadcrumb-separator", " > " }
+                            span { class: "breadcrumb breadcrumb-current", "@{handle}" }
                         }
-                        span { class: "breadcrumb-separator", " > " }
-                        span { class: "breadcrumb breadcrumb-current", "{book_title}" }
                     },
-                    Route::Entry { ident, book_title, .. } => rsx! {
-                        span { class: "breadcrumb-separator", " > " }
-                        Link {
-                            to: Route::RepositoryIndex { ident: ident.clone() },
-                            class: "breadcrumb",
-                            "@{use_handle(ident.clone())?}"
+                    Route::NotebookIndex { ident, book_title } => {
+                        let handle = notebook_handle.as_ref().unwrap();
+                        rsx! {
+                            span { class: "breadcrumb-separator", " > " }
+                            Link {
+                                to: Route::RepositoryIndex { ident: ident.clone() },
+                                class: "breadcrumb",
+                                "@{handle}"
+                            }
+                            span { class: "breadcrumb-separator", " > " }
+                            span { class: "breadcrumb breadcrumb-current", "{book_title}" }
                         }
-                        span { class: "breadcrumb-separator", " > " }
-                        Link {
-                            to: Route::NotebookIndex { ident: ident.clone(), book_title: book_title.clone() },
-                            class: "breadcrumb",
-                            "{book_title}"
+                    },
+                    Route::EntryPage { ident, book_title, .. } => {
+                        let handle = notebook_handle.as_ref().unwrap();
+                        rsx! {
+                            span { class: "breadcrumb-separator", " > " }
+                            Link {
+                                to: Route::RepositoryIndex { ident: ident.clone() },
+                                class: "breadcrumb",
+                                "@{handle}"
+                            }
+                            span { class: "breadcrumb-separator", " > " }
+                            Link {
+                                to: Route::NotebookIndex { ident: ident.clone(), book_title: book_title.clone() },
+                                class: "breadcrumb",
+                                "{book_title}"
+                            }
                         }
                     },
                     _ => rsx! {}
···
                                 fetcher.downgrade_to_unauthenticated().await;
                             }
                         },
-                        span { class: "auth-handle", "@{use_handle(AtIdentifier::Did(did.clone()))?}" }
+                        span { class: "auth-handle", "@{get_handle(did.clone())}" }
                     }
                 }
+
             } else {
                 div {
                     class: "auth-button",
···
             }
         }
 
-        // The `Outlet` component is used to render the next component inside the layout. In this case, it will render either
-        // the [`Home`] or [`Blog`] component depending on the current route.
         Outlet::<Route> {}
     }
 }

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

···
     book_title: ReadSignal<SmolStr>,
 ) -> Element {
     // Fetch full notebook metadata with SSR support
-    let notebook_data = data::use_notebook(ident(), book_title()).ok();
+    let notebook_data = data::use_notebook(ident(), book_title())?;
 
     // Fetch entries with SSR support
-    let entries_resource = data::use_notebook_entries(ident(), book_title()).ok();
+    let entries_resource = data::use_notebook_entries(ident(), book_title())?;
 
     rsx! {
         document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
 
-        if let (Some(notebook_memo), Some(entries_memo)) = (&notebook_data, &entries_resource) {
-            match (&*notebook_memo.read_unchecked(), &*entries_memo.read_unchecked()) {
-                (Some(data), Some(entries)) => {
-                    let (notebook_view, _) = data;
-                    let author_count = notebook_view.authors.len();
+        match (&*notebook_data.read(), &*entries_resource.read()) {
+            (Some(data), Some(entries)) => {
+                let (notebook_view, _) = data;
+                let author_count = notebook_view.authors.len();
 
-                    rsx! {
-                        div { class: "notebook-layout",
-                            aside { class: "notebook-sidebar",
-                                NotebookCover {
-                                    notebook: notebook_view.clone(),
-                                    title: book_title().to_string()
-                                }
+                rsx! {
+                    div { class: "notebook-layout",
+                        aside { class: "notebook-sidebar",
+                            NotebookCover {
+                                notebook: notebook_view.clone(),
+                                title: book_title().to_string()
                             }
+                        }
 
-                            main { class: "notebook-main",
-                                div { class: "entries-list",
-                                    for entry in entries {
-                                        EntryCard {
-                                            entry: entry.clone(),
-                                            book_title: book_title(),
-                                            author_count
-                                        }
+                        main { class: "notebook-main",
+                            div { class: "entries-list",
+                                for entry in entries {
+                                    EntryCard {
+                                        entry: entry.clone(),
+                                        book_title: book_title(),
+                                        author_count
                                     }
                                 }
                             }
                         }
                     }
-                },
-                _ => rsx! { div { class: "loading", "Loading..." } }
-            }
-        } else {
-            div { class: "loading", "Loading..." }
+                }
+            },
+            _ => rsx! { div { class: "loading", "Loading..." } }
         }
     }
 }

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

···
 use crate::Route;
 use crate::auth::AuthState;
-use crate::components::accordion::{Accordion, AccordionContent, AccordionItem, AccordionTrigger};
-use crate::components::dialog::{DialogContent, DialogDescription, DialogRoot, DialogTitle};
-use crate::fetch::CachedFetcher;
-use dioxus::prelude::Event;
-use dioxus::{CapturedError, prelude::*};
-use humansize::format_size;
-use jacquard::api::com_atproto::repo::get_record::GetRecordOutput;
-use jacquard::bytes::Bytes;
-use jacquard::client::AgentError;
+use crate::components::record_editor::EditableRecordContent;
+use crate::components::record_view::{
+    CodeView, PrettyRecordView, RecordViewLayout, SchemaView, ViewMode,
+};
+use crate::fetch::Fetcher;
+use dioxus::prelude::*;
 use jacquard::common::to_data;
 use jacquard::smol_str::ToSmolStr;
-use jacquard::types::LexiconStringType;
-use jacquard::types::string::AtprotoStr;
-use jacquard::{atproto, prelude::*};
 use jacquard::{
     client::AgentSessionExt,
-    common::{Data, IntoStatic},
+    common::IntoStatic,
     identity::lexicon_resolver::LexiconSchemaResolver,
-    types::{aturi::AtUri, cid::Cid, ident::AtIdentifier, string::Nsid},
+    types::{aturi::AtUri, ident::AtIdentifier, string::Nsid},
 };
 use jacquard_lexicon::lexicon::LexiconDoc;
-use jacquard_lexicon::validation::{
-    ConstraintError, StructuralError, ValidationError, ValidationPath, ValidationResult,
-};
-use mime_sniffer::MimeTypeSniffer;
-use weaver_api::com_atproto::repo::{
-    create_record::CreateRecord, delete_record::DeleteRecord, put_record::PutRecord,
-};
-use weaver_renderer::{code_pretty::highlight_code, css::generate_default_css};
-
-#[derive(Clone, Copy, PartialEq)]
-enum ViewMode {
-    Pretty,
-    Json,
-    Schema,
-}
 
 #[component]
 pub fn RecordIndex() -> Element {
···
 }
 
 #[component]
+pub fn RecordPage(uri: ReadSignal<Vec<String>>) -> Element {
+    rsx! {
+        {std::iter::once(rsx! {RecordView {uri}})}
+    }
+}
+
+#[component]
 pub fn RecordView(uri: ReadSignal<Vec<String>>) -> Element {
-    let fetcher = use_context::<CachedFetcher>();
+    let fetcher = use_context::<Fetcher>();
     info!("Uri:{:?}", uri().join("/"));
     let at_uri = AtUri::new_owned(&*uri.read().join("/"));
     if at_uri.is_err() {
···
 
             // Helper to recursively resolve a schema and its refs
             fn resolve_schema_with_refs<'a>(
-                fetcher: &'a CachedFetcher,
+                fetcher: &'a Fetcher,
                 type_str: &'a str,
                 validator: &'a jacquard_lexicon::validation::SchemaValidator,
                 resolved: &'a mut std::collections::HashSet<String>,
···
         rsx! {}
     }
 }
-
-#[component]
-fn PrettyRecordView(
-    record: Data<'static>,
-    uri: AtUri<'static>,
-    schema: ReadSignal<Option<LexiconDoc<'static>>>,
-) -> Element {
-    let did = uri.authority().to_string();
-    let root_data = use_signal(|| record.clone());
-
-    // Validate the record and provide via context - only after schema is loaded
-    let mut validation_result = use_signal(|| None);
-    use_effect(move || {
-        // Wait for schema to be loaded
-        if schema().is_some() {
-            if let Some(nsid_str) = root_data.read().type_discriminator() {
-                let validator = jacquard_lexicon::validation::SchemaValidator::global();
-                let result = validator.validate_by_nsid(nsid_str, &*root_data.read());
-                validation_result.set(Some(result));
-            }
-        }
-    });
-    use_context_provider(|| validation_result);
-
-    rsx! {
-        div {
-            class: "pretty-record",
-            DataView { data: record, root_data, path: String::new(), did }
-        }
-    }
-}
-
-#[component]
-fn SchemaView(schema: ReadSignal<Option<LexiconDoc<'static>>>) -> Element {
-    if let Some(schema_doc) = schema() {
-        // Convert LexiconDoc to Data for display
-        let schema_data = use_memo(move || to_data(&schema_doc).ok().map(|d| d.into_static()));
-
-        if let Some(data) = schema_data() {
-            let root_data = use_signal(|| data.clone());
-            rsx! {
-                div {
-                    class: "pretty-record",
-                    DataView { data: data, root_data, path: String::new(), did: String::new() }
-                }
-            }
-        } else {
-            rsx! {
-                div { class: "schema-error", "Failed to convert schema to displayable format" }
-            }
-        }
-    } else {
-        rsx! {
-            div { class: "schema-loading", "Loading schema..." }
-        }
-    }
-}
-fn get_hex_rep(byte_array: &mut [u8]) -> String {
-    let build_string_vec: Vec<String> = byte_array
-        .chunks(2)
-        .enumerate()
-        .map(|(i, c)| {
-            let sep = if i % 16 == 0 && i > 0 {
-                "\n"
-            } else if i == 0 {
-                ""
-            } else {
-                " "
-            };
-            if c.len() == 2 {
-                format!("{}{:02x}{:02x}", sep, c[0], c[1])
-            } else {
-                format!("{}{:02x}", sep, c[0])
-            }
-        })
-        .collect();
-    build_string_vec.join("")
-}
-
-#[component]
-fn PathLabel(path: String) -> Element {
-    if path.is_empty() {
-        return rsx! {};
-    }
-
-    // Find the last separator
-    let last_sep = path.rfind(|c| c == '.');
-
-    if let Some(idx) = last_sep {
-        let prefix = &path[..idx + 1];
-        let final_segment = &path[idx + 1..];
-        rsx! {
-            span { class: "field-label",
-                span { class: "path-prefix", "{prefix}" }
-                span { class: "path-final", "{final_segment}" }
-            }
-        }
-    } else {
-        rsx! {
-            span { class: "field-label","{path}" }
-        }
-    }
-}
-
-/// Get expected string format from schema by navigating path
-fn get_expected_string_format(
-    root_data: &Data<'_>,
-    current_path: &str,
-) -> Option<jacquard_lexicon::lexicon::LexStringFormat> {
-    use jacquard_lexicon::lexicon::*;
-
-    // Get root type discriminator
-    let root_nsid = root_data.type_discriminator()?;
-
-    // Look up schema in global registry
-    let validator = jacquard_lexicon::validation::SchemaValidator::global();
-    let registry = validator.registry();
-    let schema = registry.get(root_nsid)?;
-
-    // Navigate to the property at this path
-    let segments: Vec<&str> = if current_path.is_empty() {
-        vec![]
-    } else {
-        current_path.split('.').collect()
-    };
-
-    // Start with the record's main object definition
-    let main_obj = match schema.defs.get("main")? {
-        LexUserType::Record(rec) => match &rec.record {
-            LexRecordRecord::Object(obj) => obj,
-        },
-        _ => return None,
-    };
-
-    // Track current position in schema
-    enum SchemaType<'a> {
-        ObjectProp(&'a LexObjectProperty<'a>),
-        ArrayItem(&'a LexArrayItem<'a>),
-    }
-
-    let mut current_type: Option<SchemaType> = None;
-    let mut current_obj = Some(main_obj);
-
-    for segment in segments {
-        // Handle array indices - strip them to get field name
-        let field_name = segment.trim_end_matches(|c: char| c.is_numeric() || c == '[' || c == ']');
-
-        if field_name.is_empty() {
-            continue; // Pure array index like [0], skip
-        }
-
-        if let Some(obj) = current_obj.take() {
-            if let Some(prop) = obj.properties.get(field_name) {
-                current_type = Some(SchemaType::ObjectProp(prop));
-            }
-        }
-
-        // Process current type
-        match current_type {
-            Some(SchemaType::ObjectProp(LexObjectProperty::Array(arr))) => {
-                // Array - unwrap to item type
-                current_type = Some(SchemaType::ArrayItem(&arr.items));
-            }
-            Some(SchemaType::ObjectProp(LexObjectProperty::Object(obj))) => {
-                // Nested object - descend into it
-                current_obj = Some(obj);
-                current_type = None;
-            }
-            Some(SchemaType::ArrayItem(LexArrayItem::Object(obj))) => {
-                // Array of objects - descend into object
-                current_obj = Some(obj);
-                current_type = None;
-            }
-            _ => {}
-        }
-    }
-
-    // Check if final type is a string with format
-    match current_type? {
-        SchemaType::ObjectProp(LexObjectProperty::String(lex_string)) => lex_string.format,
-        SchemaType::ArrayItem(LexArrayItem::String(lex_string)) => lex_string.format,
-        _ => None,
-    }
-}
-
-#[component]
-fn DataView(
-    data: Data<'static>,
-    root_data: ReadSignal<Data<'static>>,
-    path: String,
-    did: String,
-) -> Element {
-    // Try to get validation result from context and get errors exactly at this path
-    let validation_result = try_use_context::<Signal<Option<ValidationResult>>>();
-
-    let errors = if let Some(vr_signal) = validation_result {
-        get_errors_at_exact_path(&*vr_signal.read(), &path)
-    } else {
-        Vec::new()
-    };
-
-    let has_errors = !errors.is_empty();
-
-    match &data {
-        Data::Null => rsx! {
-            div { class: if has_errors { "record-field field-error" } else { "record-field" },
-                PathLabel { path: path.clone() }
-                span { class: "field-value muted", "null" }
-                if has_errors {
-                    for error in &errors {
-                        div { class: "field-error-message", "{error}" }
-                    }
-                }
-            }
-        },
-        Data::Boolean(b) => rsx! {
-            div { class: if has_errors { "record-field field-error" } else { "record-field" },
-                PathLabel { path: path.clone() }
-                span { class: "field-value", "{b}" }
-                if has_errors {
-                    for error in &errors {
-                        div { class: "field-error-message", "{error}" }
-                    }
-                }
-            }
-        },
-        Data::Integer(i) => rsx! {
-            div { class: if has_errors { "record-field field-error" } else { "record-field" },
-                PathLabel { path: path.clone() }
-                span { class: "field-value", "{i}" }
-                if has_errors {
-                    for error in &errors {
-                        div { class: "field-error-message", "{error}" }
-                    }
-                }
-            }
-        },
-        Data::String(s) => {
-            use jacquard::types::string::AtprotoStr;
-            use jacquard_lexicon::lexicon::LexStringFormat;
-
-            // Get expected format from schema
-            let expected_format = get_expected_string_format(&*root_data.read(), &path);
-
-            // Get actual type from data
-            let actual_type_label = match s {
-                AtprotoStr::Datetime(_) => "datetime",
-                AtprotoStr::Language(_) => "language",
-                AtprotoStr::Tid(_) => "tid",
-                AtprotoStr::Nsid(_) => "nsid",
-                AtprotoStr::Did(_) => "did",
-                AtprotoStr::Handle(_) => "handle",
-                AtprotoStr::AtIdentifier(_) => "at-identifier",
-                AtprotoStr::AtUri(_) => "at-uri",
-                AtprotoStr::Uri(_) => "uri",
-                AtprotoStr::Cid(_) => "cid",
-                AtprotoStr::RecordKey(_) => "record-key",
-                AtprotoStr::String(_) => "string",
-            };
-
-            // Prefer schema format if available, otherwise use actual type
-            let type_label = if let Some(fmt) = expected_format {
-                match fmt {
-                    LexStringFormat::Datetime => "datetime",
-                    LexStringFormat::Uri => "uri",
-                    LexStringFormat::AtUri => "at-uri",
-                    LexStringFormat::Did => "did",
-                    LexStringFormat::Handle => "handle",
-                    LexStringFormat::AtIdentifier => "at-identifier",
-                    LexStringFormat::Nsid => "nsid",
-                    LexStringFormat::Cid => "cid",
-                    LexStringFormat::Language => "language",
-                    LexStringFormat::Tid => "tid",
-                    LexStringFormat::RecordKey => "record-key",
-                }
-            } else {
-                actual_type_label
-            };
-
-            rsx! {
-                div { class: if has_errors { "record-field field-error" } else { "record-field" },
-                    PathLabel { path: path.clone() }
-                    span { class: "field-value",
-
-                        HighlightedString { string_type: s.clone() }
-                        if type_label != "string" {
-                            span { class: "string-type-tag", " [{type_label}]" }
-                        }
-                    }
-                    if has_errors {
-                        for error in &errors {
-                            div { class: "field-error-message", "{error}" }
-                        }
-                    }
-                }
-            }
-        }
-        Data::Bytes(b) => {
-            let hex_string = get_hex_rep(&mut b.to_vec());
-            let byte_size = if b.len() > 128 {
-                format_size(b.len(), humansize::BINARY)
-            } else {
-                format!("{} bytes", b.len())
-            };
-            rsx! {
-                div { class: if has_errors { "record-field field-error" } else { "record-field" },
-                    PathLabel { path: path.clone() }
-                    pre { class: "field-value bytes", "{hex_string} [{byte_size}]" }
-                    if has_errors {
-                        for error in &errors {
-                            div { class: "field-error-message", "{error}" }
-                        }
-                    }
-                }
-            }
-        }
-        Data::CidLink(cid) => rsx! {
-            div { class: if has_errors { "record-field field-error" } else { "record-field" },
-                span { class: "field-label", "{path}" }
-                span { class: "field-value", "{cid}" }
-                if has_errors {
-                    for error in &errors {
-                        div { class: "field-error-message", "{error}" }
-                    }
-                }
-            }
-        },
-        Data::Array(arr) => {
-            let label = path.split('.').last().unwrap_or(&path);
-            rsx! {
-                div { class: "record-section",
-                    Accordion {
-                        id: "array-{path}",
-                        collapsible: true,
-                        AccordionItem {
-                            default_open: true,
-                            index: 0,
-                            AccordionTrigger {
-                                div { class: "section-label", "{label}" span { class: "array-len", "[{arr.len()}]" } }
-                            }
-                            AccordionContent {
-                                if has_errors {
-                                    for error in &errors {
-                                        div { class: "field-error-message", "{error}" }
-                                    }
-                                }
-                                div { class: "section-content",
-                                    for (idx, item) in arr.iter().enumerate() {
-                                        {
-                                            let item_path = format!("{}[{}]", label, idx);
-                                            let is_object = matches!(item, Data::Object(_));
-
-                                            if is_object {
-                                                rsx! {
-                                                    div {
-                                                        class: "array-item",
-                                                    div { class: "record-section",
-                                                        div { class: "section-label", "{item_path}" }
-                                                        div { class: "section-content",
-                                                            DataView {
-                                                                data: item.clone(),
-                                                                root_data,
-                                                                path: item_path.clone(),
-                                                                did: did.clone()
-                                                            }
-                                                        }
-                                                    }
-                                                    }
-                                                }
-                                            } else {
-                                                rsx! {
-                                                    div {
-                                                        class: "array-item",
-                                                    DataView {
-                                                        data: item.clone(),
-                                                        root_data,
-                                                        path: item_path,
-                                                        did: did.clone()
-                                                    }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        Data::Object(obj) => {
-            let is_root = path.is_empty();
-            let is_array_item = path.split('.').last().unwrap_or(&path).contains('[');
-
-            if is_root || is_array_item {
-                // Root object or array item: just render children (array items already wrapped)
-                rsx! {
-                    div { class: if !is_root { "record-section" } else {""},
-                        if has_errors {
-                            for error in &errors {
-                                div { class: "field-error-message", "{error}" }
-                            }
-                        }
-                        for (key, value) in obj.iter() {
-                            {
-                                let new_path = if is_root {
-                                    key.to_string()
-                                } else {
-                                    format!("{}.{}", path, key)
-                                };
-                                let did_clone = did.clone();
-                                rsx! {
-                                    DataView { data: value.clone(), root_data, path: new_path, did: did_clone }
-                                }
-                            }
-                        }
-                    }
-                }
-            } else {
-                // Nested object (not array item): wrap in section
-                let label = path.split('.').last().unwrap_or(&path);
-                rsx! {
-                    div { class: "record-section",
-                        Accordion {
-                            id: "object-{path}",
-                            collapsible: true,
-                            AccordionItem {
-                                default_open: true,
-                                index: 0,
-                                AccordionTrigger {
-                                    div { class: "section-label", "{label}" }
-                                }
-                                AccordionContent {
-                                    if has_errors {
-                                        for error in &errors {
-                                            div { class: "field-error-message", "{error}" }
-                                        }
-                                    }
-                                    div { class: "section-content",
-                                        for (key, value) in obj.iter() {
-                                            {
-                                                let new_path = format!("{}.{}", path, key);
-                                                let did_clone = did.clone();
-                                                rsx! {
-                                                    DataView { data: value.clone(), root_data, path: new_path, did: did_clone }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        Data::Blob(blob) => {
-            let is_image = blob.mime_type.starts_with("image/");
-            let format = blob.mime_type.strip_prefix("image/").unwrap_or("jpeg");
-            let image_url = format!(
-                "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@{}",
-                did,
-                blob.cid(),
-                format
-            );
-
-            let blob_size = format_size(blob.size, humansize::BINARY);
-            rsx! {
-                div { class: "record-field",
-                    span { class: "field-label", "{path}" }
-                    span { class: "field-value mime", "[mimeType: {blob.mime_type}, size: {blob_size}]" }
-                    if is_image {
-                        img {
-                            src: "{image_url}",
-                            alt: "Blob image",
-                            class: "blob-image",
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[component]
-fn HighlightedUri(uri: AtUri<'static>) -> Element {
-    let s = uri.as_str();
-    let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, s);
-
-    if let Some(rest) = s.strip_prefix("at://") {
-        let parts: Vec<&str> = rest.splitn(3, '/').collect();
-        return rsx! {
-            a {
-                href: link,
-                class: "uri-link",
-                span { class: "string-at-uri",
-                    span { class: "aturi-scheme", "at://" }
-                    span { class: "aturi-authority", "{uri.authority()}" }
-
-                    if parts.len() > 1 {
-                        span { class: "aturi-slash", "/" }
-                        if let Some(collection) = uri.collection() {
-                            span { class: "aturi-collection", "{collection.as_ref()}" }
-                        }
-                    }
-                    if parts.len() > 2 {
-                        span { class: "aturi-slash", "/" }
-                        if let Some(rkey) = uri.rkey() {
-                            span { class: "aturi-rkey", "{rkey.as_ref()}" }
-                        }
-                    }
-                }
-            }
-        };
-    }
-
-    rsx! { a { class: "string-at-uri", href: s } }
-}
-
-#[component]
-fn HighlightedString(string_type: AtprotoStr<'static>) -> Element {
-    use jacquard::types::string::AtprotoStr;
-
-    match &string_type {
-        AtprotoStr::Nsid(nsid) => {
-            let parts: Vec<&str> = nsid.as_str().split('.').collect();
-            rsx! {
-                span { class: "string-nsid",
-                    for (i, part) in parts.iter().enumerate() {
-                        span { class: "nsid-segment nsid-segment-{i % 3}", "{part}" }
-                        if i < parts.len() - 1 {
-                            span { class: "nsid-dot", "." }
-                        }
-                    }
-                }
-            }
-        }
-        AtprotoStr::Did(did) => {
-            let s = did.as_str();
-            if let Some(rest) = s.strip_prefix("did:") {
-                if let Some((method, identifier)) = rest.split_once(':') {
-                    return rsx! {
-                        span { class: "string-did",
-                            span { class: "did-scheme", "did:" }
-                            span { class: "did-method", "{method}" }
-                            span { class: "did-separator", ":" }
-                            span { class: "did-identifier", "{identifier}" }
-                        }
-                    };
-                }
-            }
-            rsx! { span { class: "string-did", "{s}" } }
-        }
-        AtprotoStr::Handle(handle) => {
-            let parts: Vec<&str> = handle.as_str().split('.').collect();
-            rsx! {
-                span { class: "string-handle",
-                    for (i, part) in parts.iter().enumerate() {
-                        span { class: "handle-segment handle-segment-{i % 2}", "{part}" }
-                        if i < parts.len() - 1 {
-                            span { class: "handle-dot", "." }
-                        }
-                    }
-                }
-            }
-        }
-        AtprotoStr::AtUri(uri) => {
-            rsx! {
-                HighlightedUri { uri: uri.clone().into_static() }
-            }
-        }
-        AtprotoStr::Uri(uri) => {
-            let s = uri.as_str();
-            if let Ok(at_uri) = AtUri::new(s) {
-                return rsx! {
-                    HighlightedUri { uri: at_uri.into_static() }
-                };
-            }
-
-            // Try to parse scheme
-            if let Some((scheme, rest)) = s.split_once("://") {
-                // Split authority and path
-                let (authority, path) = if let Some(idx) = rest.find('/') {
-                    (&rest[..idx], &rest[idx..])
-                } else {
-                    (rest, "")
-                };
-
-                return rsx! {
-                    a {
-                        href: "{s}",
-                        target: "_blank",
-                        rel: "noopener noreferrer",
-                        class: "uri-link",
-                        span { class: "string-uri",
-                            span { class: "uri-scheme", "{scheme}" }
-                            span { class: "uri-separator", "://" }
-                            span { class: "uri-authority", "{authority}" }
-                            if !path.is_empty() {
-                                span { class: "uri-path", "{path}" }
-                            }
-                        }
-                    }
-                };
-            }
-
-            rsx! { span { class: "string-uri", "{s}" } }
-        }
-        _ => {
-            let value = string_type.as_str();
-            rsx! { "{value}" }
-        }
-    }
-}
-
-#[derive(Props, Clone, PartialEq)]
-pub struct CodeViewProps {
-    #[props(default)]
-    id: Signal<String>,
-    #[props(default)]
-    class: Signal<String>,
-    code: ReadSignal<String>,
-    lang: Option<String>,
-}
-
-#[component]
-fn JsonEditor(
-    data: Signal<Data<'static>>,
-    nsid: ReadSignal<Option<String>>,
-    schema: ReadSignal<Option<LexiconDoc<'static>>>,
-) -> Element {
-    let mut json_text =
-        use_signal(|| serde_json::to_string_pretty(&*data.read()).unwrap_or_default());
-
-    let height = use_memo(move || {
-        let line_count = json_text().lines().count();
-        let min_lines = 10;
-        let lines = line_count.max(min_lines);
-        // line-height is 1.5, font-size is 0.9rem (approx 14.4px), so each line is ~21.6px
-        // Add padding (1rem top + 1rem bottom = 2rem = 32px)
-        format!("{}px", lines * 22 + 32)
-    });
-
-    let validation = use_resource(move || {
-        let text = json_text();
-        let nsid_val = nsid();
-        let _ = schema(); // Track schema changes
-
-        async move {
-            // Only validate if we have an NSID
-            let nsid_str = nsid_val?;
-
-            // Parse JSON to Data
-            let parsed = match serde_json::from_str::<Data>(&text) {
-                Ok(val) => val.into_static(),
-                Err(e) => {
-                    return Some((None, Some(e.to_string())));
-                }
-            };
-
-            // Use global validator (schema already registered)
-            let validator = jacquard_lexicon::validation::SchemaValidator::global();
-            let result = validator.validate_by_nsid(&nsid_str, &parsed);
-
-            Some((Some(result), None))
-        }
-    });
-
-    rsx! {
-        div { class: "json-editor",
-            textarea {
-                class: "json-textarea",
-                style: "height: {height};",
-                value: "{json_text}",
-                oninput: move |evt| {
-                    json_text.set(evt.value());
-                    // Update data signal on successful parse
-                    if let Ok(parsed) = serde_json::from_str::<Data>(&evt.value()) {
-                        data.set(parsed.into_static());
-                    }
-                },
-            }
-
-            ValidationPanel {
-                validation: validation,
-            }
-        }
-    }
-}
-
-#[component]
-fn ActionButtons(
-    on_update: EventHandler<()>,
-    on_save_new: EventHandler<()>,
-    on_replace: EventHandler<()>,
-    on_delete: EventHandler<()>,
-    on_cancel: EventHandler<()>,
-) -> Element {
-    let mut show_save_dropdown = use_signal(|| false);
-    let mut show_replace_warning = use_signal(|| false);
-    let mut show_delete_confirm = use_signal(|| false);
-
-    rsx! {
-        div { class: "action-buttons-group",
-            button {
-                class: "tab-button action-button",
-                onclick: move |_| on_update.call(()),
-                "Update"
-            }
-
-            div { class: "dropdown-wrapper",
-                button {
-                    class: "tab-button action-button",
-                    onclick: move |_| show_save_dropdown.toggle(),
-                    "Save as New ▼"
-                }
-                if show_save_dropdown() {
-                    div { class: "dropdown-menu",
-                        button {
-                            onclick: move |_| {
-                                show_save_dropdown.set(false);
-                                on_save_new.call(());
-                            },
-                            "Save as New"
-                        }
-                        button {
-                            onclick: move |_| {
-                                show_save_dropdown.set(false);
-                                show_replace_warning.set(true);
-                            },
-                            "Replace"
-                        }
-                    }
-                }
-            }
-
-            if show_replace_warning() {
-                div { class: "inline-warning",
-                    "⚠️ This will delete the current record and create a new one with a different rkey. "
-                    button {
-                        onclick: move |_| {
-                            show_replace_warning.set(false);
-                            on_replace.call(());
-                        },
-                        "Yes"
-                    }
-                    button {
-                        onclick: move |_| show_replace_warning.set(false),
-                        "No"
-                    }
-                }
-            }
-
-            button {
-                class: "tab-button action-button action-button-danger",
-                onclick: move |_| show_delete_confirm.set(true),
-                "Delete"
-            }
-
-            DialogRoot {
-                open: Some(show_delete_confirm()),
-                on_open_change: move |open: bool| {
-                    show_delete_confirm.set(open);
-                },
-                DialogContent {
-                    DialogTitle { "Delete Record?" }
-                    DialogDescription {
-                        "This action cannot be undone."
-                    }
-                    div { class: "dialog-actions",
-                        button {
-                            onclick: move |_| {
-                                show_delete_confirm.set(false);
-                                on_delete.call(());
-                            },
-                            "Delete"
-                        }
-                        button {
-                            onclick: move |_| show_delete_confirm.set(false),
-                            "Cancel"
-                        }
-                    }
-                }
-            }
-
-            button {
-                class: "tab-button action-button",
-                onclick: move |_| on_cancel.call(()),
-                "Cancel"
-            }
-        }
-    }
-}
-
-#[component]
-fn ValidationPanel(
-    validation: Resource<Option<(Option<ValidationResult>, Option<String>)>>,
-) -> Element {
-    rsx! {
-        div { class: "validation-panel",
-            if let Some(Some((result_opt, parse_error_opt))) = validation.read().as_ref() {
-                if let Some(parse_err) = parse_error_opt {
-                    div { class: "parse-error",
-                        "❌ Invalid JSON: {parse_err}"
-                    }
-                }
-
-                if let Some(result) = result_opt {
-                    // Structural validity
-                    if result.is_structurally_valid() {
-                        div { class: "validation-success", "✓ Structurally valid" }
-                    } else {
-                        div { class: "parse-error", "❌ Structurally invalid" }
-                    }
-
-                    // Overall validity
-                    if result.is_valid() {
-                        div { class: "validation-success", "✓ Fully valid" }
-                    } else {
-                        div { class: "validation-warning", "⚠ Has errors" }
-                    }
-
-                    // Show errors if any
-                    if !result.is_valid() {
-                        div { class: "validation-errors",
-                            h4 { "Validation Errors:" }
-                            for error in result.all_errors() {
-                                div { class: "error", "{error}" }
-                            }
-                        }
-                    }
-                }
-            } else {
-                div { "Validating..." }
-            }
-        }
-    }
-}
-
-// ============================================================================
-// Validation Helper Functions
-// ============================================================================
-
-/// Parse UI path into segments (fields and indices only)
-fn parse_ui_path(ui_path: &str) -> Vec<UiPathSegment> {
-    if ui_path.is_empty() {
-        return vec![];
-    }
-
-    let mut segments = Vec::new();
-    let mut current = String::new();
-
-    for ch in ui_path.chars() {
-        match ch {
-            '.' => {
-                if !current.is_empty() {
-                    segments.push(UiPathSegment::Field(current.clone()));
-                    current.clear();
-                }
-            }
-            '[' => {
-                if !current.is_empty() {
-                    segments.push(UiPathSegment::Field(current.clone()));
-                    current.clear();
-                }
-            }
-            ']' => {
-                if !current.is_empty() {
-                    if let Ok(idx) = current.parse::<usize>() {
-                        segments.push(UiPathSegment::Index(idx));
-                    }
-                    current.clear();
-                }
-            }
-            c => current.push(c),
-        }
-    }
-
-    if !current.is_empty() {
-        segments.push(UiPathSegment::Field(current));
-    }
-
-    segments
-}
-
-#[derive(Debug, PartialEq)]
-enum UiPathSegment {
-    Field(String),
-    Index(usize),
-}
-
-/// Get all validation errors at exactly this path (not children)
-fn get_errors_at_exact_path(
-    validation_result: &Option<ValidationResult>,
-    ui_path: &str,
-) -> Vec<String> {
-    use jacquard_lexicon::validation::PathSegment;
-
-    if let Some(result) = validation_result {
-        let ui_segments = parse_ui_path(ui_path);
-
-        result
-            .all_errors()
-            .filter_map(|err| {
-                let validation_path = match &err {
-                    ValidationError::Structural(s) => match s {
-                        StructuralError::TypeMismatch { path, .. } => Some(path),
-                        StructuralError::MissingRequiredField { path, .. } => Some(path),
-                        StructuralError::MissingUnionDiscriminator { path } => Some(path),
-                        StructuralError::UnionNoMatch { path, .. } => Some(path),
-                        StructuralError::UnresolvedRef { path, .. } => Some(path),
-                        StructuralError::RefCycle { path, .. } => Some(path),
-                        StructuralError::MaxDepthExceeded { path, .. } => Some(path),
-                    },
-                    ValidationError::Constraint(c) => match c {
-                        ConstraintError::MaxLength { path, .. } => Some(path),
-                        ConstraintError::MaxGraphemes { path, .. } => Some(path),
-                        ConstraintError::MinLength { path, .. } => Some(path),
-                        ConstraintError::MinGraphemes { path, .. } => Some(path),
-                        ConstraintError::Maximum { path, .. } => Some(path),
-                        ConstraintError::Minimum { path, .. } => Some(path),
-                    },
-                };
-
-                if let Some(path) = validation_path {
-                    // Convert validation path to UI segments
-                    let validation_ui_segments: Vec<_> = path
-                        .segments()
-                        .iter()
-                        .filter_map(|seg| match seg {
-                            PathSegment::Field(name) => {
-                                Some(UiPathSegment::Field(name.to_string()))
-                            }
-                            PathSegment::Index(idx) => Some(UiPathSegment::Index(*idx)),
-                            PathSegment::UnionVariant(_) => None,
-                        })
-                        .collect();
-
-                    // Exact match only
-                    if validation_ui_segments == ui_segments {
-                        return Some(err.to_string());
-                    }
-                }
-                None
-            })
-            .collect()
-    } else {
-        Vec::new()
-    }
-}
-
-// ============================================================================
-// Pretty Editor: Helper Functions
-// ============================================================================
-
-/// Infer Data type from text input
-fn infer_data_from_text(text: &str) -> Result<Data<'static>, String> {
-    let trimmed = text.trim();
-
-    if trimmed == "true" || trimmed == "false" {
-        Ok(Data::Boolean(trimmed == "true"))
-    } else if trimmed == "{}" {
-        use jacquard::types::value::Object;
-        use std::collections::BTreeMap;
-        Ok(Data::Object(Object(BTreeMap::new())))
-    } else if trimmed == "[]" {
-        use jacquard::types::value::Array;
-        Ok(Data::Array(Array(Vec::new())))
-    } else if trimmed == "null" {
-        Ok(Data::Null)
-    } else if let Ok(num) = trimmed.parse::<i64>() {
-        Ok(Data::Integer(num))
-    } else {
-        // Smart string parsing
-        use jacquard::types::value::parsing;
-        Ok(Data::String(parsing::parse_string(trimmed).into_static()))
-    }
-}
-
-/// Parse text as specific AtprotoStr type, preserving type information
-fn try_parse_as_type(
-    text: &str,
-    string_type: LexiconStringType,
-) -> Result<AtprotoStr<'static>, String> {
-    use jacquard::types::string::*;
-    use std::str::FromStr;
-
-    match string_type {
-        LexiconStringType::Datetime => Datetime::from_str(text)
-            .map(AtprotoStr::Datetime)
-            .map_err(|e| format!("Invalid datetime: {}", e)),
-        LexiconStringType::Did => Did::new(text)
-            .map(|v| AtprotoStr::Did(v.into_static()))
-            .map_err(|e| format!("Invalid DID: {}", e)),
-        LexiconStringType::Handle => Handle::new(text)
-            .map(|v| AtprotoStr::Handle(v.into_static()))
-            .map_err(|e| format!("Invalid handle: {}", e)),
-        LexiconStringType::AtUri => AtUri::new(text)
-            .map(|v| AtprotoStr::AtUri(v.into_static()))
-            .map_err(|e| format!("Invalid AT-URI: {}", e)),
-        LexiconStringType::AtIdentifier => AtIdentifier::new(text)
-            .map(|v| AtprotoStr::AtIdentifier(v.into_static()))
-            .map_err(|e| format!("Invalid identifier: {}", e)),
-        LexiconStringType::Nsid => Nsid::new(text)
-            .map(|v| AtprotoStr::Nsid(v.into_static()))
-            .map_err(|e| format!("Invalid NSID: {}", e)),
-        LexiconStringType::Tid => Tid::new(text)
-            .map(|v| AtprotoStr::Tid(v.into_static()))
-            .map_err(|e| format!("Invalid TID: {}", e)),
-        LexiconStringType::RecordKey => Rkey::new(text)
-            .map(|rk| AtprotoStr::RecordKey(RecordKey::from(rk)))
-            .map_err(|e| format!("Invalid record key: {}", e)),
-        LexiconStringType::Cid => Cid::new(text.as_bytes())
-            .map(|v| AtprotoStr::Cid(v.into_static()))
-            .map_err(|_| "Invalid CID".to_string()),
-        LexiconStringType::Language => Language::new(text)
-            .map(AtprotoStr::Language)
-            .map_err(|e| format!("Invalid language: {}", e)),
-        LexiconStringType::Uri(_) => Uri::new(text)
-            .map(|u| AtprotoStr::Uri(u.into_static()))
-            .map_err(|e| format!("Invalid URI: {}", e)),
-        LexiconStringType::String => {
-            // Plain strings: use smart inference
-            use jacquard::types::value::parsing;
-            Ok(parsing::parse_string(text).into_static())
-        }
-    }
-}
-
-/// Create default value for new array item by cloning structure of existing items
-fn create_array_item_default(arr: &jacquard::types::value::Array) -> Data<'static> {
-    if let Some(existing) = arr.0.first() {
-        clone_structure(existing)
-    } else {
-        // Empty array, default to null (user can change type)
-        Data::Null
-    }
-}
-
-/// Clone structure of Data, setting sensible defaults for leaf values
-fn clone_structure(data: &Data) -> Data<'static> {
-    use jacquard::types::string::*;
-    use jacquard::types::value::{Array, Object};
-    use jacquard::types::{LexiconStringType, blob::*};
-    use std::collections::BTreeMap;
-
-    match data {
-        Data::Object(obj) => {
-            let mut new_obj = BTreeMap::new();
-            for (key, value) in obj.0.iter() {
-                new_obj.insert(key.clone(), clone_structure(value));
-            }
-            Data::Object(Object(new_obj))
-        }
-        Data::Array(_) => Data::Array(Array(Vec::new())),
-        Data::String(s) => match s.string_type() {
-            LexiconStringType::Datetime => {
-                // Sensible default: now
-                Data::String(AtprotoStr::Datetime(Datetime::now()))
-            }
-            LexiconStringType::Tid => Data::String(AtprotoStr::Tid(Tid::now_0())),
-            _ => {
-                // Empty string, type inference will handle it
-                Data::String(AtprotoStr::String("".into()))
-            }
-        },
-        Data::Integer(_) => Data::Integer(0),
-        Data::Boolean(_) => Data::Boolean(false),
-        Data::Blob(blob) => {
-            // Placeholder blob
-            Data::Blob(
-                Blob {
-                    r#ref: CidLink::str(
-                        "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-                    ),
-                    mime_type: blob.mime_type.clone(),
-                    size: 0,
-                }
-                .into_static(),
-            )
-        }
-        Data::CidLink(_) => Data::CidLink(Cid::str(
-            "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-        )),
-        Data::Bytes(_) => Data::Bytes(Bytes::new()),
-        Data::Null => Data::Null,
-    }
-}
-
-// ============================================================================
-// Pretty Editor: Component Hierarchy
-// ============================================================================
-
-/// Main dispatcher - routes to specific field editors based on Data type
-#[component]
-fn EditableDataView(
-    root: Signal<Data<'static>>,
-    path: String,
-    did: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let root_read = root.read();
-
-    match root_read
-        .get_at_path(&path_for_memo)
-        .map(|d| d.clone().into_static())
-    {
-        Some(Data::Object(_)) => {
-            rsx! { EditableObjectField { root, path: path.clone(), did, remove_button } }
-        }
-        Some(Data::Array(_)) => rsx! { EditableArrayField { root, path: path.clone(), did } },
-        Some(Data::String(_)) => {
-            rsx! { EditableStringField { root, path: path.clone(), remove_button } }
-        }
-        Some(Data::Integer(_)) => {
-            rsx! { EditableIntegerField { root, path: path.clone(), remove_button } }
-        }
-        Some(Data::Boolean(_)) => {
-            rsx! { EditableBooleanField { root, path: path.clone(), remove_button } }
-        }
-        Some(Data::Null) => rsx! { EditableNullField { root, path: path.clone(), remove_button } },
-        Some(Data::Blob(_)) => {
-            rsx! { EditableBlobField { root, path: path.clone(), did, remove_button } }
-        }
-        Some(Data::Bytes(_)) => {
-            rsx! { EditableBytesField { root, path: path.clone(), remove_button } }
-        }
-        Some(Data::CidLink(_)) => {
-            rsx! { EditableCidLinkField { root, path: path.clone(), remove_button } }
-        }
-
-        None => rsx! { div { class: "field-error", "❌ Path not found: {path}" } },
-    }
-}
-
-// ============================================================================
-// Primitive Field Editors
-// ============================================================================
-
-/// String field with type preservation
-#[component]
-fn EditableStringField(
-    root: Signal<Data<'static>>,
-    path: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    use jacquard::types::LexiconStringType;
-
-    let path_for_text = path.clone();
-    let path_for_type = path.clone();
-
-    // Get current string value
-    let current_text = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_text)
-            .and_then(|d| d.as_str())
-            .map(|s| s.to_string())
-            .unwrap_or_default()
-    });
-
-    // Get string type (Copy, cheap to store)
-    let string_type = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_type)
-            .and_then(|d| match d {
-                Data::String(s) => Some(s.string_type()),
-                _ => None,
-            })
-            .unwrap_or(LexiconStringType::String)
-    });
-
-    // Local state for invalid input
-    let mut input_text = use_signal(|| current_text());
-    let mut parse_error = use_signal(|| None::<String>);
-
-    // Sync input when current changes
-    use_effect(move || {
-        input_text.set(current_text());
-    });
-
-    let path_for_mutation = path.clone();
-    let handle_input = move |evt: Event<FormData>| {
-        let new_text = evt.value();
-        input_text.set(new_text.clone());
-
-        match try_parse_as_type(&new_text, string_type()) {
-            Ok(new_atproto_str) => {
-                parse_error.set(None);
-                let mut new_data = root.read().clone();
-                new_data.set_at_path(&path_for_mutation, Data::String(new_atproto_str));
-                root.set(new_data);
-            }
-            Err(e) => {
-                parse_error.set(Some(e));
-            }
-        }
-    };
-
-    let type_label = format!("{:?}", string_type()).to_lowercase();
-    let is_plain_string = string_type() == LexiconStringType::String;
-
-    // Dynamic width based on content length
-    let input_width = use_memo(move || {
-        let len = input_text().len();
-        let min_width = match string_type() {
-            LexiconStringType::Cid => 60,
-            LexiconStringType::Nsid => 40,
-            LexiconStringType::Did => 50,
-            LexiconStringType::AtUri => 50,
-            _ => 20,
-        };
-        format!("{}ch", len.max(min_width))
-    });
-
-    rsx! {
-        div { class: "record-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                if type_label != "string" {
-                    span { class: "string-type-tag", " [{type_label}]" }
-                }
-                {remove_button}
-            }
-            if is_plain_string {
-                textarea {
-                    value: "{input_text}",
-                    oninput: handle_input,
-                    class: if parse_error().is_some() { "invalid" } else { "" },
-                    rows: "1",
-                }
-            } else {
-                input {
-                    r#type: "text",
-                    value: "{input_text}",
-                    style: "width: {input_width}",
-                    oninput: handle_input,
-                    class: if parse_error().is_some() { "invalid" } else { "" },
-                }
-            }
-            if let Some(err) = parse_error() {
-                span { class: "field-error", " ❌ {err}" }
-            }
-        }
-    }
-}
-
-/// Integer field with validation
-#[component]
-fn EditableIntegerField(
-    root: Signal<Data<'static>>,
-    path: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let current_value = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .and_then(|d| d.as_integer())
-            .unwrap_or(0)
-    });
-
-    let mut input_text = use_signal(|| current_value().to_string());
-    let mut parse_error = use_signal(|| None::<String>);
-
-    use_effect(move || {
-        input_text.set(current_value().to_string());
-    });
-
-    let path_for_mutation = path.clone();
-
-    rsx! {
-        div { class: "record-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                {remove_button}
-            }
-            input {
-                r#type: "number",
-                value: "{input_text}",
-                oninput: move |evt| {
-                    let text = evt.value();
-                    input_text.set(text.clone());
-
-                    match text.parse::<i64>() {
-                        Ok(num) => {
-                            parse_error.set(None);
-                            let mut data_edit = root.write_unchecked();
-                             data_edit.set_at_path(&path_for_mutation, Data::Integer(num));
-                        }
-                        Err(_) => {
-                            parse_error.set(Some("Must be a valid integer".to_string()));
-                        }
-                    }
-                }
-            }
-            if let Some(err) = parse_error() {
-                span { class: "field-error", " ❌ {err}" }
-            }
-        }
-    }
-}
-
-/// Boolean field (toggle button)
-#[component]
-fn EditableBooleanField(
-    root: Signal<Data<'static>>,
-    path: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let current_value = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .and_then(|d| d.as_boolean())
-            .unwrap_or(false)
-    });
-
-    let path_for_mutation = path.clone();
-    rsx! {
-        div { class: "record-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                {remove_button}
-            }
-            button {
-                class: if current_value() { "boolean-toggle boolean-toggle-true" } else { "boolean-toggle boolean-toggle-false" },
-                onclick: move |_| {
-                    root.with_mut(|data| {
-                        if let Some(target) = data.get_at_path_mut(path_for_mutation.as_str()) {
-                            if let Some(bool_val) = target.as_boolean() {
-                                *target = Data::Boolean(!bool_val);
-                            }
-                        }
-                    });
-                },
-                "{current_value()}"
-            }
-        }
-    }
-}
-
-/// Null field with type inference
-#[component]
-fn EditableNullField(
-    root: Signal<Data<'static>>,
-    path: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let mut input_text = use_signal(|| String::new());
-    let mut parse_error = use_signal(|| None::<String>);
-
-    let path_for_mutation = path.clone();
-    rsx! {
-        div { class: "record-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                span { class: "field-value muted", "null" }
-                {remove_button}
-            }
-            input {
-                r#type: "text",
-                placeholder: "Enter value (or {{}}, [], true, 123)...",
-                value: "{input_text}",
-                oninput: move |evt| {
-                    input_text.set(evt.value());
-                },
-                onkeydown: move |evt| {
-                    use dioxus::prelude::keyboard_types::Key;
-                    if evt.key() == Key::Enter {
-                        let text = input_text();
-                        match infer_data_from_text(&text) {
-                            Ok(new_value) => {
-                                root.with_mut(|data| {
-                                    if let Some(target) = data.get_at_path_mut(path_for_mutation.as_str()) {
-                                        *target = new_value;
-                                    }
-                                });
-                                input_text.set(String::new());
-                                parse_error.set(None);
-                            }
-                            Err(e) => {
-                                parse_error.set(Some(e));
-                            }
-                        }
-                    }
-                }
-            }
-            if let Some(err) = parse_error() {
-                span { class: "field-error", " ❌ {err}" }
-            }
-        }
-    }
-}
-
-/// Blob field - shows CID, size (editable), mime type (read-only), file upload
-#[component]
-fn EditableBlobField(
-    root: Signal<Data<'static>>,
-    path: String,
-    did: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let blob_data = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .and_then(|d| match d {
-                Data::Blob(blob) => Some((
-                    blob.r#ref.to_string(),
-                    blob.size,
-                    blob.mime_type.as_str().to_string(),
-                )),
-                _ => None,
-            })
-    });
-
-    let mut cid_input = use_signal(|| String::new());
-    let mut size_input = use_signal(|| String::new());
-    let mut cid_error = use_signal(|| None::<String>);
-    let mut size_error = use_signal(|| None::<String>);
-    let mut uploading = use_signal(|| false);
-    let mut upload_error = use_signal(|| None::<String>);
-    let mut preview_data_url = use_signal(|| None::<String>);
-
-    // Sync inputs when blob data changes
-    use_effect(move || {
-        if let Some((cid, size, _)) = blob_data() {
-            cid_input.set(cid);
-            size_input.set(size.to_string());
-        }
-    });
-
-    let fetcher = use_context::<CachedFetcher>();
-    let path_for_upload = path.clone();
-    let handle_file = move |evt: Event<dioxus::prelude::FormData>| {
-        let fetcher = fetcher.clone();
-        let path_upload_clone = path_for_upload.clone();
-        spawn(async move {
-            uploading.set(true);
-            upload_error.set(None);
-
-            let files = evt.files();
-            for file_data in files {
-                match file_data.read_bytes().await {
-                    Ok(bytes_data) => {
-                        // Convert to jacquard Bytes and sniff MIME type
-                        let bytes = jacquard::bytes::Bytes::from(bytes_data.to_vec());
-                        let mime_str = bytes
-                            .sniff_mime_type()
-                            .unwrap_or("application/octet-stream");
-                        let mime_type = jacquard::types::blob::MimeType::new_owned(mime_str);
-
-                        // Create data URL for immediate preview if it's an image
-                        if mime_str.starts_with("image/") {
-                            let base64_data = base64::Engine::encode(
-                                &base64::engine::general_purpose::STANDARD,
-                                &bytes,
-                            );
-                            let data_url = format!("data:{};base64,{}", mime_str, base64_data);
-                            preview_data_url.set(Some(data_url.clone()));
-
-                            // Try to decode dimensions and populate aspectRatio field
-                            #[cfg(target_arch = "wasm32")]
-                            {
-                                let path_clone = path_upload_clone.clone();
-                                spawn(async move {
-                                    if let Some((width, height)) =
-                                        decode_image_dimensions(&data_url).await
-                                    {
-                                        populate_aspect_ratio(
-                                            root,
-                                            &path_clone,
-                                            width as i64,
-                                            height as i64,
-                                        );
-                                    }
-                                });
-                            }
-                        }
-
-                        // Upload blob
-                        let client = fetcher.get_client();
-                        match client.upload_blob(bytes, mime_type).await {
-                            Ok(new_blob) => {
-                                // Update blob in record
-                                let path_ref = path_upload_clone.clone();
-                                root.with_mut(|record_data| {
-                                    if let Some(Data::Blob(blob)) =
-                                        record_data.get_at_path_mut(&path_ref)
-                                    {
-                                        *blob = new_blob;
-                                    }
-                                });
-                                upload_error.set(None);
-                            }
-                            Err(e) => {
-                                upload_error.set(Some(format!("Upload failed: {:?}", e)));
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        upload_error.set(Some(format!("Failed to read file: {}", e)));
-                    }
-                }
-            }
-
-            uploading.set(false);
-        });
-    };
-
-    let path_for_cid = path.clone();
-    let handle_cid_change = move |evt: Event<dioxus::prelude::FormData>| {
-        let text = evt.value();
-        cid_input.set(text.clone());
-
-        match jacquard::types::cid::CidLink::new_owned(text.as_bytes()) {
-            Ok(new_cid_link) => {
-                cid_error.set(None);
-                root.with_mut(|data| {
-                    if let Some(Data::Blob(blob)) = data.get_at_path_mut(&path_for_cid) {
-                        blob.r#ref = new_cid_link;
-                    }
-                });
-            }
-            Err(_) => {
-                cid_error.set(Some("Invalid CID format".to_string()));
-            }
-        }
-    };
-
-    let path_for_size = path.clone();
-    let handle_size_change = move |evt: Event<dioxus::prelude::FormData>| {
-        let text = evt.value();
-        size_input.set(text.clone());
-
-        match text.parse::<usize>() {
-            Ok(new_size) => {
-                size_input.set(format_size(new_size, humansize::BINARY));
-                size_error.set(None);
-                root.with_mut(|data| {
-                    if let Some(Data::Blob(blob)) = data.get_at_path_mut(&path_for_size) {
-                        blob.size = new_size;
-                    }
-                });
-            }
-            Err(_) => {
-                size_error.set(Some("Must be a non-negative integer".to_string()));
-            }
-        }
-    };
-
-    let placeholder_cid = "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-    let is_placeholder = blob_data()
-        .map(|(cid, _, _)| cid == placeholder_cid)
-        .unwrap_or(true);
-    let is_image = blob_data()
-        .map(|(_, _, mime)| mime.starts_with("image/"))
-        .unwrap_or(false);
-
-    // Use preview data URL if available (fresh upload), otherwise CDN
-    let image_url = if let Some(data_url) = preview_data_url() {
-        Some(data_url)
-    } else if !is_placeholder && is_image {
-        blob_data().map(|(cid, _, mime)| {
-            let format = mime.strip_prefix("image/").unwrap_or("jpeg");
-            format!(
-                "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@{}",
-                did, cid, format
-            )
-        })
-    } else {
-        None
-    };
-
-    rsx! {
-        div { class: "record-field blob-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                span { class: "string-type-tag", " [blob]" }
-                {remove_button}
-            }
-            div { class: "blob-fields",
-                div { class: "blob-field-row blob-field-cid",
-                    label { "CID:" }
-                    input {
-                        r#type: "text",
-                        value: "{cid_input}",
-                        oninput: handle_cid_change,
-                        class: if cid_error().is_some() { "invalid" } else { "" },
-                    }
-                    if let Some(err) = cid_error() {
-                        span { class: "field-error", " ❌ {err}" }
-                    }
-                }
-                div { class: "blob-field-row",
-                    label { "Size:" }
-                    input {
-                        r#type: "number",
-                        value: "{size_input}",
-                        oninput: handle_size_change,
-                        class: if size_error().is_some() { "invalid" } else { "" },
-                    }
-                    if let Some(err) = size_error() {
-                        span { class: "field-error", " ❌ {err}" }
-                    }
-                }
-                div { class: "blob-field-row",
-                    label { "MIME Type:" }
-                    span { class: "readonly",
-                        "{blob_data().map(|(_, _, mime)| mime).unwrap_or_default()}"
-                    }
-                }
-                if let Some(url) = image_url {
-                    img {
-                        src: "{url}",
-                        alt: "Blob preview",
-                        class: "blob-image",
-                    }
-                }
-                div { class: "blob-upload-section",
-                    input {
-                        r#type: "file",
-                        accept: if is_image { "image/*" } else { "*/*" },
-                        onchange: handle_file,
-                        disabled: uploading(),
-                    }
-                    if uploading() {
-                        span { class: "upload-status", "Uploading..." }
-                    }
-                    if let Some(err) = upload_error() {
-                        div { class: "field-error", "❌ {err}" }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Decode image dimensions from data URL using browser Image API
-#[cfg(target_arch = "wasm32")]
-async fn decode_image_dimensions(data_url: &str) -> Option<(u32, u32)> {
-    use wasm_bindgen::JsCast;
-    use wasm_bindgen::prelude::*;
-    use wasm_bindgen_futures::JsFuture;
-
-    let window = web_sys::window()?;
-    let document = window.document()?;
-
-    let img = document.create_element("img").ok()?;
-    let img = img.dyn_into::<web_sys::HtmlImageElement>().ok()?;
-
-    img.set_src(data_url);
-
-    // Wait for image to load
-    let promise = js_sys::Promise::new(&mut |resolve, _reject| {
-        let onload = Closure::wrap(Box::new(move || {
-            resolve.call0(&JsValue::NULL).ok();
-        }) as Box<dyn FnMut()>);
-
-        img.set_onload(Some(onload.as_ref().unchecked_ref()));
-        onload.forget();
-    });
-
-    JsFuture::from(promise).await.ok()?;
-
-    Some((img.natural_width(), img.natural_height()))
-}
-
-/// Find and populate aspectRatio field for a blob
-#[allow(unused)]
-fn populate_aspect_ratio(
-    mut root: Signal<Data<'static>>,
-    blob_path: &str,
-    width: i64,
-    height: i64,
-) {
-    // Query for all aspectRatio fields and collect the path we want
-    let aspect_path_to_update = {
-        let data = root.read();
-        let query_result = data.query("...aspectRatio");
-
-        query_result.multiple().and_then(|matches| {
-            // Find aspectRatio that's a sibling of our blob
-            // e.g. blob at "embed.images[0].image" -> look for "embed.images[0].aspectRatio"
-            let blob_parent = blob_path.rsplit_once('.').map(|(parent, _)| parent);
-            matches.iter().find_map(|query_match| {
-                let aspect_parent = query_match.path.rsplit_once('.').map(|(parent, _)| parent);
-
-                // Check if they share the same parent
-                if blob_parent == aspect_parent {
-                    Some(query_match.path.clone())
-                } else {
-                    None
-                }
-            })
-        })
-    };
-
-    // Update the aspectRatio if we found a matching field
-    if let Some(aspect_path) = aspect_path_to_update {
-        let aspect_obj = atproto! {{
-            "width": width,
-            "height": height
-        }};
-
-        root.with_mut(|record_data| {
-            record_data.set_at_path(&aspect_path, aspect_obj);
-        });
-    }
-}
-
-/// Bytes field with hex/base64 auto-detection
-#[component]
-fn EditableBytesField(
-    root: Signal<Data<'static>>,
-    path: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let current_bytes = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .and_then(|d| match d {
-                Data::Bytes(b) => Some(bytes_to_hex(b)),
-                _ => None,
-            })
-    });
-
-    let mut input_text = use_signal(|| String::new());
-    let mut parse_error = use_signal(|| None::<String>);
-    let mut detected_format = use_signal(|| None::<String>);
-
-    // Sync input when bytes change
-    use_effect(move || {
-        if let Some(hex) = current_bytes() {
-            input_text.set(hex);
-        }
-    });
-
-    let path_for_mutation = path.clone();
-    let handle_input = move |evt: Event<dioxus::prelude::FormData>| {
-        let text = evt.value();
-        input_text.set(text.clone());
-
-        match parse_bytes_input(&text) {
-            Ok((bytes, format)) => {
-                parse_error.set(None);
-                detected_format.set(Some(format));
-                root.with_mut(|data| {
-                    if let Some(target) = data.get_at_path_mut(&path_for_mutation) {
-                        *target = Data::Bytes(bytes);
-                    }
-                });
-            }
-            Err(e) => {
-                parse_error.set(Some(e));
-                detected_format.set(None);
-            }
-        }
-    };
-
-    let byte_count = current_bytes()
-        .map(|hex| hex.chars().filter(|c| c.is_ascii_hexdigit()).count() / 2)
-        .unwrap_or(0);
-    let size_label = if byte_count > 128 {
-        format_size(byte_count, humansize::BINARY)
-    } else {
-        format!("{} bytes", byte_count)
-    };
-
-    rsx! {
-        div { class: "record-field bytes-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                span { class: "string-type-tag", " [bytes: {size_label}]" }
-                if let Some(format) = detected_format() {
-                    span { class: "bytes-format-tag", " ({format})" }
-                }
-                {remove_button}
-            }
-            textarea {
-                value: "{input_text}",
-                placeholder: "Paste hex (1a2b3c...) or base64 (YWJj...)",
-                oninput: handle_input,
-                class: if parse_error().is_some() { "invalid" } else { "" },
-                rows: "3",
-            }
-            if let Some(err) = parse_error() {
-                span { class: "field-error", " ❌ {err}" }
-            }
-        }
-    }
-}
-
-/// Parse bytes from hex or base64, auto-detecting format
-fn parse_bytes_input(text: &str) -> Result<(jacquard::bytes::Bytes, String), String> {
-    let trimmed = text.trim();
-    if trimmed.is_empty() {
-        return Err("Input is empty".to_string());
-    }
-
-    // Remove common whitespace/separators
-    let cleaned: String = trimmed
-        .chars()
-        .filter(|c| !c.is_whitespace() && *c != ':' && *c != '-')
-        .collect();
-
-    // Try hex first (more restrictive)
-    if cleaned.chars().all(|c| c.is_ascii_hexdigit()) {
-        parse_hex_bytes(&cleaned).map(|b| (b, "hex".to_string()))
-    } else {
-        // Try base64
-        parse_base64_bytes(&cleaned).map(|b| (b, "base64".to_string()))
-    }
-}
-
-/// Parse hex string to bytes
-fn parse_hex_bytes(hex: &str) -> Result<jacquard::bytes::Bytes, String> {
-    if hex.len() % 2 != 0 {
-        return Err("Hex string must have even length".to_string());
-    }
-
-    let mut bytes = Vec::with_capacity(hex.len() / 2);
-    for chunk in hex.as_bytes().chunks(2) {
-        let hex_byte = std::str::from_utf8(chunk).map_err(|e| format!("Invalid UTF-8: {}", e))?;
-        let byte =
-            u8::from_str_radix(hex_byte, 16).map_err(|e| format!("Invalid hex digit: {}", e))?;
-        bytes.push(byte);
-    }
-
-    Ok(jacquard::bytes::Bytes::from(bytes))
-}
-
-/// Parse base64 string to bytes
-fn parse_base64_bytes(b64: &str) -> Result<jacquard::bytes::Bytes, String> {
-    use base64::Engine;
-    let engine = base64::engine::general_purpose::STANDARD;
-
-    engine
-        .decode(b64)
-        .map(jacquard::bytes::Bytes::from)
-        .map_err(|e| format!("Invalid base64: {}", e))
-}
-
-/// Convert bytes to hex display string (with spacing every 4 chars)
-fn bytes_to_hex(bytes: &jacquard::bytes::Bytes) -> String {
-    bytes
-        .iter()
-        .enumerate()
-        .map(|(i, b)| {
-            let hex = format!("{:02x}", b);
-            if i > 0 && i % 2 == 0 {
-                format!(" {}", hex)
-            } else {
-                hex
-            }
-        })
-        .collect()
-}
-
-/// CidLink field with validation
-#[component]
-fn EditableCidLinkField(
-    root: Signal<Data<'static>>,
-    path: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let current_cid = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .map(|d| match d {
-                Data::CidLink(cid) => cid.to_string(),
-                _ => String::new(),
-            })
-            .unwrap_or_default()
-    });
-
-    let mut input_text = use_signal(|| String::new());
-    let mut parse_error = use_signal(|| None::<String>);
-
-    use_effect(move || {
-        input_text.set(current_cid());
-    });
-
-    let input_width = use_memo(move || {
-        let len = input_text().len();
-        format!("{}ch", len.max(60))
-    });
-
-    let path_for_mutation = path.clone();
-    let handle_input = move |evt: Event<dioxus::prelude::FormData>| {
-        let text = evt.value();
-        input_text.set(text.clone());
-
-        match jacquard::types::cid::Cid::new_owned(text.as_bytes()) {
-            Ok(new_cid) => {
-                parse_error.set(None);
-                root.with_mut(|data| {
-                    if let Some(target) = data.get_at_path_mut(&path_for_mutation) {
-                        *target = Data::CidLink(new_cid);
-                    }
-                });
-            }
-            Err(_) => {
-                parse_error.set(Some("Invalid CID format".to_string()));
-            }
-        }
-    };
-
-    rsx! {
-        div { class: "record-field cidlink-field",
-            div { class: "field-header",
-                PathLabel { path: path.clone() }
-                span { class: "string-type-tag", " [cid-link]" }
-                {remove_button}
-            }
-            input {
-                r#type: "text",
-                value: "{input_text}",
-                style: "width: {input_width}",
-                placeholder: "bafyrei...",
-                oninput: handle_input,
-                class: if parse_error().is_some() { "invalid" } else { "" },
-            }
-            if let Some(err) = parse_error() {
-                span { class: "field-error", " ❌ {err}" }
-            }
-        }
-    }
-}
-
-// ============================================================================
-// Field with Remove Button Wrapper
-// ============================================================================
-
-/// Wraps a field with an optional remove button in the header
-#[component]
-fn FieldWithRemove(
-    root: Signal<Data<'static>>,
-    path: String,
-    did: String,
-    is_removable: bool,
-    parent_path: String,
-    field_key: String,
-) -> Element {
-    let remove_button = if is_removable {
-        Some(rsx! {
-            button {
-                class: "field-remove-button",
-                onclick: move |_| {
-                    let mut new_data = root.read().clone();
-                    if let Some(Data::Object(obj)) = new_data.get_at_path_mut(parent_path.as_str()) {
-                        obj.0.remove(field_key.as_str());
-                    }
-                    root.set(new_data);
-                },
-                "Remove"
-            }
-        })
-    } else {
-        None
-    };
-
-    rsx! {
-        EditableDataView {
-            root: root,
-            path: path.clone(),
-            did: did.clone(),
-            remove_button: remove_button,
-        }
-    }
-}
-
-// ============================================================================
-// Array Field Editor (enables recursion)
-// ============================================================================
-
-/// Array field - iterates items and renders child EditableDataView for each
-#[component]
-fn EditableArrayField(root: Signal<Data<'static>>, path: String, did: String) -> Element {
-    let path_for_memo = path.clone();
-    let array_len = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .and_then(|d| d.as_array())
-            .map(|arr| arr.0.len())
-            .unwrap_or(0)
-    });
-
-    let path_for_add = path.clone();
-
-    rsx! {
-        div { class: "record-section array-section",
-            Accordion {
-                id: "edit-array-{path}",
-                collapsible: true,
-                AccordionItem {
-                    default_open: true,
-                    index: 0,
-                    AccordionTrigger {
-                        div { class: "section-header",
-                            div { class: "section-label",
-                                {
-                                    let parts: Vec<&str> = path.split('.').collect();
-                                    let final_part = parts.last().unwrap_or(&"");
-                                    rsx! { "{final_part}" }
-                                }
-                            }
-                            span { class: "array-length", "[{array_len}]" }
-                        }
-                    }
-                    AccordionContent {
-                        div { class: "section-content",
-                            for idx in 0..array_len() {
-                                {
-                                    let item_path = format!("{}[{}]", path, idx);
-                                    let path_for_remove = path.clone();
-
-                                    rsx! {
-                                        div {
-                                            class: "array-item",
-                                            key: "{item_path}",
-
-                                            EditableDataView {
-                                                root: root,
-                                                path: item_path.clone(),
-                                                did: did.clone(),
-                                                remove_button: rsx! {
-                                                    button {
-                                                        class: "field-remove-button",
-                                                        onclick: move |_| {
-                                                            root.with_mut(|data| {
-                                                                if let Some(Data::Array(arr)) = data.get_at_path_mut(&path_for_remove) {
-                                                                    arr.0.remove(idx);
-                                                                }
-                                                            });
-                                                        },
-                                                        "Remove"
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            div {
-                                class: "array-item",
-                                div {
-                                    class: "add-field-widget",
-                                    button {
-                                        onclick: move |_| {
-                                            root.with_mut(|data| {
-                                                if let Some(Data::Array(arr)) = data.get_at_path_mut(&path_for_add) {
-                                                    let new_item = create_array_item_default(arr);
-                                                    arr.0.push(new_item);
-                                                }
-                                            });
-                                        },
-                                        "+ Add Item"
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-// ============================================================================
-// Object Field Editor (enables recursion)
-// ============================================================================
-
-/// Object field - iterates fields and renders child EditableDataView for each
-#[component]
-fn EditableObjectField(
-    root: Signal<Data<'static>>,
-    path: String,
-    did: String,
-    #[props(default)] remove_button: Option<Element>,
-) -> Element {
-    let path_for_memo = path.clone();
-    let field_keys = use_memo(move || {
-        root.read()
-            .get_at_path(&path_for_memo)
-            .and_then(|d| d.as_object())
-            .map(|obj| obj.0.keys().cloned().collect::<Vec<_>>())
-            .unwrap_or_default()
-    });
-
-    let is_root = path.is_empty();
-
-    rsx! {
-        if !is_root {
-            div { class: "record-section object-section",
-                Accordion {
-                    id: "edit-object-{path}",
-                    collapsible: true,
-                    AccordionItem {
-                        default_open: true,
-                        index: 0,
-                        AccordionTrigger {
-                            div { class: "section-header",
-                                div { class: "section-label",
-                                    {
-                                        let parts: Vec<&str> = path.split('.').collect();
-                                        let final_part = parts.last().unwrap_or(&"");
-                                        rsx! { "{final_part}" }
-                                    }
-                                }
-                                {remove_button}
-                            }
-                        }
-                        AccordionContent {
-                            div { class: "section-content",
-                                for key in field_keys() {
-                                {
-                                    let field_path = if path.is_empty() {
-                                        key.to_string()
-                                    } else {
-                                        format!("{}.{}", path, key)
-                                    };
-                                    let is_type_field = key == "$type";
-
-                                    rsx! {
-                                        FieldWithRemove {
-                                            key: "{field_path}",
-                                            root: root,
-                                            path: field_path.clone(),
-                                            did: did.clone(),
-                                            is_removable: !is_type_field,
-                                            parent_path: path.clone(),
-                                            field_key: key.clone(),
-                                        }
-                                    }
-                                }
-                                }
-
-                                AddFieldWidget { root: root, path: path.clone() }
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            for key in field_keys() {
-                {
-                    let field_path = key.to_string();
-                    let is_type_field = key == "$type";
-
-                    rsx! {
-                        FieldWithRemove {
-                            key: "{field_path}",
-                            root: root,
-                            path: field_path.clone(),
-                            did: did.clone(),
-                            is_removable: !is_type_field,
-                            parent_path: path.clone(),
-                            field_key: key.clone(),
-                        }
-                    }
-                }
-            }
-
-            AddFieldWidget { root: root, path: path.clone() }
-        }
-    }
-}
-
-/// Widget for adding new fields to objects
-#[component]
-fn AddFieldWidget(root: Signal<Data<'static>>, path: String) -> Element {
-    let mut field_name = use_signal(|| String::new());
-    let mut field_value = use_signal(|| String::new());
-    let mut error = use_signal(|| None::<String>);
-    let mut show_form = use_signal(|| false);
-
-    let path_for_enter = path.clone();
-    let path_for_button = path.clone();
-
-    rsx! {
-        div { class: "add-field-widget",
-            if !show_form() {
-                button {
-                    class: "add-button",
-                    onclick: move |_| show_form.set(true),
-                    "+ Add Field"
-                }
-            } else {
-                div { class: "add-field-form",
-                    input {
-                        r#type: "text",
-                        placeholder: "Field name",
-                        value: "{field_name}",
-                        oninput: move |evt| field_name.set(evt.value()),
-                    }
-                    input {
-                        r#type: "text",
-                        placeholder: r#"Value: {{}}, [], true, 123, "text""#,
-                        value: "{field_value}",
-                        oninput: move |evt| field_value.set(evt.value()),
-                        onkeydown: move |evt| {
-                            use dioxus::prelude::keyboard_types::Key;
-                            if evt.key() == Key::Enter {
-                                let name = field_name();
-                                let value_text = field_value();
-
-                                if name.is_empty() {
-                                    error.set(Some("Field name required".to_string()));
-                                    return;
-                                }
-
-                                let new_value = match infer_data_from_text(&value_text) {
-                                    Ok(data) => data,
-                                    Err(e) => {
-                                        error.set(Some(e));
-                                        return;
-                                    }
-                                };
-
-                                let mut new_data = root.read().clone();
-                                if let Some(Data::Object(obj)) = new_data.get_at_path_mut(path_for_enter.as_str()) {
-                                    obj.0.insert(name.into(), new_value);
-                                }
-                                root.set(new_data);
-
-                                // Reset form
-                                field_name.set(String::new());
-                                field_value.set(String::new());
-                                show_form.set(false);
-                                error.set(None);
-                            }
-                        }
-                    }
-                    button {
-                        class: "add-field-widget-edit",
-                        onclick: move |_| {
-                            let name = field_name();
-                            let value_text = field_value();
-
-                            if name.is_empty() {
-                                error.set(Some("Field name required".to_string()));
-                                return;
-                            }
-
-                            let new_value = match infer_data_from_text(&value_text) {
-                                Ok(data) => data,
-                                Err(e) => {
-                                    error.set(Some(e));
-                                    return;
-                                }
-                            };
-
-                            let mut new_data = root.read().clone();
-                            if let Some(Data::Object(obj)) = new_data.get_at_path_mut(path_for_button.as_str()) {
-                                obj.0.insert(name.into(), new_value);
-                            }
-                            root.set(new_data);
-
-                            // Reset form
-                            field_name.set(String::new());
-                            field_value.set(String::new());
-                            show_form.set(false);
-                            error.set(None);
-                        },
-                        "Add"
-                    }
-                    button {
-                        class: "add-field-widget-edit",
-                        onclick: move |_| {
-                            show_form.set(false);
-                            field_name.set(String::new());
-                            field_value.set(String::new());
-                            error.set(None);
-                        },
-                        "Cancel"
-                    }
-                    if let Some(err) = error() {
-                        div { class: "field-error", "❌ {err}" }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Layout component for record view - handles header, metadata, and wraps children
-#[component]
-fn RecordViewLayout(
-    uri: AtUri<'static>,
-    cid: Option<Cid<'static>>,
-    schema: ReadSignal<Option<LexiconDoc<'static>>>,
-    record_value: Data<'static>,
-    children: Element,
-) -> Element {
-    // Validate the record if schema is available
-    let validation_status = use_memo(move || {
-        let _schema_doc = schema()?;
-        let nsid_str = record_value.type_discriminator()?;
-
-        let validator = jacquard_lexicon::validation::SchemaValidator::global();
-        let result = validator.validate_by_nsid(nsid_str, &record_value);
-
-        Some(result.is_valid())
-    });
-
-    rsx! {
-        div {
-            class: "record-metadata",
-            div { class: "metadata-row",
-                span { class: "metadata-label", "URI" }
-                span { class: "metadata-value",
-                    HighlightedUri { uri: uri.clone() }
-                }
-            }
-            if let Some(cid) = cid {
-                div { class: "metadata-row",
-                    span { class: "metadata-label", "CID" }
-                    code { class: "metadata-value", "{cid}" }
-                }
-            }
-            if let Some(is_valid) = validation_status() {
-                div { class: "metadata-row",
-                    span { class: "metadata-label", "Schema" }
-                    span {
-                        class: if is_valid { "metadata-value schema-valid" } else { "metadata-value schema-invalid" },
-                        if is_valid { "Valid" } else { "Invalid" }
-                    }
-                }
-            }
-        }
-
-        {children}
-
-    }
-}
-
-/// Render some text as markdown.
-#[component]
-fn EditableRecordContent(
-    record_value: Data<'static>,
-    uri: ReadSignal<AtUri<'static>>,
-    view_mode: Signal<ViewMode>,
-    edit_mode: Signal<bool>,
-    record_resource: Resource<Result<GetRecordOutput<'static>, AgentError>>,
-    schema: ReadSignal<Option<LexiconDoc<'static>>>,
-) -> Element {
-    let mut edit_data = use_signal(use_reactive!(|record_value| record_value.clone()));
-    let nsid = use_memo(move || edit_data().type_discriminator().map(|s| s.to_string()));
-    let navigator = use_navigator();
-    let fetcher = use_context::<CachedFetcher>();
-
-    // Validate edit_data whenever it changes and provide via context
-    let mut validation_result = use_signal(|| None);
-    use_effect(move || {
-        let _ = schema(); // Track schema changes
-        if let Some(nsid_str) = nsid() {
-            let data = edit_data();
-            let validator = jacquard_lexicon::validation::SchemaValidator::global();
-            let result = validator.validate_by_nsid(&nsid_str, &data);
-            validation_result.set(Some(result));
-        }
-    });
-    use_context_provider(|| validation_result);
-
-    let update_fetcher = fetcher.clone();
-    let create_fetcher = fetcher.clone();
-    let replace_fetcher = fetcher.clone();
-    let delete_fetcher = fetcher.clone();
-
-    rsx! {
-        div {
-            class: "tab-bar",
-            button {
-                class: if view_mode() == ViewMode::Pretty { "tab-button active" } else { "tab-button" },
-                onclick: move |_| view_mode.set(ViewMode::Pretty),
-                "View"
-            }
-            button {
-                class: if view_mode() == ViewMode::Json { "tab-button active" } else { "tab-button" },
-                onclick: move |_| view_mode.set(ViewMode::Json),
-                "JSON"
-            }
-            button {
-                class: if view_mode() == ViewMode::Schema { "tab-button active" } else { "tab-button" },
-                onclick: move |_| view_mode.set(ViewMode::Schema),
-                "Schema"
-            }
-            ActionButtons {
-                on_update: move |_| {
-                    let fetcher = update_fetcher.clone();
-                    let uri = uri();
-                    let data = edit_data();
-                    spawn(async move {
-                        if let Some((did, _)) = fetcher.session_info().await {
-                            if let (Some(collection_str), Some(rkey)) = (uri.collection(), uri.rkey()) {
-                                let collection = Nsid::new(collection_str.as_str()).ok();
-                                if let Some(collection) = collection {
-                                    let request = PutRecord::new()
-                                        .repo(AtIdentifier::Did(did))
-                                        .collection(collection)
-                                        .rkey(rkey.clone())
-                                        .record(data.clone())
-                                        .build();
-
-                                    match fetcher.send(request).await {
-                                        Ok(output) => {
-                                            if output.status() == StatusCode::OK {
-                                                tracing::info!("Record updated successfully");
-                                                edit_data.set(data.clone());
-                                                edit_mode.set(false);
-                                            } else {
-                                                tracing::error!("Unexpected status code: {:?}", output.status());
-                                            }
-                                        }
-                                        Err(e) => {
-                                            tracing::error!("Failed to update record: {:?}", e);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    });
-                },
-                on_save_new: move |_| {
-                    let fetcher = create_fetcher.clone();
-                    let data = edit_data();
-                    let nav = navigator.clone();
-                    spawn(async move {
-                        if let Some((did, _)) = fetcher.session_info().await {
-                            if let Some(collection_str) = data.type_discriminator() {
-                                let collection = Nsid::new(collection_str).ok();
-                                if let Some(collection) = collection {
-                                    let request = CreateRecord::new()
-                                        .repo(AtIdentifier::Did(did))
-                                        .collection(collection)
-                                        .record(data.clone())
-                                        .build();
-
-                                    match fetcher.send(request).await {
-                                        Ok(response) => {
-                                            if let Ok(output) = response.into_output() {
-                                                tracing::info!("Record created: {}", output.uri);
-                                                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, output.uri);
-                                                nav.push(link);
-                                            }
-                                        }
-                                        Err(e) => {
-                                            tracing::error!("Failed to create record: {:?}", e);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    });
-                },
-                on_replace: move |_| {
-                    let fetcher = replace_fetcher.clone();
-                    let uri = uri();
-                    let data = edit_data();
-                    let nav = navigator.clone();
-                    spawn(async move {
-                        if let Some((did, _)) = fetcher.session_info().await {
-                            if let Some(new_collection_str) = data.type_discriminator() {
-                                let new_collection = Nsid::new(new_collection_str).ok();
-                                if let Some(new_collection) = new_collection {
-                                    // Create new record
-                                    let create_req = CreateRecord::new()
-                                        .repo(AtIdentifier::Did(did.clone()))
-                                        .collection(new_collection)
-                                        .record(data.clone())
-                                        .build();
-
-                                    match fetcher.send(create_req).await {
-                                        Ok(response) => {
-                                            if let Ok(create_output) = response.into_output() {
-                                                // Delete old record
-                                                if let (Some(old_collection_str), Some(old_rkey)) = (uri.collection(), uri.rkey()) {
-                                                    let old_collection = Nsid::new(old_collection_str.as_str()).ok();
-                                                    if let Some(old_collection) = old_collection {
-                                                        let delete_req = DeleteRecord::new()
-                                                            .repo(AtIdentifier::Did(did))
-                                                            .collection(old_collection)
-                                                            .rkey(old_rkey.clone())
-                                                            .build();
-
-                                                        if let Err(e) = fetcher.send(delete_req).await {
-                                                            tracing::warn!("Created new record but failed to delete old: {:?}", e);
-                                                        }
-                                                    }
-                                                }
-
-                                                tracing::info!("Record replaced: {}", create_output.uri);
-                                                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, create_output.uri);
-                                                nav.push(link);
-                                            }
-                                        }
-                                        Err(e) => {
-                                            tracing::error!("Failed to replace record: {:?}", e);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    });
-                },
-                on_delete: move |_| {
-                    let fetcher = delete_fetcher.clone();
-                    let uri = uri();
-                    let nav = navigator.clone();
-                    spawn(async move {
-                        if let Some((did, _)) = fetcher.session_info().await {
-                            if let (Some(collection_str), Some(rkey)) = (uri.collection(), uri.rkey()) {
-                                let collection = Nsid::new(collection_str.as_str()).ok();
-                                if let Some(collection) = collection {
-                                    let request = DeleteRecord::new()
-                                        .repo(AtIdentifier::Did(did))
-                                        .collection(collection)
-                                        .rkey(rkey.clone())
-                                        .build();
-
-                                    match fetcher.send(request).await {
-                                        Ok(_) => {
-                                            tracing::info!("Record deleted");
-                                            nav.push(Route::Home {});
-                                        }
-                                        Err(e) => {
-                                            tracing::error!("Failed to delete record: {:?}", e);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    });
-                },
-                on_cancel: move |_| {
-                    edit_data.set(record_value.clone());
-                    edit_mode.set(false);
-                },
-            }
-        }
-        div {
-            class: "tab-content",
-            match view_mode() {
-                ViewMode::Pretty => rsx! {
-                    div { class: "pretty-record",
-                        EditableDataView {
-                            root: edit_data,
-                            path: String::new(),
-                            did: uri().authority().to_string(),
-                        }
-                    }
-                },
-                ViewMode::Json => rsx! {
-                    JsonEditor { data: edit_data, nsid, schema }
-                },
-                ViewMode::Schema => rsx! {
-                    SchemaView { schema }
-                },
-            }
-        }
-    }
-}
-
-#[component]
-pub fn CodeView(props: CodeViewProps) -> Element {
-    let code = &*props.code.read();
-
-    let mut html_buf = String::new();
-    highlight_code(props.lang.as_deref(), code, &mut html_buf).unwrap();
-
-    rsx! {
-        document::Style { {generate_default_css().unwrap()}}
-        div {
-            id: "{&*props.id.read()}",
-            class: "{&*props.class.read()}",
-            dangerous_inner_html: "{html_buf}"
-        }
-    }
-}

crates/weaver-cli/Cargo.toml

···
 miette = { workspace = true, features = ["fancy"] }
 
 jacquard = { workspace = true, features = ["loopback", "dns"] }
-jacquard-api = { workspace = true, features = ["sh_weaver"] }
 
 markdown-weaver = { workspace = true }
 markdown-weaver-escape = { workspace = true }

crates/weaver-common/Cargo.toml

···
 n0-future = { workspace = true }
 weaver-api = { version = "0.1", path = "../weaver-api" }
 markdown-weaver = { workspace = true }
-#libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
-
 http = "1.3.1"
-
 jacquard = { workspace = true }
 jacquard-common = { workspace = true }
 trait-variant = "0.1"
-
 serde = { workspace = true }
 serde_json = { version = "1.0.140", features = ["preserve_order", "raw_value"] }
-serde_ipld_dagcbor = { version = "0.6.1", features = ["codec"] }
-serde_html_form = "0.2.7"
-serde_bytes = "0.11.17"
 tokio = { version = "1.44", features = ["sync"] }
-
-minijinja = { workspace = true, features = [
-  "builtins",
-  "debug",
-  "deserialization",
-  "macros",
-  "multi_template",
-  "adjacent_loop_items",
-  "std_collections",
-  "serde",
-] }
-
-
 miette = { workspace = true }
-owo-colors = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-reqwest = "0.12.15"
-regex = "1.11.1"
+reqwest = { version = "0.12", default-features = false, features = [
+    "json",
+    "rustls-tls",
+] }
+
 markdown-weaver-escape = { workspace = true, features = ["std"] }
 mime-sniffer = "^0.1"
 
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+regex = "1.11.1"
+
 # wasm-in-browser dependencies
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+regex-lite = { version = "0.1" }
 futures-util = "0.3"
 js-sys = "0.3"
 pin-project = "1"

crates/weaver-common/src/agent.rs

···
                         .map(|blob| {
                             let cid = blob.blob().cid();
                             jacquard::types::string::Uri::new_owned(format!(
-                                "https://cdn.bsky.app/img/avatar/plain/{}/{}",
+                                "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
                                 did, cid
                             ))
                         })
···
                         .map(|blob| {
                             let cid = blob.blob().cid();
                             jacquard::types::string::Uri::new_owned(format!(
-                                "https://cdn.bsky.app/img/banner/plain/{}/{}",
+                                "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
                                 did, cid
                             ))
                         })
···
                     .map(|blob| {
                         let cid = blob.blob().cid();
                         jacquard::types::string::Uri::new_owned(format!(
-                            "https://cdn.bsky.app/img/avatar/plain/{}/{}",
+                            "https://cdn.bsky.app/img/avatar/plain/{}/{}@jpeg",
                             did, cid
                         ))
                     })
···
                     .map(|blob| {
                         let cid = blob.blob().cid();
                         jacquard::types::string::Uri::new_owned(format!(
-                            "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}",
+                            "https://cdn.bsky.app/img/banner/plain/{}/{}@jpeg",
                             did, cid
                         ))
                     })

crates/weaver-common/src/error.rs

···
 pub enum ParseErrorKind {
     #[error(transparent)]
     SerdeError(#[from] SerDeError),
-    #[error(transparent)]
-    MiniJinjaError(#[from] minijinja::Error),
     #[error("error in markdown parsing or rendering: {0}")]
     MarkdownError(markdown_weaver::CowStr<'static>),
 }
···
     #[error(transparent)]
     #[diagnostic_source]
     Json(#[from] serde_json::Error),
-    #[error(transparent)]
-    DagCbor(#[from] serde_ipld_dagcbor::error::CodecError),
-    #[error(transparent)]
-    HtmlForm(#[from] serde_html_form::ser::Error),
 }
 
 impl From<serde_json::Error> for ParseError {

crates/weaver-index/Cargo.toml

···
 uuid = { version = "1.8.0", features = ["v7", "serde"] }
 
 jacquard = { workspace = true, features = ["websocket", "zstd"] }
-jacquard-api = { workspace = true, features = ["sh_weaver"] }
 jacquard-axum = { workspace = true }
 
 axum = "0.8"

crates/weaver-renderer/Cargo.toml

···
 weaver-api = { path = "../weaver-api" }
 jacquard.workspace = true
 markdown-weaver = { workspace = true }
-compact_string = "0.1.0"
 http = "1.3.1"
 url = "2.5.4"
 syntect = { workspace = true, default-features = false, features = ["default-fancy"]}
 markdown-weaver-escape = { workspace = true, features = ["std"] }
 thiserror.workspace = true
+tracing.workspace = true
 miette.workspace = true
 unicode-normalization = "0.1.24"
 yaml-rust2 = { version = "0.10.2" }
 bitflags = "2.9.1"
-tracing = "0.1"
-
 dashmap = "6.1.0"
-regex = "1.11.1"
 pin-utils = "0.1.0"
 pin-project = "1.1.10"
-dynosaur = "0.2.0"
 smol_str = { version = "0.3", features = ["serde"] }
 mime-sniffer = "0.1.3"
 reqwest = { version = "0.12.7", default-features = false, features = [
···
 ] }
 
 [target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+regex = { version = "1.12" }
 tokio = { version = "1.28", features = ["rt", "time"] }
 tokio-util = { version = "0.7.14", features = ["rt"] }
 ignore = "0.4.23"
+
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+regex-lite = { version = "0.1" }
 
 [dev-dependencies]
 insta = { version = "1.40", features = ["yaml"] }

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());
···
 /// - Bluesky list: `at://{actor}/app.bsky.graph.list/{rkey}` → `https://bsky.app/profile/{actor}/lists/{rkey}`
 /// - Bluesky feed: `at://{actor}/app.bsky.feed.generator/{rkey}` → `https://bsky.app/profile/{actor}/feed/{rkey}`
 /// - Bluesky starterpack: `at://{actor}/app.bsky.graph.starterpack/{rkey}` → `https://bsky.app/starter-pack/{actor}/{rkey}`
-/// - Weaver/other: `at://{actor}/{collection}/{rkey}` → `https://weaver.sh/{actor}/{collection}/{rkey}`
+/// - Weaver/other: `at://{actor}/{collection}/{rkey}` → `https://weaver.sh/record/{at_uri}`
 fn at_uri_to_web_url(at_uri: &AtUri<'_>) -> String {
     let authority = at_uri.authority().as_ref();
 
     // Profile-only link (no collection/rkey)
     if at_uri.collection().is_none() && at_uri.rkey().is_none() {
-        return format!("https://weaver.sh/{}", authority);
+        return format!("https://alpha.weaver.sh/{}", authority);
     }
 
     // Record link
···
             }
             // Weaver records and unknown collections go to weaver.sh
             _ => {
-                format!(
-                    "https://weaver.sh/{}/{}/{}",
-                    authority, collection_str, rkey_str
-                )
+                format!("https://alpha.weaver.sh/record/{}", at_uri)
             }
         }
     } else {
         // Fallback for malformed URIs
-        format!("https://weaver.sh/{}", authority)
+        format!("https://alpha.weaver.sh/{}", authority)
     }
 }
 

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

···
     Body,
 }
 
-impl<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E: EmbedContentProvider> ClientWriter<'a, I, W, E> {
+impl<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E: EmbedContentProvider>
+    ClientWriter<'a, I, W, E>
+{
     pub fn new(events: I, writer: W) -> Self {
         Self {
             events,
···
             Tag::Superscript => self.write("<sup>"),
             Tag::Emphasis => self.write("<em>"),
             Tag::Strong => self.write("<strong>"),
-            Tag::Strikethrough => self.write("<del>"),
+            Tag::Strikethrough => self.write("<s>"),
             Tag::Link {
                 link_type: LinkType::Email,
                 dest_url,
···
             TagEnd::Superscript => self.write("</sup>"),
             TagEnd::Subscript => self.write("</sub>"),
             TagEnd::Strong => self.write("</strong>"),
-            TagEnd::Strikethrough => self.write("</del>"),
+            TagEnd::Strikethrough => self.write("</s>"),
             TagEnd::Link => self.write("</a>"),
             TagEnd::Image => Ok(()), // No-op: raw_text() already consumed the End(Image) event
             TagEnd::Embed => Ok(()),
···
     }
 }
 
-impl<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E: EmbedContentProvider> ClientWriter<'a, I, W, E> {
+impl<'a, I: Iterator<Item = Event<'a>>, W: StrWrite, E: EmbedContentProvider>
+    ClientWriter<'a, I, W, E>
+{
     fn write_embed(
         &mut self,
         embed_type: EmbedType,

crates/weaver-renderer/src/lib.rs

···
 use yaml_rust2::Yaml;
 use yaml_rust2::YamlLoader;
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use regex::Regex;
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use regex_lite::Regex;
+
 use std::iter::Iterator;
 use std::path::PathBuf;
 use std::pin::Pin;

crates/weaver-renderer/src/types.rs

···
-use compact_string::CompactString;
 use http::Uri;
+use smol_str::SmolStr;
 use weaver_common::jacquard::types::string::{Cid, Did};
 
 pub struct Link<'a> {
···
     pub blob: BlobLink<'a>,
 }
 
-pub type MimeType = CompactString;
+pub type MimeType = SmolStr;
 
 pub enum BlobLink<'a> {
     PDS {

crates/weaver-renderer/src/utils.rs

···
 use markdown_weaver::{CodeBlockKind, CowStr, Event, Tag};
 use miette::IntoDiagnostic;
 use n0_future::TryFutureExt;
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use regex::Regex;
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use regex_lite::Regex;
+
 use markdown_weaver::BrokenLink;
 use std::path::PathBuf;
 use std::sync::Arc;

flake.nix

···
             dioxus-cli
             wasm-bindgen-cli
             wasm-pack
+            twiggy
             binaryen.out
           ];
         };

weaver_notes/.obsidian/workspace.json

···
             "state": {
               "type": "markdown",
               "state": {
-                "file": "bug notes.md",
+                "file": "Why I rewrote pdsls in Rust (tm).md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "bug notes"
+              "title": "Why I rewrote pdsls in Rust (tm)"
             }
           }
         ],
···
   },
   "active": "6029beecc3d03bce",
   "lastOpenFiles": [
+    "light_mode_excerpt.png",
+    "notebook_entry_preview.png",
+    "xkcd_345_excerpt.png",
     "bug notes.md",
     "Why I rewrote pdsls in Rust (tm).md",
     "meta.png",
···
     "pretty_editor.png",
     "Arch.md",
     "Weaver - Long-form writing.md",
-    "weaver_photo_med.jpg",
-    "xkcd_345_excerpt.png",
-    "light_mode_excerpt.png"
+    "weaver_photo_med.jpg"
   ]
 }

weaver_notes/bug notes.md

···
-- renderer/processor doesn't add http(s):// to urls without them (or handle autolinks currently)
-- mobile view doesn't narrow correctly
--