few fixes, incl css

Cargo.lock

···
 ]
 
 [[package]]
-name = "accessory"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28e416a3ab45838bac2ab2d81b1088d738d7b2d2c5272a54d39366565a29bd80"
-dependencies = [
- "macroific",
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "addr2line"
 version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "pin-project-lite",
  "tokio",
 ]
+
+[[package]]
+name = "async-once-cell"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288f83726785267c6f2ef073a3d83dc3f9b81464e9f99898240cced85fce35a"
 
 [[package]]
 name = "async-recursion"
···
 ]
 
 [[package]]
-name = "delegate-display"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9926686c832494164c33a36bf65118f4bd6e704000b58c94681bf62e9ad67a74"
-dependencies = [
- "impartial-ord",
- "itoa",
- "macroific",
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "der"
 version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "serde",
  "subsecond",
  "warnings",
+ "wasm-splitter",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "fancy_constructor"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a27643a5d05f3a22f5afd6e0d0e6e354f92d37907006f97b84b9cb79082198"
-dependencies = [
- "macroific",
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "fastrand"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "impartial-ord"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab604ee7085efba6efc65e4ebca0e9533e3aff6cb501d7d77b211e3a781c6d5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
-name = "indexed_db_futures"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69ff41758cbd104e91033bb53bc449bec7eea65652960c81eddf3fc146ecea19"
-dependencies = [
- "accessory",
- "cfg-if",
- "delegate-display",
- "derive_more 2.0.1",
- "fancy_constructor",
- "indexed_db_futures_macros_internal",
- "js-sys",
- "sealed",
- "smallvec",
- "thiserror 2.0.17",
- "tokio",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "indexed_db_futures_macros_internal"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "caeba94923b68f254abef921cea7e7698bf4675fdd89d7c58bf1ed885b49a27d"
-dependencies = [
- "macroific",
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
+ "gloo-storage",
  "http",
  "jacquard-api",
  "jacquard-common",
···
  "jacquard-oauth",
  "jose-jwk",
  "miette 7.6.0",
- "n0-future",
  "regex",
  "reqwest",
  "serde",
···
  "jacquard-lexicon",
  "miette 7.6.0",
  "mini-moka",
- "n0-future",
  "percent-encoding",
  "reqwest",
  "serde",
···
  "jose-jwa",
  "jose-jwk",
  "miette 7.6.0",
- "n0-future",
  "p256",
  "rand 0.8.5",
  "rouille",
···
 checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
+name = "lol_alloc"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e5106554cabc97552dcadf54f57560ae6af3276652f82ca2be06120dc4c5dc"
+dependencies = [
+ "spin 0.9.8",
+]
+
+[[package]]
 name = "longest-increasing-subsequence"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "macroific"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89f276537b4b8f981bf1c13d79470980f71134b7bdcc5e6e911e910e556b0285"
-dependencies = [
- "macroific_attr_parse",
- "macroific_core",
- "macroific_macro",
-]
-
-[[package]]
-name = "macroific_attr_parse"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad4023761b45fcd36abed8fb7ae6a80456b0a38102d55e89a57d9a594a236be9"
-dependencies = [
- "proc-macro2",
- "quote",
- "sealed",
- "syn 2.0.110",
-]
-
-[[package]]
-name = "macroific_core"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a7594d3c14916fa55bef7e9d18c5daa9ed410dd37504251e4b75bbdeec33e3"
-dependencies = [
- "proc-macro2",
- "quote",
- "sealed",
- "syn 2.0.110",
-]
-
-[[package]]
-name = "macroific_macro"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4da6f2ed796261b0a74e2b52b42c693bb6dee1effba3a482c49592659f824b3b"
-dependencies = [
- "macroific_attr_parse",
- "macroific_core",
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "malloc_buf"
 version = "0.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "sealed"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22f968c5ea23d555e670b449c1c5e7b2fc399fdaec1d304a17cd48e288abc107"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.110",
-]
-
-[[package]]
 name = "sec1"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35c6d746902bca4ddf16592357eacf0473631ea26b36072f0dd0b31fa5ccd1f4"
 dependencies = [
- "indexed_db_futures",
  "js-sys",
  "once_cell",
  "thiserror 2.0.17",
···
 ]
 
 [[package]]
+name = "wasm-split-macro"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a12f9d65e85c7ea30ad753fd6c84e5e7a0ff9e581e1ed1860d173807018f955"
+dependencies = [
+ "base16",
+ "digest",
+ "proc-macro2",
+ "quote",
+ "sha2",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "wasm-splitter"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e0bdc944727dcfb8cb919213d19f2946b508370740bf7c1c6e215acd98dd5b4"
+dependencies = [
+ "async-once-cell",
+ "wasm-split-macro",
+]
+
+[[package]]
 name = "wasm-streams"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "chrono",
  "console_error_panic_hook",
  "dashmap",
- "diesel",
- "diesel_migrations",
  "dioxus",
  "dioxus-free-icons",
- "dioxus-logger",
  "dioxus-primitives",
  "dotenvy",
  "gloo-storage",
- "hex_fmt",
  "http",
  "humansize",
  "jacquard",
  "jacquard-axum",
  "jacquard-lexicon",
  "js-sys",
+ "lol_alloc",
  "markdown-weaver",
  "mime-sniffer",
  "mini-moka",
···
  "serde",
  "serde_html_form",
  "serde_json",
- "sqlite-wasm-rs",
  "time",
  "tokio",
  "tracing",

Cargo.toml

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

crates/weaver-app/Cargo.toml

···
 default = ["web", "fullstack-server", "no-app-index"]
 # Fullstack mode with SSR and server functions
 fullstack-server = ["dioxus/fullstack"]
+wasm-split = ["dioxus/wasm-split"]
 no-app-index = []
 
 web = ["dioxus/web"]
···
 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 = { workspace = true}#, features = ["streaming"] }
 jacquard-lexicon = { workspace = true }
 jacquard-axum = { workspace = true, optional = true }
-weaver-api = { path = "../weaver-api", features = ["streaming"] }
+weaver-api = { path = "../weaver-api"}#, features = ["streaming"] }
 markdown-weaver = { workspace = true }
 weaver-renderer = { path = "../weaver-renderer" }
 mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d" }
···
 axum = {version = "0.8.6", optional = true}
 mime-sniffer = {version = "^0.1"}
 chrono = { version = "0.4" }
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0"} #, features = ["derive"] }
 serde_json = "1.0"
-hex_fmt = "0.3"
 humansize = "2.0.0"
 base64 = "0.22"
 http = "1.3"
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
 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"] }
+# 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"] }
-dioxus-logger = "0.7.1"
 serde_html_form = "0.2.8"
-webbrowser = "1.0.6"
 tracing.workspace = true
 
+[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
+webbrowser = "1.0.6"
 
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
-sqlite-wasm-rs = { version = "0.4", default-features = false, features = ["precompiled", "relaxed-idb"] }
+#sqlite-wasm-rs = { version = "0.4", default-features = false, features = ["precompiled", "relaxed-idb"] }
 time = { version = "0.3", features = ["wasm-bindgen"] }
 console_error_panic_hook = "0.1"
 mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d", features = ["js"] }
···
 web-sys = { version = "0.3", features = ["ServiceWorkerContainer", "ServiceWorker", "ServiceWorkerRegistration", "RegistrationOptions", "Window", "Navigator", "MessageEvent", "console", "Document", "Element", "HtmlImageElement"] }
 js-sys = "0.3"
 gloo-storage = "0.3"
+lol_alloc = "0.4.1"
 
 [build-dependencies]
 dotenvy = "0.15.7"

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

···
     max-width: calc(90ch + 400px + 4rem); /* content + gutters + gaps */
     margin: 0 auto;
     padding: 0 1rem 0 0;
+    box-sizing: border-box;
 }
 
 /* Main content area */
···
     background: var(--color-surface);
 }
 
-/* Responsive layout */
+/* Responsive layout - Tablet/small desktop */
 @media (max-width: 1400px) {
     .entry-page-layout {
         grid-template-columns: 1fr;
···
         order: 1;
     }
 }
+
+/* Tablet and smaller */
+@media (max-width: 900px) {
+    .entry-page-layout {
+        max-width: 100%;
+        grid-template-columns: minmax(0, 1fr);
+    }
+}
+
+/* Small mobile phones */
+@media (max-width: 480px) {
+    .entry-content-main {
+        padding: 1rem 0.75rem;
+    }
+
+    .nav-gutter {
+        padding: 0 0.75rem;
+    }
+
+    .nav-button {
+        padding: 0.75rem;
+    }
+
+    .entry-metadata {
+        margin-bottom: 1rem;
+        padding-bottom: 0.75rem;
+    }
+
+    .entry-title {
+        font-size: 1.65rem;
+        margin-top: 0.5rem;
+        margin-bottom: 0.75rem;
+    }
+
+    .entry-meta-info {
+        gap: 0.75rem;
+        font-size: 0.85rem;
+    }
+}

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

···
 
 .accordion-content {
     grid-template-rows: 1fr;
-    padding-left: 2.8rem;
+    padding-left: 46px;
 }
 
 .accordion-content .section-content {
···
 }
 
 .accordion {
-    margin-left: -2.8rem;
+    margin-left: -46px;
 }

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

···
     use crate::fetch::CachedFetcher;
     use dioxus::prelude::*;
     use gloo_storage::{LocalStorage, Storage};
+    use jacquard::types::string::Did;
     // Look for session keys in localStorage (format: oauth_session_{did}_{session_id})
     let keys = LocalStorage::get_all::<serde_json::Value>()?;
     let mut found_session: Option<(String, String)> = None;
···
 
     let (did_str, session_id) =
         found_session.ok_or(CapturedError::from_display("No saved session found"))?;
-    let did = jacquard::types::string::Did::new_owned(did_str)?;
+    let did = Did::new_owned(did_str)?;
     let fetcher = use_context::<CachedFetcher>();
 
     let session = fetcher
···
         .set_authenticated(restored_did, session_id);
     fetcher.upgrade_to_authenticated(session).await;
 
-    dioxus_logger::tracing::debug!("session restored");
+    tracing::debug!("session restored");
     Ok(())
 }

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

···
                     Ok(Some(data))
                 }
                 Err(gloo_storage::errors::StorageError::KeyNotFound(err)) => {
-                    dioxus_logger::tracing::debug!("gloo error: {}", err);
+                    tracing::debug!("gloo error: {}", err);
                     Ok(None)
                 }
                 Err(e) => Err(SessionStoreError::Other(

crates/weaver-app/src/fetch.rs

···
 use crate::auth::AuthStore;
 use crate::cache_impl;
 use dioxus::Result;
-use dioxus::prelude::*;
 use jacquard::AuthorizationToken;
 use jacquard::CowStr;
 use jacquard::IntoStatic;
···
         }
     }
 
+    #[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() {

crates/weaver-app/src/main.rs

···
 use dioxus::fullstack::FullstackContext;
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
 use dioxus::fullstack::response::Extension;
-use dioxus_logger::tracing::Level;
-use jacquard::{
-    oauth::{client::OAuthClient, session::ClientData},
-    types::aturi::AtUri,
-};
+use jacquard::oauth::{client::OAuthClient, session::ClientData};
 #[allow(unused)]
 use jacquard::{
     smol_str::SmolStr,
···
 };
 #[cfg(feature = "server")]
 use std::sync::Arc;
-use std::sync::{LazyLock, Mutex};
+use std::sync::LazyLock;
 #[allow(unused)]
 use views::{
     Callback, Home, Navbar, Notebook, NotebookIndex, NotebookPage, RecordIndex, RecordView,
···
 /// Define a views module that contains the UI for all Layouts and Routes for our app.
 mod views;
 
-/// The Route enum is used to define the structure of internal routes in our app. All route enums need to derive
-/// the [`Routable`] trait, which provides the necessary methods for the router to work.
-///
-/// Each variant represents a different URL pattern that can be matched by the router. If that pattern is matched,
-/// the components for that route will be rendered.
+#[cfg(target_arch = "wasm32")]
+use lol_alloc::{FreeListAllocator, LockedAllocator};
+
+#[cfg(target_arch = "wasm32")]
+#[global_allocator]
+static ALLOCATOR: LockedAllocator<FreeListAllocator> =
+    LockedAllocator::new(FreeListAllocator::new());
+
 #[derive(Debug, Clone, Routable, PartialEq)]
 #[rustfmt::skip]
 enum Route {
-    // The layout attribute defines a wrapper for all routes under the layout. Layouts are great for wrapping
-    // many routes with a common UI like a navbar.
     #[layout(Navbar)]
-        // The route attribute defines the URL pattern that a specific route matches. If that pattern matches the URL,
-        // the component for that route will be rendered. The component name that is rendered defaults to the variant name.
         #[route("/")]
         Home {},
         #[layout(ErrorLayout)]
···
                 Entry { ident: AtIdentifier<'static>, book_title: SmolStr, title: SmolStr }
 
 }
-
-// We can import assets in dioxus with the `asset!` macro. This macro takes a path to an asset relative to the crate root.
-// The macro returns an `Asset` type that will display as the path to the asset in the browser or a local path in desktop bundles.
 const FAVICON: Asset = asset!("/assets/weaver_photo_sm.jpg");
-// The asset macro also minifies some assets like CSS and JS to make bundled smaller
 const MAIN_CSS: Asset = asset!("/assets/styling/main.css");
 
 #[cfg(not(feature = "fullstack-server"))]
···
     oauth: OAuthConfig::from_env().as_metadata(),
 });
 fn main() {
-    dioxus_logger::init(Level::DEBUG).expect("logger failed to init");
     // Set up better panic messages for wasm
     #[cfg(target_arch = "wasm32")]
     console_error_panic_hook::set_once();
···
                     async move {
                         req.extensions_mut().insert(blob_cache);
                         req.extensions_mut().insert(fetcher);
-
-                        // And then return the response with `next.run()
                         Ok::<_, Infallible>(next.run(req).await)
                     }
                 }
             }))
         };
