working alpha version up online!

Cargo.lock

···
  "sqlite-wasm-rs",
  "time",
  "tokio",
+ "tracing",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "weaver-api",

crates/weaver-app/Cargo.toml

···
 dioxus-logger = "0.7.1"
 serde_html_form = "0.2.8"
 webbrowser = "1.0.6"
+tracing.workspace = true
 
 
 

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

···
 #header {
     max-width: 1200px;
 }
+
+.record-view-container {
+    max-width: 1200px;
+    margin: 2rem auto;
+    padding: 0 1rem;
+}
+
+.uri-input-section {
+    margin-bottom: 2.5rem;
+}
+
+.uri-input {
+    font-family: var(--font-mono);
+    font-size: 0.9rem;
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+    padding: 0.5rem 0.75rem;
+    background: var(--color-surface, rgba(0, 0, 0, 0.2));
+    border: 1px solid var(--color-border);
+    color: var(--color-text);
+    outline: none;
+    transition: border-color 0.2s;
+}
+
+.uri-input:focus {
+    border-color: var(--color-primary);
+}
+
+.uri-input::placeholder {
+    color: var(--color-subtle);
+    opacity: 0.5;
+}

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

···
     display: flex;
     flex-direction: row;
     justify-content: space-between;
-    padding-left: 4rem;
+    padding-left: 1rem;
     padding-top: 1rem;
-    padding-right: 4rem;
+    padding-right: 1rem;
 }
 
 .breadcrumbs {

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

···
     letter-spacing: 0.15em;
 }
 
+.uri-input-section {
+    margin-bottom: 1rem;
+}
+
+.uri-input {
+    font-family: var(--font-mono);
+    font-size: 0.9rem;
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+    padding: 0.5rem 0.75rem;
+    background: var(--color-surface, rgba(0, 0, 0, 0.2));
+    border: 1px solid var(--color-border);
+    color: var(--color-text);
+    outline: none;
+    transition: border-color 0.2s;
+}
+
+.uri-input:focus {
+    border-color: var(--color-primary);
+}
+
+.uri-input::placeholder {
+    color: var(--color-subtle);
+    opacity: 0.5;
+}
+
 .record-metadata {
     display: flex-wrap;
     flex-direction: column;
···
     font-style: italic;
     padding-top: 0.25rem;
 }
+
+/* Dialog Actions for Delete Confirmation */
+.dialog-actions {
+    display: flex;
+    flex-direction: row;
+    justify-content: flex-end;
+    gap: 0;
+    margin-top: 8px;
+}
+
+.dialog-actions button {
+    font-family: var(--font-mono);
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    padding: 0.5rem 1rem;
+    background: transparent;
+    border: none;
+    border-bottom: 2px solid transparent;
+    color: var(--color-subtle);
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.dialog-actions button:hover {
+    color: var(--color-primary);
+    border-bottom-color: var(--color-primary);
+}
+
+.dialog-actions button:first-child {
+    color: var(--color-error, #ff6b6b);
+}
+
+.dialog-actions button:first-child:hover {
+    color: var(--color-error, #ff5252);
+    border-bottom-color: var(--color-error, #ff6b6b);
+}

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

···
             let handle = handle.clone();
             let fetcher = fetcher.clone();
             spawn(async move {
-                if let Err(e) = start_oauth_flow(handle, fetcher).await {
-                    error!("Authentication failed: {}", e);
-                    error.set(Some(format!("Authentication failed: {}", e)));
-                    is_loading.set(false);
+                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);
+                    }
                 }
-                open.set(false);
             });
         });
     };

crates/weaver-app/src/main.rs

···
 #[cfg(all(feature = "fullstack-server", feature = "server"))]
 use dioxus::fullstack::response::Extension;
 use dioxus_logger::tracing::Level;
