fixed lexicon resolution, styling

Cargo.lock

···
 [[package]]
 name = "jacquard"
 version = "0.9.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
···
 [[package]]
 name = "jacquard-api"
 version = "0.9.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-axum"
 version = "0.9.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "axum",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.9.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.9.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.9.1"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.9.1"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "cid",
  "dashmap",
···
 [[package]]
 name = "jacquard-oauth"
 version = "0.9.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#5c79bb76de544cbd4fa8d5d8b01ba6e828f8ba65"
 dependencies = [
  "base64 0.22.1",
  "bytes",

Cargo.toml

···
 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-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 = { 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-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-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/crates/jacquard", default-features = false, features = ["derive", "api_bluesky", "tracing"] }
+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 }
 
 [profile]
 

crates/weaver-app/Cargo.toml

···
 dashmap = "6.1.0"
 
 dioxus = { version = "0.7.1", features = ["router"] }
+#dioxus-router = { version = "0.7.1", features = ["wasm-split"] }
 weaver-common = { path = "../weaver-common" }
 jacquard = { workspace = true, features = ["streaming"] }
 jacquard-lexicon = { workspace = true }
···
 serde_html_form = "0.2.8"
 webbrowser = "1.0.6"
 tracing.workspace = true
-
-
 
 
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]

crates/weaver-app/assets/styling/record-view.css

···
 .record-view-container {
-    font-family: var(--font-mono);
     max-width: 1200px;
     margin: 2rem auto;
     padding: 0 1rem;
···
 .record-header {
     margin-bottom: 2rem;
     padding-bottom: 0.5rem;
+
+    font-family: var(--font-mono);
     border-bottom: 1px solid var(--color-border);
 }
 
···
 }
 
 .metadata-label {
+    font-family: var(--font-mono);
     color: var(--color-subtle);
     font-size: 0.85rem;
     text-transform: uppercase;
···
     border-bottom-color: var(--color-error, #ff6b6b);
 }
 
-.record-field input[type="checkbox"] {
-    width: 1.1rem;
-    height: 1.1rem;
-    margin-top: 0.3rem;
-    margin-bottom: 0.3rem;
+.boolean-toggle {
+    font-family: var(--font-mono);
+    font-size: 0.9rem;
+    color: var(--color-text);
+    background: var(--color-surface);
+    border: 1px solid var(--color-border);
+    padding: 0.25rem 0.25rem;
+    margin-right: 0.5rem;
+    margin-bottom: 0.2rem;
     cursor: pointer;
-    accent-color: var(--color-primary);
+    transition:
+        background-color 0.2s,
+        border-color 0.2s;
+}
+
+.boolean-toggle-false {
+    color: var(--color-error);
+    border: 1px solid var(--color-error);
+}
+
+.boolean-toggle-true {
+    border: 1px solid var(--color-success);
+}
+
+.boolean-toggle:hover {
+    border: 1px solid var(--color-primary);
+    background-color: var(--color-primary);
+    color: var(--color-surface);
 }
 
 .field-error {

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

···
             use crate::Route;
             use gloo_storage::Storage;
             let full_route = use_route::<Route>();
-            gloo_storage::LocalStorage::set("cached_route", format!("{}", full_route));
+            gloo_storage::LocalStorage::set("cached_route", format!("{}", full_route)).ok();
         }
 
         use_effect(move || {

crates/weaver-app/src/data.rs

···
 use dioxus::prelude::*;
 #[cfg(feature = "fullstack-server")]
 #[allow(unused_imports)]
-use dioxus::{fullstack::extract::Extension, CapturedError};
+use dioxus::{CapturedError, fullstack::extract::Extension};
 use jacquard::types::{did::Did, string::Handle};
 #[allow(unused_imports)]
 use jacquard::{
···
 };
 #[allow(unused_imports)]
 use std::sync::Arc;
-use weaver_api::sh_weaver::notebook::{entry::Entry, BookEntryView};
+use weaver_api::sh_weaver::notebook::{BookEntryView, entry::Entry};
 // ============================================================================
 // Wrapper Hooks (feature-gated)
 // ============================================================================
···
 async fn render_markdown_impl(content: Entry<'static>, did: Did<'static>) -> String {
     use n0_future::stream::StreamExt;
     use weaver_renderer::{
-        atproto::{ClientContext, ClientWriter},
         ContextIterator, NotebookProcessor,
+        atproto::{ClientContext, ClientWriter},
     };
 
     let ctx = ClientContext::<()>::new(content.clone(), did);

crates/weaver-app/src/main.rs

···
           #[layout(RecordIndex)]
             #[route("/:..uri")]
             RecordView { uri: Vec<String> },
-          #[end_layout]
+                     #[end_layout]
         #[end_nest]
         #[route("/callback?:state&:iss&:code")]
         Callback { state: SmolStr, iss: SmolStr, code: SmolStr },

crates/weaver-app/src/service_worker.rs

···
 
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use wasm_bindgen_futures::JsFuture;
-
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use web_sys::{RegistrationOptions, ServiceWorkerContainer, Window};
 

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

···
 use humansize::format_size;
 use jacquard::api::com_atproto::repo::get_record::GetRecordOutput;
 use jacquard::client::AgentError;
+use jacquard::common::to_data;
 use jacquard::prelude::*;
 use jacquard::smol_str::ToSmolStr;
 use jacquard::{
···
     identity::lexicon_resolver::LexiconSchemaResolver,
     types::{aturi::AtUri, cid::Cid, ident::AtIdentifier, string::Nsid},
 };
+use jacquard_lexicon::lexicon::LexiconDoc;
 use mime_sniffer::MimeTypeSniffer;
 use weaver_api::com_atproto::repo::{
     create_record::CreateRecord, delete_record::DeleteRecord, put_record::PutRecord,
···
 enum ViewMode {
     Pretty,
     Json,
+    Schema,
 }
 
 #[component]
 pub fn RecordIndex() -> Element {
     let navigator = use_navigator();
     let mut uri_input = use_signal(|| String::new());
-
     let handle_uri_submit = move || {
         let input_uri = uri_input.read().clone();
         if !input_uri.is_empty() {
···
         async move { client.fetch_record_slingshot(&*uri.read()).await }
     });
 
+    // Fetch schema for the record
+    let schema_resource = use_resource(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            let record_read = record_resource.read();
+            let record = record_read.as_ref()?.as_ref().ok()?;
+
+            let validator = jacquard_lexicon::validation::SchemaValidator::global();
+            let main_type = record.value.type_discriminator();
+            let mut main_schema = None;
+
+            // Find and resolve all schemas (including main and nested)
+            for type_val in record.value.query("...$type").values() {
+                if let Some(type_str) = type_val.as_str() {
+                    // Skip non-NSID types (like "blob")
+                    if !type_str.contains('.') {
+                        continue;
+                    }
+
+                    if let Ok(nsid) = Nsid::new(type_str) {
+                        // Fetch and register schema
+                        if let Ok(schema) = fetcher.resolve_lexicon_schema(&nsid).await {
+                            validator
+                                .registry()
+                                .insert(nsid.to_smolstr(), schema.doc.clone());
+
+                            // Keep the main record schema
+                            if Some(type_str) == main_type {
+                                main_schema = Some(schema.doc);
+                            }
+                        }
+                    }
+                }
+            }
+
+            main_schema
+        }
+    });
+
+    let schema_signal = use_memo(move || schema_resource.read().clone().flatten());
+
     // Check ownership for edit access
     let auth_state = use_context::<Signal<AuthState>>();
     let is_owner = use_memo(move || {
···
                             view_mode: view_mode,
                             edit_mode: edit_mode,
                             record_resource: record_resource,
+                            schema: schema_signal,
                         }
                     } else {
                         div {
···
                                 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"
+                            }
                             if is_owner() {
                                 button {
                                     class: "tab-button edit-button",
···
                                             lang: Some("json".to_string()),
                                         }
                                     }
+                                },
+                                ViewMode::Schema => rsx! {
+                                    SchemaView { schema: schema_signal }
                                 },
                             }
                         }
···
         }
     }
 }