-        // And then return the router
         Ok(router)
     });
 
-    // When not on the server, just run `launch()` like normal
     #[cfg(not(feature = "server"))]
     dioxus::launch(App);
 }
···
     use_effect(move || {
         spawn(async move {
             if let Err(e) = auth::restore_session().await {
-                dioxus_logger::tracing::warn!("Session restoration failed: {}", e);
+                tracing::warn!("Session restoration failed: {}", e);
             }
         });
     });
 
-    // Register service worker on startup (only on web)
     #[cfg(all(
         target_family = "wasm",
         target_os = "unknown",

crates/weaver-app/src/service_worker.rs

···
+use dioxus::prelude::*;
 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
 use wasm_bindgen::prelude::*;
 
···
 ) -> Result<(), String> {
     Ok(())
 }
+
+// #[used]
+// static BINDINGS_JS: Asset = asset!("/assets/sw.js", AssetOptions::js().with_hash_suffix(false));

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

···
 use crate::auth::AuthState;
 use crate::fetch::CachedFetcher;
-use dioxus::logger::tracing::{Level, error, info};
-use dioxus::{CapturedError, prelude::*};
+use dioxus::prelude::*;
 use jacquard::{
     IntoStatic,
     cowstr::ToCowStr,
     oauth::{error::OAuthError, types::CallbackParams},
     smol_str::SmolStr,
 };