-use jacquard::oauth::{client::OAuthClient, session::ClientData};
+use jacquard::{
+    oauth::{client::OAuthClient, session::ClientData},
+    types::aturi::AtUri,
+};
 #[allow(unused)]
 use jacquard::{
     smol_str::SmolStr,
···
 use std::sync::Arc;
 use std::sync::{LazyLock, Mutex};
 #[allow(unused)]
-use views::{Callback, Home, Navbar, Notebook, NotebookIndex, NotebookPage, RecordView};
+use views::{
+    Callback, Home, Navbar, Notebook, NotebookIndex, NotebookPage, RecordIndex, RecordView,
+};
 
 use crate::{
     auth::{AuthState, AuthStore},
···
         #[route("/")]
         Home {},
         #[layout(ErrorLayout)]
-        #[route("/record#:uri")]
-        RecordView { uri: SmolStr },
+        #[nest("/record")]
+          #[layout(RecordIndex)]
+            #[route("/:..uri")]
+            RecordView { uri: Vec<String> },
+          #[end_layout]
+        #[end_nest]
         #[route("/callback?:state&:iss&:code")]
         Callback { state: SmolStr, iss: SmolStr, code: SmolStr },
         #[nest("/:ident")]

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

···
-use crate::{components::identity::NotebookCard, fetch};
+use crate::{Route, components::identity::NotebookCard, fetch};
 use dioxus::prelude::*;
+use jacquard::{IntoStatic, smol_str::ToSmolStr, types::aturi::AtUri};
 
 const NOTEBOOK_CARD_CSS: Asset = asset!("/assets/styling/notebook-card.css");
 
···
         let fetcher = fetcher.clone();
         async move { fetcher.fetch_notebooks_from_ufos().await }
     });
+    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() {
+            if let Ok(parsed) = AtUri::new(&input_uri) {
+                navigator.push(Route::RecordView {
+                    uri: vec![parsed.to_string()],
+                });
+            }
+        }
+    };
 
     rsx! {
         document::Link { rel: "stylesheet", href: NOTEBOOK_CARD_CSS }
-
-        div { class: "notebooks-list",
-            match notebooks() {
-                Some(Ok(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()
+        div {
+            class: "record-view-container",
+            div { class: "record-header",
+                div { class: "uri-input-section",
+                    input {
+                        r#type: "text",
+                        class: "uri-input",
+                        placeholder: "at://did:plc:.../collection/rkey",
+                        value: "{uri_input}",
+                        oninput: move |evt| uri_input.set(evt.value()),
+                        onkeydown: move |evt| {
+                            if evt.key() == Key::Enter {
+                                handle_uri_submit();
+                            }
+                        },
+                    }
+                }
+            }
+            div { class: "notebooks-list",
+                match notebooks() {
+                    Some(Ok(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()
+                                        }
                                     }
                                 }
                             }
                         }
+                    },
+                    Some(Err(_)) => rsx! {
+                        div { "Error loading notebooks" }
+                    },
+                    None => rsx! {
+                        div { "Loading notebooks..." }
                     }
-                },
-                Some(Err(_)) => rsx! {
-                    div { "Error loading notebooks" }
-                },
-                None => rsx! {
-                    div { "Loading notebooks..." }
                 }
             }
         }
+
     }
 }

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

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

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

···
 use crate::auth::AuthState;
 use crate::components::dialog::{DialogContent, DialogDescription, DialogRoot, DialogTitle};
 use crate::fetch::CachedFetcher;
-use dioxus::prelude::*;
+use dioxus::{CapturedError, prelude::*};
 use humansize::format_size;
 use jacquard::api::com_atproto::repo::get_record::GetRecordOutput;
 use jacquard::client::AgentError;
···
     client::AgentSessionExt,
     common::{Data, IntoStatic},
     identity::lexicon_resolver::LexiconSchemaResolver,
-    smol_str::SmolStr,
     types::{aturi::AtUri, cid::Cid, ident::AtIdentifier, string::Nsid},
 };
 use mime_sniffer::MimeTypeSniffer;
···
 }
 
 #[component]