+
+#[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() {
+            rsx! {
+                div {
+                    class: "pretty-record",
+                    DataView { 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..." }
+        }
+    }
+}
 fn get_hex_rep(byte_array: &mut [u8]) -> String {
     let build_string_vec: Vec<String> = byte_array
         .chunks(2)
···
 }
 
 #[component]
-fn JsonEditor(data: Signal<Data<'static>>, nsid: ReadSignal<Option<String>>) -> Element {
+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 mut parse_error = use_signal(|| None::<String>);
 
     let height = use_memo(move || {
         let line_count = json_text().lines().count();
···
         format!("{}px", lines * 22 + 32)
     });
 
-    let fetcher = use_context::<CachedFetcher>();
-
     let validation = use_resource(move || {
         let text = json_text();
         let nsid_val = nsid();
-        let fetcher = fetcher.clone();
+        let _ = schema(); // Track schema changes
 
         async move {
             // Only validate if we have an NSID
···
                 }
             };
 
-            // Resolve lexicon if needed
-            let registry = jacquard_lexicon::schema::SchemaRegistry::from_inventory();
-            if registry.get(&nsid_str).is_none() {
-                let nsid_str = nsid_str.split('#').next();
-                if let Some(Ok(nsid_parsed)) = nsid_str.map(|s| Nsid::new(s)) {
-                    if let Ok(schema) = fetcher.resolve_lexicon_schema(&nsid_parsed).await {
-                        registry.insert(nsid_parsed.to_smolstr(), schema.doc);
-                    }
-                }
-            }
-
-            // Validate
-            let validator = jacquard_lexicon::validation::SchemaValidator::from_registry(registry);
+            // 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))
···
     }
 }
 
-/// Boolean field (checkbox)
+/// Boolean field (toggle button)
 #[component]
 fn EditableBooleanField(
     root: Signal<Data<'static>>,
···
                 PathLabel { path: path.clone() }
                 {remove_button}
             }
-            input {
-                r#type: "checkbox",
-                checked: current_value(),
-                onchange: move |evt| {
+            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()) {
-                            *target = Data::Boolean(evt.checked());
+                            if let Some(bool_val) = target.as_boolean() {
+                                *target = Data::Boolean(!bool_val);
+                            }
                         }
                     });
-                }
+                },
+                "{current_value()}"
             }
         }
     }
···
     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()));
···
                 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 |_| {
···
                     }
                 },
                 ViewMode::Json => rsx! {
-                    JsonEditor { data: edit_data, nsid }
+                    JsonEditor { data: edit_data, nsid, schema }
+                },
+                ViewMode::Schema => rsx! {
+                    SchemaView { schema }
                 },
             }
         }