+use tracing::{error, info};
 
 #[component]
 pub fn Callback(
···
 
     match &*result.read_unchecked() {
         Some(Ok(())) => {
-            // #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-            // {
-            //     if let Some(window) = web_sys::window() {
-            //         window.close().ok();
-            //     }
-            // }
-            #[cfg(target_arch = "wasm32")]
+            #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
             {
                 use gloo_storage::Storage;
                 let mut prev = gloo_storage::LocalStorage::get::<String>("cached_route").ok();
                 if let Some(prev) = prev.take() {
-                    dioxus_logger::tracing::info!("Navigating to previous page");
+                    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

···
 use crate::{Route, components::identity::NotebookCard, fetch};
 use dioxus::prelude::*;
-use jacquard::{IntoStatic, smol_str::ToSmolStr, types::aturi::AtUri};
+use jacquard::types::aturi::AtUri;
 
 const NOTEBOOK_CARD_CSS: Asset = asset!("/assets/styling/notebook-card.css");
 

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

···
 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 jacquard::common::to_data;
-use jacquard::prelude::*;
 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},
···
 }
 
 #[component]
-fn HighlightedString(string_type: jacquard::types::string::AtprotoStr<'static>) -> Element {
+fn HighlightedString(string_type: AtprotoStr<'static>) -> Element {
     use jacquard::types::string::AtprotoStr;
 
     match &string_type {
···
     Index(usize),
 }
 
-/// Check if a validation path matches or is a child of the given UI path
-/// Filters out UnionVariant segments from validation path for comparison
-fn validation_path_matches_ui(validation_path: &ValidationPath, ui_path: &str) -> bool {
-    use jacquard_lexicon::validation::PathSegment;
-
-    let ui_segments = parse_ui_path(ui_path);
-
-    // Convert validation path to UI segments by filtering out UnionVariant
-    let validation_ui_segments: Vec<_> = validation_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, // Skip union discriminators
-        })
-        .collect();
-
-    // Check if validation path matches or is a child of UI path
-    if validation_ui_segments.len() < ui_segments.len() {
-        return false; // Validation path can't be shorter than UI path
-    }
-
-    // Check if all UI segments match the start of validation segments
-    ui_segments
-        .iter()
-        .zip(validation_ui_segments.iter())
-        .all(|(a, b)| a == b)
-}
-
 /// Get all validation errors at exactly this path (not children)
 fn get_errors_at_exact_path(
     validation_result: &Option<ValidationResult>,
···
 /// Parse text as specific AtprotoStr type, preserving type information
 fn try_parse_as_type(
     text: &str,
-    string_type: jacquard::types::LexiconStringType,
-) -> Result<jacquard::types::string::AtprotoStr<'static>, String> {
-    use jacquard::types::LexiconStringType;
+    string_type: LexiconStringType,
+) -> Result<AtprotoStr<'static>, String> {
     use jacquard::types::string::*;
     use std::str::FromStr;
 
···
             }
             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(
···
                 .into_static(),
             )
         }
-
-        Data::Bytes(_) | Data::CidLink(_) | Data::Null => Data::Null,
+        Data::CidLink(_) => Data::CidLink(Cid::str(
+            "bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        )),
+        Data::Bytes(_) => Data::Bytes(Bytes::new()),
+        Data::Null => Data::Null,
     }
 }
 
···
     });
 
     let path_for_mutation = path.clone();