-pub fn RecordView(uri: ReadSignal<SmolStr>) -> Element {
-    let fetcher = use_context::<CachedFetcher>();
-    let at_uri = AtUri::new_owned(uri());
-    if let Err(err) = &at_uri {
-        let error = format!("{:?}", err);
-        return rsx! {
-            div {
+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() {
+            if let Ok(parsed) = AtUri::new(&input_uri) {
+                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, parsed);
+                navigator.push(link);
+            }
+        }
+    };
+    rsx! {
+        document::Stylesheet { href: asset!("/assets/styling/record-view.css") }
+        div {
+            class: "record-view-container",
+            div { class: "record-header",
                 h1 { "Record View" }
-                p { "URI: {uri}" }
-                p { "Error: {error}" }
+                div { class: "uri-input-section",
+                    input {
+                        r#type: "text",
+                        class: "uri-input",
+                        placeholder: "at://did:plc:.../collection/rkey",
+                        value: "{uri_input}",
+                        oninput: move |evt| uri_input.set(evt.value()),
+                        onkeydown: move |evt| {
+                            if evt.key() == Key::Enter {
+                                handle_uri_submit();
+                            }
+                        },
+                    }
+                }
             }
-        };
+
+            Outlet::<Route> {}
+        }
+    }
+}
+
+#[component]
+pub fn RecordView(uri: ReadSignal<Vec<String>>) -> Element {
+    let fetcher = use_context::<CachedFetcher>();
+    info!("Uri:{:?}", uri().join("/"));
+    let at_uri = AtUri::new_owned(&*uri.read().join("/"));
+    if at_uri.is_err() {
+        return rsx! {};
     }
-    let uri = use_signal(|| at_uri.unwrap());
+    let uri = use_signal(move || AtUri::new_owned(&*uri.read().join("/")).unwrap());
     let mut view_mode = use_signal(|| ViewMode::Pretty);
     let mut edit_mode = use_signal(|| false);
-    let navigator = use_navigator();
 
     let client = fetcher.get_client();
     let record_resource = use_resource(move || {
         let client = client.clone();
-        async move { client.fetch_record_slingshot(&uri()).await }
+        async move { client.fetch_record_slingshot(&*uri.read()).await }
     });
 
     // Check ownership for edit access
···
         }
 
         // authority() returns &AtIdentifier which can be Did or Handle
-        match uri().authority() {
+        match &*uri.read().authority() {
             AtIdentifier::Did(record_did) => auth.did.as_ref() == Some(record_did),
             AtIdentifier::Handle(_) => {
                 // Can't easily check ownership for handles without async resolution
···
             }
         }
     });
-    if let Some(Ok(record)) = &*record_resource.read_unchecked() {
-        let mut record_value = use_signal(|| record.value.clone().into_static());
-        let json =
-            use_memo(move || serde_json::to_string_pretty(&record_value()).unwrap_or_default());
+    if let Some(Ok(record)) = &*record_resource.read() {
+        let record_value = record.value.clone().into_static();
+        let record = record.clone();
 
         rsx! {
-            RecordViewLayout {
-                uri: uri().clone(),
-                cid: record.cid.clone(),
-                if edit_mode() {
-                    EditableRecordContent {
-                        record_value: record_value,
-                        uri: uri,
-                        view_mode: view_mode,
-                        edit_mode: edit_mode,
-                        record_resource: record_resource,
-                    }
-                } else {
-                    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"
+            Fragment {  key: "{uri()}",
+                RecordViewLayout {
+                    uri: uri().clone(),
+                    cid: record.cid.clone(),
+                    if edit_mode() {
+
+                        EditableRecordContent {
+                            record_value: record_value,
+                            uri: uri,
+                            view_mode: view_mode,
+                            edit_mode: edit_mode,
+                            record_resource: record_resource,
                         }
-                        button {
-                            class: if view_mode() == ViewMode::Json { "tab-button active" } else { "tab-button" },
-                            onclick: move |_| view_mode.set(ViewMode::Json),
-                            "JSON"
-                        }
-                        if is_owner() {
+                    } else {
+                        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: "tab-button edit-button",
-                                onclick: move |_| edit_mode.set(true),
-                                "Edit"
+                                class: if view_mode() == ViewMode::Json { "tab-button active" } else { "tab-button" },
+                                onclick: move |_| view_mode.set(ViewMode::Json),
+                                "JSON"
+                            }
+                            if is_owner() {
+                                button {
+                                    class: "tab-button edit-button",
+                                    onclick: move |_| edit_mode.set(true),
+                                    "Edit"
+                                }
                             }
                         }
-                    }
-                    div {
-                        class: "tab-content",
-                        match view_mode() {
-                            ViewMode::Pretty => rsx! {
-                                PrettyRecordView { record: record_value(), uri: uri().clone() }
-                            },
-                            ViewMode::Json => rsx! {
-                                CodeView {
-                                    code: use_signal(|| json()),
-                                    lang: Some("json".to_string()),
-                                }
-                            },
+                        div {
+                            class: "tab-content",
+                            match view_mode() {
+                                ViewMode::Pretty => rsx! {
+                                    PrettyRecordView { record: record_value, uri: uri().clone() }
+                                },
+                                ViewMode::Json => {
+                                    let json = use_memo(use_reactive!(|record| serde_json::to_string_pretty(
+                                        &record.value
+                                    )
+                                    .unwrap_or_default()));
+                                    rsx! {
+                                        CodeView {
+                                            code: json,
+                                            lang: Some("json".to_string()),
+                                        }
+                                    }
+                                },
+                            }
                         }
                     }
                 }
             }
         }
     } else {
-        rsx! {
-            div {
-                class: "record-view-container",
-                h1 { "Record" }
-                p { "URI: {uri}" }
-                p { "Loading..." }
-            }
-        }
+        rsx! {}
     }
 }
 
···
 #[component]
 fn HighlightedUri(uri: AtUri<'static>) -> Element {
     let s = uri.as_str();
-    let link = format!("/record#{}", s);
+    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}",
+                href: link,
                 class: "uri-link",
                 span { class: "string-at-uri",
                     span { class: "aturi-scheme", "at://" }
···
         };
     }
 
-    rsx! { span { class: "string-at-uri", "{s}" } }
+    rsx! { a { class: "string-at-uri", href: s } }
 }
 
 #[component]