-    let handle_input = move |evt: dioxus::prelude::Event<dioxus::prelude::FormData>| {
+    let handle_input = move |evt: Event<FormData>| {
         let new_text = evt.value();
         input_text.set(new_text.clone());
 
···
 
     let fetcher = use_context::<CachedFetcher>();
     let path_for_upload = path.clone();
-    let handle_file = move |evt: dioxus::prelude::Event<dioxus::prelude::FormData>| {
+    let handle_file = move |evt: Event<dioxus::prelude::FormData>| {
         let fetcher = fetcher.clone();
         let path_upload_clone = path_for_upload.clone();
         spawn(async move {
···
     };
 
     let path_for_cid = path.clone();
-    let handle_cid_change = move |evt: dioxus::prelude::Event<dioxus::prelude::FormData>| {
+    let handle_cid_change = move |evt: Event<dioxus::prelude::FormData>| {
         let text = evt.value();
         cid_input.set(text.clone());
 
···
     };
 
     let path_for_size = path.clone();
-    let handle_size_change = move |evt: dioxus::prelude::Event<dioxus::prelude::FormData>| {
+    let handle_size_change = move |evt: Event<dioxus::prelude::FormData>| {
         let text = evt.value();
         size_input.set(text.clone());
 
···
             // 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_path = query_match.path.as_str();
-                let aspect_parent = aspect_path.rsplit_once('.').map(|(parent, _)| parent);
+                let aspect_parent = query_match.path.rsplit_once('.').map(|(parent, _)| parent);
 
                 // Check if they share the same parent
                 if blob_parent == aspect_parent {
-                    Some(aspect_path.to_string())
+                    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 {
-        use jacquard::types::value::Object;
-        use std::collections::BTreeMap;
-
-        let mut aspect_obj = BTreeMap::new();
-        aspect_obj.insert("width".into(), Data::Integer(width));
-        aspect_obj.insert("height".into(), Data::Integer(height));
+        let aspect_obj = atproto! {{
+            "width": width,
+            "height": height
+        }};
 
         root.with_mut(|record_data| {
-            record_data.set_at_path(&aspect_path, Data::Object(Object(aspect_obj)));
+            record_data.set_at_path(&aspect_path, aspect_obj);
         });
     }
 }
···
     });
 
     let path_for_mutation = path.clone();
-    let handle_input = move |evt: dioxus::prelude::Event<dioxus::prelude::FormData>| {
+    let handle_input = move |evt: Event<dioxus::prelude::FormData>| {
         let text = evt.value();
         input_text.set(text.clone());
 
···
     });
 
     let path_for_mutation = path.clone();
-    let handle_input = move |evt: dioxus::prelude::Event<dioxus::prelude::FormData>| {
+    let handle_input = move |evt: Event<dioxus::prelude::FormData>| {
         let text = evt.value();
         input_text.set(text.clone());
 
···
                                     match fetcher.send(request).await {
                                         Ok(output) => {
                                             if output.status() == StatusCode::OK {
-                                                dioxus_logger::tracing::info!("Record updated successfully");
+                                                tracing::info!("Record updated successfully");
                                                 edit_data.set(data.clone());
                                                 edit_mode.set(false);
                                             } else {
-                                                dioxus_logger::tracing::error!("Unexpected status code: {:?}", output.status());
+                                                tracing::error!("Unexpected status code: {:?}", output.status());
                                             }
                                         }
                                         Err(e) => {
-                                            dioxus_logger::tracing::error!("Failed to update record: {:?}", e);
+                                            tracing::error!("Failed to update record: {:?}", e);
                                         }
                                     }
                                 }
···
                                     match fetcher.send(request).await {
                                         Ok(response) => {
                                             if let Ok(output) = response.into_output() {
-                                                dioxus_logger::tracing::info!("Record created: {}", output.uri);
+                                                tracing::info!("Record created: {}", output.uri);
                                                 let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, output.uri);
                                                 nav.push(link);
                                             }
                                         }
                                         Err(e) => {
-                                            dioxus_logger::tracing::error!("Failed to create record: {:?}", e);
+                                            tracing::error!("Failed to create record: {:?}", e);
                                         }
                                     }
                                 }
···
                                                             .build();
 
                                                         if let Err(e) = fetcher.send(delete_req).await {
-                                                            dioxus_logger::tracing::warn!("Created new record but failed to delete old: {:?}", e);
+                                                            tracing::warn!("Created new record but failed to delete old: {:?}", e);
                                                         }
                                                     }
                                                 }
 
-                                                dioxus_logger::tracing::info!("Record replaced: {}", create_output.uri);
+                                                tracing::info!("Record replaced: {}", create_output.uri);
                                                 let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, create_output.uri);
                                                 nav.push(link);
                                             }
                                         }
                                         Err(e) => {
-                                            dioxus_logger::tracing::error!("Failed to replace record: {:?}", e);
+                                            tracing::error!("Failed to replace record: {:?}", e);
                                         }
                                     }
                                 }
···
 
                                     match fetcher.send(request).await {
                                         Ok(_) => {
-                                            dioxus_logger::tracing::info!("Record deleted");
+                                            tracing::info!("Record deleted");
                                             nav.push(Route::Home {});
                                         }
                                         Err(e) => {
-                                            dioxus_logger::tracing::error!("Failed to delete record: {:?}", e);
+                                            tracing::error!("Failed to delete record: {:?}", e);
                                         }
                                     }
                                 }

crates/weaver-common/src/agent.rs

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

crates/weaver-renderer/src/css.rs

···
     max-width: 90ch;
     margin: 0 auto;
     padding: 2rem 1rem;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
 }}
 
 /* Typography */
···
 
 p {{
     margin-bottom: 1rem;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
 }}
 
 a {{
···
     border-collapse: collapse;
     width: 100%;
     margin-bottom: 1rem;
+    display: block;
+    overflow-x: auto;
+    max-width: 100%;
 }}
 
 th, td {{
···
     border: none;
     border-top: 2px solid var(--color-border);
     margin: 2rem 0;
+}}
+
+/* Tablet and mobile responsiveness */
+@media (max-width: 900px) {{
+    .notebook-content {{
+        padding: 1.5rem 1rem;
+        max-width: 100%;
+    }}
+
+    h1 {{ font-size: 1.85rem; }}
+    h2 {{ font-size: 1.4rem; }}
+    h3 {{ font-size: 1.2rem; }}
+
+    blockquote {{
+        margin-left: 0;
+        margin-right: 0;
+    }}
+}}
+
+/* Small mobile phones */
+@media (max-width: 480px) {{
+    .notebook-content {{
+        padding: 1rem 0.75rem;
+    }}
+
+    h1 {{ font-size: 1.65rem; }}
+    h2 {{ font-size: 1.3rem; }}
+    h3 {{ font-size: 1.1rem; }}
+
+    blockquote {{
+        padding-left: 0.75rem;
+        padding-right: 0.75rem;
+    }}
 }}
 "#,
         // Light mode colours