···
 #[component]
 fn RecordViewLayout(uri: AtUri<'static>, cid: Option<Cid<'static>>, children: Element) -> Element {
     rsx! {
-        document::Stylesheet { href: asset!("/assets/styling/record-view.css") }
         div {
-            class: "record-view-container",
-            div {
-                class: "record-header",
-                h1 { "Record" }
-                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}" }
-                        }
-                    }
+            class: "record-metadata",
+            div { class: "metadata-row",
+                span { class: "metadata-label", "URI" }
+                span { class: "metadata-value",
+                    HighlightedUri { uri: uri.clone() }
                 }
             }
-            {children}
+            if let Some(cid) = cid {
+                div { class: "metadata-row",
+                    span { class: "metadata-label", "CID" }
+                    code { class: "metadata-value", "{cid}" }
+                }
+            }
         }
+
+        {children}
+
     }
 }
 
 /// Render some text as markdown.
 #[component]
 fn EditableRecordContent(
-    record_value: Signal<Data<'static>>,
+    record_value: Data<'static>,
     uri: ReadSignal<AtUri<'static>>,
     view_mode: Signal<ViewMode>,
     edit_mode: Signal<bool>,
     record_resource: Resource<Result<GetRecordOutput<'static>, AgentError>>,
 ) -> Element {
-    let mut edit_data = use_signal(|| record_value());
+    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>();
···
                                         Ok(output) => {
                                             if output.status() == StatusCode::OK {
                                                 dioxus_logger::tracing::info!("Record updated successfully");
-                                                record_value.set(data);
+                                                edit_data.set(data.clone());
                                                 edit_mode.set(false);
                                             } else {
                                                 dioxus_logger::tracing::error!("Unexpected status code: {:?}", output.status());
···
                                         Ok(response) => {
                                             if let Ok(output) = response.into_output() {
                                                 dioxus_logger::tracing::info!("Record created: {}", output.uri);
-                                                nav.push(Route::RecordView { uri: output.uri.to_smolstr() });
+                                                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, output.uri);
+                                                nav.push(link);
                                             }
                                         }
                                         Err(e) => {
···
                                                 }
 
                                                 dioxus_logger::tracing::info!("Record replaced: {}", create_output.uri);
-                                                nav.push(Route::RecordView { uri: create_output.uri.to_smolstr() });
+                                                let link = format!("{}/record/{}", crate::env::WEAVER_APP_DOMAIN, create_output.uri);
+                                                nav.push(link);
                                             }
                                         }
                                         Err(e) => {
···
                     });
                 },
                 on_cancel: move |_| {
-                    edit_data.set(record_value());
+                    edit_data.set(record_value.clone());
                     edit_mode.set(false);
                 },
             }