flake.lock

···
     "advisory-db": {
       "flake": false,
       "locked": {
-        "lastModified": 1761631338,
-        "narHash": "sha256-F6dlUrDiShwhMfPR+WoVmaQguGdEwjW9SI4nKlkay7c=",
+        "lastModified": 1763052940,
+        "narHash": "sha256-dt2Eze8JMyeCqpUPT1TF6XrGJR8QeD7UvUDaIrKngrE=",
         "owner": "rustsec",
         "repo": "advisory-db",
-        "rev": "2e45336771e36acf5bcefe7c99280ab214719707",
+        "rev": "4b6acc7020a23b61ae4963a075f0a4058cef79f2",
         "type": "github"
       },
       "original": {
···
     },
     "crane": {
       "locked": {
-        "lastModified": 1760924934,
-        "narHash": "sha256-tuuqY5aU7cUkR71sO2TraVKK2boYrdW3gCSXUkF4i44=",
+        "lastModified": 1762538466,
+        "narHash": "sha256-8zrIPl6J+wLm9MH5ksHcW7BUHo7jSNOu0/hA0ohOOaM=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "c6b4d5308293d0d04fcfeee92705017537cad02f",
+        "rev": "0cea393fffb39575c46b7a0318386467272182fe",
         "type": "github"
       },
       "original": {
···
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1761886294,
-        "narHash": "sha256-GEyOUuFbqWzpQIKO6mT2oCEp2JnUvNkOW/WsrHOFK6I=",
+        "lastModified": 1763000036,
+        "narHash": "sha256-yJiLpG1W2+yn3xvdeVTpt9CUYC2/VBLCCpKhEifdcsc=",
         "owner": "DioxusLabs",
         "repo": "dioxus",
-        "rev": "2ab9a5586dc6b4d95e210eded692f50e7ab7575e",
+        "rev": "bd2d1de873ae9c0e7c4656ec0c991ea9aafd3293",
         "type": "github"
       },
       "original": {
···
     },
     "nixpkgs_3": {
       "locked": {
-        "lastModified": 1761880412,
-        "narHash": "sha256-QoJjGd4NstnyOG4mm4KXF+weBzA2AH/7gn1Pmpfcb0A=",
+        "lastModified": 1762943920,
+        "narHash": "sha256-ITeH8GBpQTw9457ICZBddQEBjlXMmilML067q0e6vqY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "a7fc11be66bdfb5cdde611ee5ce381c183da8386",
+        "rev": "91c9a64ce2a84e648d0cf9671274bb9c2fb9ba60",
         "type": "github"
       },
       "original": {
···
         "nixpkgs": "nixpkgs_4"
       },
       "locked": {
-        "lastModified": 1761878277,
-        "narHash": "sha256-6fCtyVdTzoQejwoextAu7dCLoy5fyD3WVh+Qm7t2Nhg=",
+        "lastModified": 1763087910,
+        "narHash": "sha256-eB9Z1mWd1U6N61+F8qwDggX0ihM55s4E0CluwNukJRU=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "6604534e44090c917db714faa58d47861657690c",
+        "rev": "cf4a68749733d45c0420726596367acd708eb2e8",
         "type": "github"
       },
       "original": {

flake.nix

···
             diesel-cli
             postgresql
             cargo-insta
+            cargo-bloat
             jq
             dioxus-cli
             wasm-bindgen-cli

weaver_notes/.obsidian/workspace.json

···
         "type": "tabs",
         "children": [
           {
-            "id": "f41bdf1f327c8668",
+            "id": "70e4a46d11e8ec6f",
             "type": "leaf",
             "state": {
               "type": "markdown",
               "state": {
-                "file": "Arch.md",
+                "file": "Why I rewrote pdsls in Rust (tm).md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "Arch"
+              "title": "Why I rewrote pdsls in Rust (tm)"
+            }
+          },
+          {
+            "id": "bf69cdf6fbb617c2",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "Why I rewrote pdsls in Rust (tm).md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "Why I rewrote pdsls in Rust (tm)"
+            }
+          },
+          {
+            "id": "6029beecc3d03bce",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "bug notes.md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "bug notes"
             }
           }
-        ]
+        ],
+        "currentTab": 2
       }
     ],
     "direction": "vertical"
···
             "state": {
               "type": "backlink",
               "state": {
-                "file": "Arch.md",
+                "file": "Why I rewrote pdsls in Rust (tm).md",
                 "collapseAll": false,
                 "extraContext": false,
                 "sortOrder": "alphabetical",
···
                 "unlinkedCollapsed": true
               },
               "icon": "links-coming-in",
-              "title": "Backlinks for Arch"
+              "title": "Backlinks for Why I rewrote pdsls in Rust (tm)"
             }
           },
           {
···
             "state": {
               "type": "outline",
               "state": {
-                "file": "Weaver - Long-form writing.md",
+                "file": "Why I rewrote pdsls in Rust (tm).md",
                 "followCursor": false,
                 "showSearch": false,
                 "searchQuery": ""
               },
               "icon": "lucide-list",
-              "title": "Outline of Weaver - Long-form writing"
+              "title": "Outline of Why I rewrote pdsls in Rust (tm)"
             }
           }
-        ]
+        ],
+        "currentTab": 3
       }
     ],
     "direction": "horizontal",
-    "width": 300
+    "width": 300,
+    "collapsed": true
   },
   "left-ribbon": {
     "hiddenItems": {
···
       "bases:Create new base": false
     }
   },
-  "active": "f41bdf1f327c8668",
+  "active": "6029beecc3d03bce",
   "lastOpenFiles": [
-    "Weaver - Long-form writing.md",
+    "bug notes.md",
+    "Why I rewrote pdsls in Rust (tm).md",
+    "meta.png",
+    "Pasted image 20251114125028.png",
+    "invalid_record.png",
+    "Pasted image 20251114125031.png",
+    "Pasted image 20251114121431.png",
+    "json_editor_with_errors.png",
+    "pretty_editor.png",
     "Arch.md",
+    "Weaver - Long-form writing.md",
     "weaver_photo_med.jpg",
     "xkcd_345_excerpt.png",
-    "light_mode_excerpt.png",
-    "notebook_entry_preview.png"
+    "light_mode_excerpt.png"
   ]
 }

weaver_notes/Why I rewrote pdsls in Rust (tm).md

···
+![[pretty_editor.png]]
+
+There are a few generic atproto record viewers out there [pdsls.dev](https://pdsls.dev), [atp.tools](https://atp.tools), a number of others, [anisota.net](https://anisota.net) recently just built one into their webapp), but only really one editor, that being pdsls. It's a good webapp. It's simple and does what it says on the tin, runs entirely client-side. So why an alternative? There's one personal motivation which I'll leave to the wayside, so I'll focus on the UX. Its record editing is exactly what you need. You get a nice little editor window to type or paste or upload JSON into. It has some syntax highlighting. It optionally validates that against a lexicon (determined by the `$type` NSID, if it can resolve it), gives you a little indicator if it's valid according the the schema, and you can make a new record, or update the current one, or delete it. This is all well and good. 
+
+But what if you want to know where a schema violation occurs in the record and what it is? What if you want to add another item to an array where the item schema is big and complex? You can copy-paste text around, but the editor has no notion of the abstract syntax tree of an atproto data model type, it simply gives you a thumbs-up, thumbs-down. And if you want to do something like upload a blob, like an image, ~~you have to figure out how to do that separately and populate all the info manually~~ whoops, it does have that now, missed it in the interface writing the initial version of this. Nothing wrong with that, it all works well and there's lots of clever little convenience features like direct links to the getRecord url and query for a record, constellation backlinks, a really nice OpenAPI-esque lexicon schema display, and so on.
+## Debugging tools and learning 
+
+But regardless, I was frustrated with it, I needed a debugging tool for Weaver records (as I'd already evolved a schema or two in ways that  invalidated my own records during testing, which required manual editing), felt the atproto ecosystem deserved a second option for this use case, and I also wanted to exercise some skills before I built the next major part of Weaver, that being the editor.
+
+The first pass at that isn't going to have the collaborative editing I'd like it to have, there's more back-end and protocol work required on that front yet. But I want it to be a nice, solid markdown editor which feels good to use. Specifically, I want it to feel basically like a simpler version of Obsidian's editor, which is what I'm using to compose this. The hybrid compose view it defaults to is perfect for markdown. It will likely have a toolbar rather than rely entirely on key combinations and text input, as I know that that will be useful to people who aren't familiar with Markdown's syntax, but it won't have a preview window, unless you want it to, and it should convey accurately what you're going to get.
+
+![[json_editor_with_errors.png]]
+
+That meant I needed to get more familiar with how Dioxus does UI. The notebook entry viewer is basically a very thin UI wrapper around a markdown-to-html converter. The editor can take advantage of that to some degree, but the needs of editing mean it can't just be that plus a text box, not if there's to be a chance in hell of me using it, versus pasting content in from Obsidian, or manually publishing from the CLI. Plus, I have something of a specific aesthetic I'm trying to go for with Weaver, and I wanted more space to refine that vision and explore stylistic choices.
+
+>I feel I should clarify that making  the record editor use Iosevka mimicking Berkeley Mono as its only font doesn't reflect my vision for the rest of the interface, it just kinda felt right for this specific thing.
+
+So, what should an evolution on a record viewer and editor have? Programmer's text editors and language servers have a lot to teach us here. Your editor should tell you what type a thing is if it's not already obvious. It should show you where an error happened, it should tell you what the error is, and it should help guide you into not making errors, as well as providing convenience features for making common changes. 
+
+![[invalid_record.png]]
+
+This helps people when they're manually editing, but it also helps people check that what their app is generating is valid, so long as they have a schema we can resolve and validate it against. ATproto apps tend to be pretty permissive when it comes to what they accept and display, as is [generally wise](https://en.wikipedia.org/wiki/Robustness_principle), but the above record, for example, breaks Jetstream because whatever tool was used to create it set that empty string `$type` field, perhaps instead of skipping the embed field for a post with no embeds.
+## Field-testing Jacquard's features
+Another driver behind this was a desire to field-test a number of the unique features of the atproto library I built for Weaver, [Jacquard](https://tangled.org/@nonbinary.computer/jacquard). I've written more about one aspect of its design philosophy and architecture [here](https://alpha.weaver.sh/did:plc:yfvwmnlztr4dwkb7hwz55r2g/Jacquard/Jacquard%20Magic) but since that post I've added a couple pretty powerful features and I needed to give them a shakedown run. One was runtime lexicon resolution and schema validation. The other was the new tools for working with generic atproto data without strong types, like the path query syntax and functions.
+
+For the former, I first had to get lexicon resolution working in WebAssembly, which mean getting DNS resolution working in WebAssembly (the `dns` feature in `jacquard-identity` uses `hickory-resolver`, which only includes support for tokio and async-std runtimes by default, neither of which support `wasm32-unknown-unknown`, the web wasm target. I went with the DNS over HTTPS route, making calls to Cloudflare's API when the `dns` feature is disabled for DNS TXT resolution (for both handles and lexicons). At some point I'll make this somewhat more pluggable, so as not to introduce a direct dependency on a specific vendor API, but for the moment this works well.
+
+For the latter, well that's literally what drives the pretty editor. There's a single `Data<'static>` stored in a Dioxus `Signal`, which is path-indexed into directly for the field display and for editing. 
+```rust
+    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)
+    });
+    /* --- SNIP --- */
+    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));
+            }
+        }
+    };
+```
+
+And the path queries are what make the blob upload interface able to do things like auto-populate sibling fields in an image embed, like the aspect ratio.
+```rust
+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);
+                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);
+        });
+    }
+}
+```
+
+They also drive the in-situ error display you saw earlier. The lexicon schema validator reports the path of an error in the data, and we can then check that path as we iterate through during the render to know where we should display said error. And yes, I did have to make further improvements to the querying (including adding the mutable reference queries and `set_at_path()` method to enable editing).
+
+>You might also notice the use of the `atproto!{}` macro above. This works just like the `json!` macro from `serde_json` and the `ipld!` macro from `ipld_core` (in fact it's *mostly* cribbed from the latter). It's been in Jacquard since almost the beginning, but I haven't shown it off much. It's not super well-developed beyond the simple cases, but it works reasonably well and is more compact than building the object manually.
+
+The upshot of all this is that building this meant I discovered a bunch of bugs in my own code, found a bunch of places where my interfaces weren't as nice as they could be, and made some stuff that I'll probably upstream into my own library after testing them in the Weaver web-app (like an abstraction over unauthenticated requests and an authenticated OAuth session, or an OAuth storage implementation using browser LocalStorage, and so on). Working on this also meant that the webapp got enough in it that I felt comfortable doing a bit of a soft-launch of something real under the [*.weaver.sh](https://alpha.weaver.sh) domain.
+## Amusing meta image
+![[meta.png]]

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
+-