wip bugfixes

Cargo.lock

···
 
 [[package]]
 name = "cookie_store"
-version = "0.21.1"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2eac901828f88a5241ee0600950ab981148a18f2f756900ffba1b125ca6a3ef9"
+checksum = "3fc4bff745c9b4c7fb1e97b25d13153da2bc7796260141df62378998d070207f"
 dependencies = [
  "cookie",
  "document-features",
···
 [[package]]
 name = "jacquard"
 version = "0.9.4"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
···
 [[package]]
 name = "jacquard-api"
 version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-axum"
 version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "axum",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.9.4"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "cid",
  "dashmap 6.1.0",
···
 [[package]]
 name = "jacquard-oauth"
 version = "0.9.2"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "base64 0.22.1",
  "bytes",
···
 [[package]]
 name = "jacquard-repo"
 version = "0.9.4"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "bytes",
  "cid",
···
 [[package]]
 name = "mini-moka"
 version = "0.10.99"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#bf8f91add8747b64b1d1d74af4b358960f69d6e7"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#87e15baeadf555a107a56c25c7f2e0008f46a5e2"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
···
 
 [[package]]
 name = "reqwest"
-version = "0.12.25"
+version = "0.12.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6eff9328d40131d43bd911d42d79eb6a47312002a4daefc9e37f17e74a7701a"
+checksum = "3b4c14b2d9afca6a60277086b0cc6a6ae0b568f6f7916c943a8cdc79f8be240f"
 dependencies = [
  "base64 0.22.1",
  "bytes",

crates/weaver-app/Dockerfile

···
 # Build wasm workers
 RUN RUSTFLAGS='--cfg getrandom_backend="wasm_js"' cargo build -p weaver-app --bin editor_worker --bin embed_worker \
     --target wasm32-unknown-unknown --release \
-    --no-default-features --features "web"
+    --no-default-features --features "web, use-index"
 
 # Run wasm-bindgen on workers
 RUN wasm-bindgen target/wasm32-unknown-unknown/release/editor_worker.wasm \

crates/weaver-app/src/blobcache.rs

···
                     .build(),
             )
             .await
-            .map_err(|e| CapturedError::from_display(format_smolstr!("Failed to fetch entry: {}", e).as_str().to_string()))?;
+            .map_err(|e| {
+                CapturedError::from_display(
+                    format_smolstr!("Failed to fetch entry: {}", e)
+                        .as_str()
+                        .to_string(),
+                )
+            })?;
 
-        let record = resp
-            .into_output()
-            .map_err(|e| CapturedError::from_display(format_smolstr!("Failed to parse entry: {}", e).as_str().to_string()))?;
+        let record = resp.into_output().map_err(|e| {
+            CapturedError::from_display(
+                format_smolstr!("Failed to parse entry: {}", e)
+                    .as_str()
+                    .to_string(),
+            )
+        })?;
 
         // Parse the entry
         let entry: Entry = jacquard::from_data(&record.value).map_err(|e| {
-            CapturedError::from_display(format_smolstr!("Failed to deserialize entry: {}", e).as_str().to_string())
+            CapturedError::from_display(
+                format_smolstr!("Failed to deserialize entry: {}", e)
+                    .as_str()
+                    .to_string(),
+            )
         })?;
 
         // Find the image by name
···
             })
             .map(|img| img.image.blob().cid().clone().into_static())
             .ok_or_else(|| {
-                CapturedError::from_display(format_smolstr!("Image '{}' not found in entry", name).as_str().to_string())
+                CapturedError::from_display(
+                    format_smolstr!("Image '{}' not found in entry", name)
+                        .as_str()
+                        .to_string(),
+                )
             })?;
 
         // Check cache first
···
             )
             .await
             .map_err(|e| {
-                CapturedError::from_display(format_smolstr!("Failed to fetch PublishedBlob: {}", e).as_str().to_string())
+                CapturedError::from_display(
+                    format_smolstr!("Failed to fetch PublishedBlob: {}", e)
+                        .as_str()
+                        .to_string(),
+                )
             })?;
 
         let record = resp.into_output().map_err(|e| {
-            CapturedError::from_display(format_smolstr!("Failed to parse PublishedBlob: {}", e).as_str().to_string())
+            CapturedError::from_display(
+                format_smolstr!("Failed to parse PublishedBlob: {}", e)
+                    .as_str()
+                    .to_string(),
+            )
         })?;
 
         // Parse the PublishedBlob
         let published: PublishedBlob = jacquard::from_data(&record.value).map_err(|e| {
-            CapturedError::from_display(format_smolstr!("Failed to deserialize PublishedBlob: {}", e).as_str().to_string())
+            CapturedError::from_display(
+                format_smolstr!("Failed to deserialize PublishedBlob: {}", e)
+                    .as_str()
+                    .to_string(),
+            )
         })?;
 
         // Get CID from the upload blob ref
···
             .get_notebook_by_key(notebook_key)
             .await?
             .ok_or_else(|| {
-                CapturedError::from_display(format_smolstr!("Notebook '{}' not found", notebook_key).as_str().to_string())
+                CapturedError::from_display(
+                    format_smolstr!("Notebook '{}' not found", notebook_key)
+                        .as_str()
+                        .to_string(),
+                )
             })?;
 
         let (view, entry_refs) = notebook.as_ref();
 
         // Get the DID from the notebook URI for blob fetching
         let notebook_did = jacquard::types::aturi::AtUri::new(view.uri.as_ref())
-            .map_err(|e| CapturedError::from_display(format_smolstr!("Invalid notebook URI: {}", e).as_str().to_string()))?
+            .map_err(|e| {
+                CapturedError::from_display(
+                    format_smolstr!("Invalid notebook URI: {}", e)
+                        .as_str()
+                        .to_string(),
+                )
+            })?
             .authority()
             .clone()
             .into_static();
···
         let client = self.fetcher.get_client();
         for entry_ref in entry_refs {
             // Parse the entry URI to get rkey
-            let entry_uri = jacquard::types::aturi::AtUri::new(entry_ref.uri.as_ref())
-                .map_err(|e| CapturedError::from_display(format_smolstr!("Invalid entry URI: {}", e).as_str().to_string()))?;
+            let entry_uri = jacquard::types::aturi::AtUri::new(entry_ref.entry.uri.as_ref())
+                .map_err(|e| {
+                    CapturedError::from_display(
+                        format_smolstr!("Invalid entry URI: {}", e)
+                            .as_str()
+                            .to_string(),
+                    )
+                })?;
             let rkey = entry_uri
                 .rkey()
                 .ok_or_else(|| CapturedError::from_display("Entry URI missing rkey"))?;
···
             }
         }
 
-        Err(CapturedError::from_display(format_smolstr!(
-            "Image '{}' not found in notebook '{}'",
-            image_name, notebook_key
-        ).as_str().to_string()))
+        Err(CapturedError::from_display(
+            format_smolstr!(
+                "Image '{}' not found in notebook '{}'",
+                image_name,
+                notebook_key
+            )
+            .as_str()
+            .to_string(),
+        ))
     }
 
     /// Insert bytes directly into cache (for pre-warming after upload)

crates/weaver-app/src/components/editor/writer.rs

···
 
                 self.last_char_offset = closing_char_end;
             }
-            Html(html) | InlineHtml(html) => {
+            Html(html) => {
                 // Track offset mapping for raw HTML
                 let char_start = self.last_char_offset;
                 let html_char_len = html.chars().count();
···
 
                 self.write(&html)?;
 
+                // Record mapping for inline HTML
+                self.record_mapping(range.clone(), char_start..char_end);
+                self.last_char_offset = char_end;
+            }
+            InlineHtml(html) => {
+                // Track offset mapping for raw HTML
+                let char_start = self.last_char_offset;
+                let html_char_len = html.chars().count();
+                let char_end = char_start + html_char_len;
+                self.write(r#"<span class="html-embed html-embed-inline">"#)?;
+                self.write(&html)?;
+                self.write("</span>")?;
                 // Record mapping for inline HTML
                 self.record_mapping(range.clone(), char_start..char_end);
                 self.last_char_offset = char_end;
···
 
         // Emit the opening tag
         match tag {
-            Tag::HtmlBlock => Ok(()),
+            // HTML blocks get their own paragraph to try and corral them better
+            Tag::HtmlBlock => {
+                // Record paragraph start for boundary tracking
+                // BUT skip if inside a list - list owns the paragraph boundary
+                if self.list_depth == 0 {
+                    self.current_paragraph_start =
+                        Some((self.last_byte_offset, self.last_char_offset));
+                }
+                let node_id = self.gen_node_id();
+
+                if self.end_newline {
+                    write!(
+                        &mut self.writer,
+                        r#"<p id="{}", class="html-embed html-embed-block">"#,
+                        node_id
+                    )?;
+                } else {
+                    write!(
+                        &mut self.writer,
+                        r#"\n<p id="{}", class="html-embed html-embed-block">"#,
+                        node_id
+                    )?;
+                }
+                self.begin_node(node_id.clone());
+
+                // Map the start position of the paragraph (before any content)
+                // This allows cursor to be placed at the very beginning
+                let para_start_char = self.last_char_offset;
+                let mapping = OffsetMapping {
+                    byte_range: range.start..range.start,
+                    char_range: para_start_char..para_start_char,
+                    node_id,
+                    char_offset_in_node: 0,
+                    child_index: Some(0), // position before first child
+                    utf16_len: 0,
+                };
+                self.offset_maps.push(mapping);
+
+                Ok(())
+            }
             Tag::Paragraph => {
                 // Record paragraph start for boundary tracking
                 // BUT skip if inside a list - list owns the paragraph boundary
···
 
         // Emit tag HTML first
         let result = match tag {
-            TagEnd::HtmlBlock => Ok(()),
+            TagEnd::HtmlBlock => {
+                // Record paragraph end for boundary tracking
+                // BUT skip if inside a list - list owns the paragraph boundary
+                if self.list_depth == 0 {
+                    if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
+                        let byte_range = byte_start..self.last_byte_offset;
+                        let char_range = char_start..self.last_char_offset;
+                        self.paragraph_ranges.push((byte_range, char_range));
+                    }
+                }
+
+                self.end_node();
+                self.write("</p>\n")
+            }
             TagEnd::Paragraph => {
                 // Record paragraph end for boundary tracking
                 // BUT skip if inside a list - list owns the paragraph boundary

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

···
 use jacquard::{smol_str::SmolStr, types::ident::AtIdentifier};
 use std::collections::HashSet;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
-use weaver_api::sh_weaver::notebook::{EntryView, NotebookView, entry::Entry};
+use weaver_api::sh_weaver::notebook::{
+    BookEntryRef, BookEntryView, EntryView, NotebookView, entry::Entry,
+};
+
+/// Constructs BookEntryViews from notebook entry refs and all available entries.
+///
+/// Matches StrongRefs by URI to find the corresponding EntryView,
+/// then builds BookEntryView with index and prev/next navigation refs.
+fn build_book_entry_views(
+    entry_refs: &[StrongRef<'static>],
+    all_entries: &[(EntryView<'static>, Entry<'static>)],
+) -> Vec<BookEntryView<'static>> {
+    use jacquard::IntoStatic;
+
+    // Build a lookup map for faster matching
+    let entry_map: std::collections::HashMap<&str, &EntryView<'static>> = all_entries
+        .iter()
+        .map(|(view, _)| (view.uri.as_ref(), view))
+        .collect();
+
+    let mut views = Vec::with_capacity(entry_refs.len());
+
+    for (idx, strong_ref) in entry_refs.iter().enumerate() {
+        let Some(entry_view) = entry_map.get(strong_ref.uri.as_ref()).copied() else {
+            continue;
+        };
+
+        // Build prev ref (if not first)
+        let prev = if idx > 0 {
+            entry_refs
+                .get(idx - 1)
+                .and_then(|prev_ref| entry_map.get(prev_ref.uri.as_ref()).copied())
+                .map(|prev_view| {
+                    BookEntryRef::new()
+                        .entry(prev_view.clone())
+                        .build()
+                        .into_static()
+                })
+        } else {
+            None
+        };
+
+        // Build next ref (if not last)
+        let next = if idx + 1 < entry_refs.len() {
+            entry_refs
+                .get(idx + 1)
+                .and_then(|next_ref| entry_map.get(next_ref.uri.as_ref()).copied())
+                .map(|next_view| {
+                    BookEntryRef::new()
+                        .entry(next_view.clone())
+                        .build()
+                        .into_static()
+                })
+        } else {
+            None
+        };
+
+        views.push(
+            BookEntryView::new()
+                .entry(entry_view.clone())
+                .index(idx as i64)
+                .maybe_prev(prev)
+                .maybe_next(next)
+                .build()
+                .into_static(),
+        );
+    }
+
+    views
+}
 
 /// A single item in the profile timeline (either notebook or standalone entry)
 #[derive(Clone, PartialEq)]
 pub enum ProfileTimelineItem {
     Notebook {
         notebook: NotebookView<'static>,
-        entries: Vec<StrongRef<'static>>,
+        entries: Vec<BookEntryView<'static>>,
         /// Most recent entry's created_at for sorting
         sort_date: jacquard::types::string::Datetime,
     },
···
     let auth_state = use_context::<Signal<AuthState>>();
 
     // Use client-only versions to avoid SSR issues with concurrent server futures
-    let (_profile_res, profile) = data::use_profile_data_client(ident);
-    let (_notebooks_res, notebooks) = data::use_notebooks_for_did_client(ident);
-    let (_entries_res, all_entries) = data::use_entries_for_did_client(ident);
+    let (_profile_res, profile) = data::use_profile_data(ident);
+    let (_notebooks_res, notebooks) = data::use_notebooks_for_did(ident);
+    let (_entries_res, all_entries) = data::use_entries_for_did(ident);
+
+    #[cfg(feature = "fullstack-server")]
+    {
+        _profile_res?;
+        _notebooks_res?;
+        _entries_res?;
+    }
 
     // Check if viewing own profile
     let is_own_profile = use_memo(move || {
···
             if let Some(all_ents) = ents.as_ref() {
                 for (notebook, entry_refs) in nbs {
                     if is_pinned(notebook.uri.as_ref(), pinned_set) {
-                        let sort_date = entry_refs
+                        let book_entries = build_book_entry_views(entry_refs, all_ents);
+                        let sort_date = book_entries
                             .iter()
-                            .filter_map(|r| {
+                            .filter_map(|bev| {
                                 all_ents
                                     .iter()
-                                    .find(|(v, _)| v.uri.as_ref() == r.uri.as_ref())
+                                    .find(|(v, _)| v.uri.as_ref() == bev.entry.uri.as_ref())
                             })
                             .map(|(_, entry)| entry.created_at.clone())
                             .max()
···
 
                         items.push(ProfileTimelineItem::Notebook {
                             notebook: notebook.clone(),
-                            entries: entry_refs.clone(),
+                            entries: book_entries,
                             sort_date,
                         });
                     }
···
             if let Some(all_ents) = ents.as_ref() {
                 for (notebook, entry_refs) in nbs {
                     if !is_pinned(notebook.uri.as_ref(), pinned_set) {
-                        let sort_date = entry_refs
+                        let book_entries = build_book_entry_views(entry_refs, all_ents);
+                        let sort_date = book_entries
                             .iter()
-                            .filter_map(|r| {
+                            .filter_map(|bev| {
                                 all_ents
                                     .iter()
-                                    .find(|(v, _)| v.uri.as_ref() == r.uri.as_ref())
+                                    .find(|(v, _)| v.uri.as_ref() == bev.entry.uri.as_ref())
                             })
                             .map(|(_, entry)| entry.created_at.clone())
                             .max()
···
 
                         items.push(ProfileTimelineItem::Notebook {
                             notebook: notebook.clone(),
-                            entries: entry_refs.clone(),
+                            entries: book_entries,
                             sort_date,
                         });
                     }
···
                                                             class: "pinned-item",
                                                             NotebookCard {
                                                                 notebook: notebook.clone(),
-                                                                entry_refs: entries.clone(),
+                                                                entries: entries.clone(),
                                                                 is_pinned: true,
                                                                 profile_ident: Some(ident()),
                                                             }
···
                                                         key: "notebook-{notebook.cid}",
                                                         NotebookCard {
                                                             notebook: notebook.clone(),
-                                                            entry_refs: entries.clone(),
+                                                            entries: entries.clone(),
                                                             is_pinned: false,
                                                             profile_ident: Some(ident()),
                                                         }
···
 
     let entry_view = &book_entry_view.entry;
 
-    let entry_title = entry_view.title.as_ref()
+    let entry_title = entry_view
+        .title
+        .as_ref()
         .map(|t| t.as_ref())
         .unwrap_or("Untitled");
 
-    let entry_path = entry_view.path
+    let entry_path = entry_view
+        .path
         .as_ref()
         .map(|p| p.as_ref().to_string())
         .unwrap_or_else(|| entry_title.to_string());
···
         html_buf
     });
 
-    let created_at = parsed_entry.as_ref()
+    let created_at = parsed_entry
+        .as_ref()
         .map(|entry| entry.created_at.as_ref().format("%B %d, %Y").to_string());
 
     let entry_uri = entry_view.uri.clone().into_static();
···
 #[component]
 pub fn NotebookCard(
     notebook: NotebookView<'static>,
-    entry_refs: Vec<StrongRef<'static>>,
+    entries: Vec<BookEntryView<'static>>,
     #[props(default = false)] is_pinned: bool,
     #[props(default)] show_author: Option<bool>,
     /// Profile identity for context-aware author visibility (hides single author on their own profile)
-    #[props(default)] profile_ident: Option<AtIdentifier<'static>>,
+    #[props(default)]
+    profile_ident: Option<AtIdentifier<'static>>,
     #[props(default)] on_pinned_changed: Option<EventHandler<bool>>,
     #[props(default)] on_deleted: Option<EventHandler<()>>,
 ) -> Element {
···
     let ident = notebook.uri.authority().clone().into_static();
     let book_title: SmolStr = notebook_path.clone().into();
 
-    // Fetch all entries to get first/last
-    let ident_for_fetch = ident.clone();
-    let book_title_for_fetch = book_title.clone();
-    let entries = use_resource(use_reactive!(|(ident_for_fetch, book_title_for_fetch)| {
-        let fetcher = fetcher.clone();
-        async move {
-            fetcher
-                .list_notebook_entries(ident_for_fetch, book_title_for_fetch)
-                .await
-                .ok()
-                .flatten()
-        }
-    }));
     rsx! {
         div { class: "notebook-card",
             div { class: "notebook-card-container",
···
                 }
 
                 // Entry previews section
-                if let Some(Some(entry_list)) = entries() {
                     div { class: "notebook-card-previews",
                         {
                             use jacquard::from_data;
                             use weaver_api::sh_weaver::notebook::entry::Entry;
+                            tracing::info!("rendering entries: {:?}", entries.iter().map(|e|
+                              e.entry.uri.as_ref()).collect::<Vec<_>>());
 
-                            if entry_list.len() <= 5 {
+                            if entries.len() <= 5 {
                                 // Show all entries if 5 or fewer
                                 rsx! {
-                                    for entry_view in entry_list.iter() {
+                                    for entry_view in entries.iter() {
                                         NotebookEntryPreview {
                                             book_entry_view: entry_view.clone(),
                                             ident: ident.clone(),
···
                             } else {
                                 // Show first, interstitial, and last
                                 rsx! {
-                                    if let Some(first_entry) = entry_list.first() {
+                                    if let Some(first_entry) = entries.first() {
                                         NotebookEntryPreview {
                                             book_entry_view: first_entry.clone(),
                                             ident: ident.clone(),
···
 
                                     // Interstitial showing count
                                     {
-                                        let middle_count = entry_list.len().saturating_sub(2);
+                                        let middle_count = entries.len().saturating_sub(2);
                                         rsx! {
                                             div { class: "notebook-entry-interstitial",
                                                 "... {middle_count} more "
···
                                         }
                                     }
 
-                                    if let Some(last_entry) = entry_list.last() {
+                                    if let Some(last_entry) = entries.last() {
                                         NotebookEntryPreview {
                                             book_entry_view: last_entry.clone(),
                                             ident: ident.clone(),
···
                             }
                         }
                     }
-                }
+
 
                 if let Some(ref tags) = notebook.tags {
                     if !tags.is_empty() {

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

···
                         div { class: "error", "{err}" }
                     }
                     Button {
+                        r#type: "submit",
+                        disabled: is_loading(),
+                        onclick: move |_| {
+                            submit_closure2();
+                        },
+                        if is_loading() { "Authenticating..." } else { "Sign In" }
+                    }
+                    Button {
                         r#type: "button",
                         onclick: move |_| {
                             open.set(false)
···
                         variant: ButtonVariant::Secondary,
                         "Cancel"
                     }
-                    Button {
-                        r#type: "submit",
-                        disabled: is_loading(),
-                        onclick: move |_| {
-                            submit_closure2();
-                        },
-                        if is_loading() { "Authenticating..." } else { "Sign In" }
-                    }
+
 
             }
         }

crates/weaver-app/src/data.rs

···
     book_title: ReadSignal<SmolStr>,
 ) -> (
     Result<Resource<Option<serde_json::Value>>, RenderError>,
-    Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>,
+    Memo<Option<(NotebookView<'static>, Vec<BookEntryView<'static>>)>>,
 ) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_server_future(use_reactive!(|(ident, book_title)| {
···
     let memo = use_memo(use_reactive!(|res| {
         let res = res.as_ref().ok()?;
         if let Some(Some(value)) = &*res.read() {
-            jacquard::from_json_value::<(NotebookView, Vec<StrongRef>)>(value.clone()).ok()
+            jacquard::from_json_value::<(NotebookView, Vec<BookEntryView>)>(value.clone()).ok()
         } else {
             None
         }
···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
 ) -> (
-    Resource<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>,
-    Memo<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>>,
+    Resource<Option<(NotebookView<'static>, Vec<BookEntryView<'static>>)>>,
+    Memo<Option<(NotebookView<'static>, Vec<BookEntryView<'static>>)>>,
 ) {
     let fetcher = use_context::<crate::fetch::Fetcher>();
     let res = use_resource(move || {

crates/weaver-app/src/fetch.rs

···
 use jacquard::client::AgentKind;
 use jacquard::error::ClientError;
 use jacquard::error::XrpcResult;
+use jacquard::from_data;
+use jacquard::from_data_owned;
 use jacquard::identity::JacquardResolver;
 use jacquard::identity::lexicon_resolver::{
     LexiconResolutionError, LexiconSchemaResolver, ResolvedLexiconSchema,
···
 };
 use weaver_common::WeaverError;
 use weaver_common::WeaverExt;
+use weaver_common::agent::title_matches;
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 struct UfosRecord {
···
     #[cfg(feature = "server")]
     book_cache: cache_impl::Cache<
         (AtIdentifier<'static>, SmolStr),
-        Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>,
+        Arc<(NotebookView<'static>, Vec<BookEntryView<'static>>)>,
     >,
     /// Maps notebook title OR path to ident (book_cache accepts either as key)
     #[cfg(feature = "server")]
···
         &self,
         ident: AtIdentifier<'static>,
         title: SmolStr,
-    ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+    ) -> Result<Option<Arc<(NotebookView<'static>, Vec<BookEntryView<'static>>)>>> {
         #[cfg(feature = "server")]
         if let Some(cached) = cache_impl::get(&self.book_cache, &(ident.clone(), title.clone())) {
             return Ok(Some(cached));
···
     pub async fn get_notebook_by_key(
         &self,
         key: &str,
-    ) -> Result<Option<Arc<(NotebookView<'static>, Vec<StrongRef<'static>>)>>> {
+    ) -> Result<Option<Arc<(NotebookView<'static>, Vec<BookEntryView<'static>>)>>> {
         let key: SmolStr = key.into();
 
         // Check cache first (key could be title or path)
···
 
         // Fallback: query UFOS and populate caches
         let notebooks = self.fetch_notebooks_from_ufos().await?;
-        Ok(notebooks.into_iter().find(|arc| {
+        let notebook = notebooks.into_iter().find(|arc| {
             let (view, _) = arc.as_ref();
             view.title.as_deref() == Some(key.as_str())
                 || view.path.as_deref() == Some(key.as_str())
-        }))
+        });
+        if let Some(notebook) = notebook {
+            let ident = notebook.0.uri.authority().clone().into_static();
+            return self.get_notebook(ident, key).await;
+        }
+        Ok(None)
     }
 
     pub async fn get_entry(
···
 
         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
             let (notebook, entries) = result.as_ref();
-            let client = self.get_client();
-            if let Some(entry) = client
-                .entry_by_title(notebook, entries.as_ref(), &entry_title)
-                .await
-                .map_err(|e| dioxus::CapturedError::from_display(e))?
-            {
-                let stored = Arc::new(entry);
+            if let Some(entry) = entries.iter().find(|e| {
+                if let Some(path) = e.entry.path.as_deref() {
+                    path == entry_title.as_str()
+                } else if let Some(title) = e.entry.title.as_deref() {
+                    title_matches(title, &entry_title)
+                } else {
+                    false
+                }
+            }) {
+                let stored = Arc::new((
+                    entry.clone(),
+                    from_data_owned(entry.entry.record.clone()).expect("should deserialize"),
+                ));
                 #[cfg(feature = "server")]
                 cache_impl::insert(&self.entry_cache, (ident, entry_title), stored.clone());
                 Ok(Some(stored))
···
             #[cfg(feature = "server")]
             {
                 cache_impl::insert(&self.notebook_key_cache, title.clone(), ident.clone());
+                #[cfg(not(feature = "use-index"))]
                 cache_impl::insert(&self.book_cache, (ident.clone(), title), result.clone());
+
                 if let Some(path) = result.0.path.as_ref() {
                     let path: SmolStr = path.as_ref().into();
                     cache_impl::insert(&self.notebook_key_cache, path.clone(), ident.clone());
+                    #[cfg(not(feature = "use-index"))]
                     cache_impl::insert(&self.book_cache, (ident, path), result.clone());
                 }
             }
···
                     {
                         // Cache by title
                         cache_impl::insert(&self.notebook_key_cache, title.clone(), ident.clone());
+
+                        #[cfg(not(feature = "use-index"))]
                         cache_impl::insert(
                             &self.book_cache,
                             (ident.clone(), title),
···
                                 path.clone(),
                                 ident.clone(),
                             );
+
+                            #[cfg(not(feature = "use-index"))]
                             cache_impl::insert(&self.book_cache, (ident, path), result.clone());
                         }
                     }
···
                     title.clone(),
                     ident_static.clone(),
                 );
-                cache_impl::insert(
-                    &self.book_cache,
-                    (ident_static.clone(), title),
-                    result.clone(),
-                );
                 if let Some(path) = result.0.path.as_ref() {
                     let path: SmolStr = path.as_ref().into();
                     cache_impl::insert(
···
                         path.clone(),
                         ident_static.clone(),
                     );
-                    cache_impl::insert(&self.book_cache, (ident_static, path), result.clone());
                 }
             }
             notebooks.push(result);
···
         ident: AtIdentifier<'static>,
         book_title: SmolStr,
     ) -> Result<Option<Vec<BookEntryView<'static>>>> {
-        use jacquard::types::aturi::AtUri;
-
         if let Some(result) = self.get_notebook(ident.clone(), book_title).await? {
-            let (notebook, entry_refs) = result.as_ref();
-            let mut book_entries = Vec::new();
-            let client = self.get_client();
-
-            for (index, entry_ref) in entry_refs.iter().enumerate() {
-                // Try to extract rkey from URI
-                let rkey = AtUri::new(entry_ref.uri.as_ref())
-                    .ok()
-                    .and_then(|uri| uri.rkey().map(|r| SmolStr::new(r.as_ref())));
-
-                // Check cache first
-                #[cfg(feature = "server")]
-                if let Some(ref rkey) = rkey {
-                    if let Some(cached) =
-                        cache_impl::get(&self.entry_cache, &(ident.clone(), rkey.clone()))
-                    {
-                        book_entries.push(cached.0.clone());
-                        continue;
-                    }
-                }
-
-                // Fetch if not cached
-                if let Ok(book_entry) = client.view_entry(notebook, entry_refs, index).await {
-                    // Try to populate cache by deserializing Entry from the view's record
-                    #[cfg(feature = "server")]
-                    if let Some(rkey) = rkey {
-                        use jacquard::IntoStatic;
-                        use weaver_api::sh_weaver::notebook::entry::Entry;
-                        if let Ok(entry) =
-                            jacquard::from_data::<Entry<'_>>(&book_entry.entry.record)
-                        {
-                            let cached =
-                                Arc::new((book_entry.clone().into_static(), entry.into_static()));
-                            cache_impl::insert(&self.entry_cache, (ident.clone(), rkey), cached);
-                        }
-                    }
-                    book_entries.push(book_entry);
-                }
-            }
-
-            Ok(Some(book_entries))
+            Ok(Some(result.as_ref().1.clone()))
         } else {
             Err(dioxus::CapturedError::from_display("Notebook not found"))
         }
···
         };
 
         // Find entry position in notebook
-        let book_entry_view = client
-            .entry_in_notebook_by_rkey(&notebook, &entries, &rkey)
-            .await
-            .map_err(|e| dioxus::CapturedError::from_display(e))?;
+        let book_entry_view = entries
+            .iter()
+            .find(|e| e.entry.uri.rkey().as_ref().map(|k| k.as_ref()) == Some(rkey.as_ref()));
 
         let mut book_entry_view = match book_entry_view {
-            Some(bev) => bev,
+            Some(bev) => bev.clone(),
             None => {
                 // Entry not in this notebook's entry list - return basic view without nav
                 use weaver_api::sh_weaver::notebook::BookEntryView;

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

···
     smol_str::SmolStr,
 };
 use tracing::{error, info};
+use weaver_api::sh_weaver::actor::profile::Profile as WeaverProfile;
 
 #[component]
 pub fn Callback(
···
                     .callback(callback_params)
                     .await?;
                 let (did, session_id) = session.session_info().await;
-                auth.write().set_authenticated(did, session_id);
+                let did_owned = did.into_static();
+                auth.write()
+                    .set_authenticated(did_owned.clone(), session_id);
                 fetcher.upgrade_to_authenticated(session).await;
+
+                // Create weaver profile if it doesn't exist
+                if let Err(e) = ensure_weaver_profile(&fetcher, &did_owned).await {
+                    error!("Failed to ensure weaver profile: {:?}", e);
+                }
+
                 Ok::<(), OAuthError>(())
             }
         })
···
         },
     }
 }
+
+/// Ensures a weaver profile exists for the authenticated user.
+/// If no weaver profile exists, creates one by mirroring the bsky profile.
+#[cfg(feature = "web")]
+async fn ensure_weaver_profile(
+    fetcher: &Fetcher,
+    did: &jacquard::types::string::Did<'_>,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    use jacquard::{
+        client::AgentSessionExt,
+        types::string::{Datetime, RecordKey},
+    };
+    use weaver_api::app_bsky::actor::profile::Profile as BskyProfile;
+
+    let weaver_uri_str = format!("at://{}/sh.weaver.actor.profile/self", did);
+    let weaver_uri = WeaverProfile::uri(&weaver_uri_str)?;
+
+    // Check if weaver profile already exists
+    if fetcher.fetch_record(&weaver_uri).await.is_ok() {
+        info!("Weaver profile already exists for {}", did);
+        return Ok(());
+    }
+
+    info!(
+        "No weaver profile found for {}, creating from bsky profile",
+        did
+    );
+
+    // Fetch bsky profile
+    let bsky_uri_str = format!("at://{}/app.bsky.actor.profile/self", did);
+    let bsky_uri = BskyProfile::uri(&bsky_uri_str)?;
+    let bsky_record = fetcher.fetch_record(&bsky_uri).await?;
+
+    // Create weaver profile mirroring bsky
+    let weaver_profile = WeaverProfile::new()
+        .maybe_display_name(bsky_record.value.display_name.clone())
+        .maybe_description(bsky_record.value.description.clone())
+        .maybe_avatar(bsky_record.value.avatar.clone())
+        .maybe_banner(bsky_record.value.banner.clone())
+        .bluesky(true)
+        .created_at(Datetime::now())
+        .build();
+
+    let self_rkey = RecordKey::any("self").expect("self is valid record key");
+
+    fetcher.put_record(self_rkey, weaver_profile).await?;
+    info!("Created weaver profile for {}", did);
+
+    Ok(())
+}

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

···
         Some((view, entries)) => rsx! {
             NotebookCard {
                 notebook: view.clone(),
-                entry_refs: entries.clone(),
+                entries: entries.clone(),
                 show_author: Some(true)
             }
         },

crates/weaver-common/src/agent.rs

···
 }
 
 /// Check if a search term matches a value, with fallback to stripped punctuation
-fn title_matches(value: &str, search: &str) -> bool {
+pub fn title_matches(value: &str, search: &str) -> bool {
     // Exact match first
     if value == search {
         return true;
···
         ident: &jacquard::types::ident::AtIdentifier<'_>,
         title: &str,
     ) -> impl Future<
-        Output = Result<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>, WeaverError>,
+        Output = Result<Option<(NotebookView<'static>, Vec<BookEntryView<'static>>)>, WeaverError>,
     >
     where
         Self: Sized,
···
                 .map_err(|e| AgentError::from(ClientError::from(e)))?;
 
             match resp.into_output() {
-                Ok(output) => {
-                    // Extract StrongRefs from the BookEntryViews for compatibility
-                    let entries: Vec<StrongRef<'static>> = output
-                        .entries
-                        .iter()
-                        .map(|bev| {
-                            StrongRef::new()
-                                .uri(bev.entry.uri.clone())
-                                .cid(bev.entry.cid.clone())
-                                .build()
-                                .into_static()
-                        })
-                        .collect();
-
-                    Ok(Some((output.notebook.into_static(), entries)))
-                }
+                Ok(output) => Ok(Some((
+                    output.notebook.into_static(),
+                    output.entries.into_static(),
+                ))),
                 Err(_) => Ok(None),
             }
         }
···
         ident: &jacquard::types::ident::AtIdentifier<'_>,
         title: &str,
     ) -> impl Future<
-        Output = Result<Option<(NotebookView<'static>, Vec<StrongRef<'static>>)>, WeaverError>,
+        Output = Result<Option<(NotebookView<'static>, Vec<BookEntryView<'static>>)>, WeaverError>,
     >
     where
         Self: Sized,
···
                             );
                         }
 
-                        let entries = notebook
-                            .entry_list
-                            .iter()
-                            .cloned()
-                            .map(IntoStatic::into_static)
-                            .collect();
+                        // TODO: Fix this - entries building is broken because we need NotebookView
+                        // to call view_entry but we're still building the NotebookView
+                        let entries = Vec::new(); // Temporarily empty
+
+                        // let mut entries = Vec::with_capacity(notebook.entry_list.len());
+                        // for (index, _) in notebook.entry_list.iter().enumerate() {
+                        //     let entry_view = self.view_entry(&notebook_view, &notebook.entry_list, index).await?;
+                        //     entries.push(entry_view);
+                        // }
 
                         // Fetch permissions for this notebook
                         let permissions = self.get_permissions_for_resource(&record.uri).await?;

crates/weaver-index/src/clickhouse/queries/notebooks.rs

···
     #[serde(with = "clickhouse::serde::chrono::datetime64::millis")]
     pub created_at: chrono::DateTime<chrono::Utc>,
     #[serde(with = "clickhouse::serde::chrono::datetime64::millis")]
+    pub updated_at: chrono::DateTime<chrono::Utc>,
+    #[serde(with = "clickhouse::serde::chrono::datetime64::millis")]
     pub indexed_at: chrono::DateTime<chrono::Utc>,
     pub record: SmolStr,
 }
···
     /// List entries for a specific notebook, ordered by position in the notebook.
     ///
     /// Uses notebook_entries table to get entries that belong to this notebook.
+    /// Deduplicates entries by rkey, keeping the most recently updated version.
     pub async fn list_notebook_entries(
         &self,
         notebook_did: &str,
···
         limit: u32,
         cursor: Option<u32>,
     ) -> Result<Vec<EntryRow>, IndexError> {
+        use std::collections::HashMap;
+
         let query = r#"
             SELECT
                 e.did AS did,
···
                 e.tags AS tags,
                 e.author_dids AS author_dids,
                 e.created_at AS created_at,
+                e.updated_at AS updated_at,
                 e.indexed_at AS indexed_at,
                 e.record AS record
             FROM notebook_entries ne FINAL
-            INNER JOIN entries e ON
+            INNER JOIN entries FINAL AS e ON
                 e.did = ne.entry_did
                 AND e.rkey = ne.entry_rkey
                 AND e.deleted_at = toDateTime64(0, 3)
···
             .bind(notebook_did)
             .bind(notebook_rkey)
             .bind(cursor_val)
-            .bind(limit)
+            // Fetch extra to account for duplicates we'll filter out
+            .bind(limit * 2)
             .fetch_all::<EntryRow>()
             .await
             .map_err(|e| ClickHouseError::Query {
···
                 source: e,
             })?;
 
-        Ok(rows)
+        // Dedupe by rkey, keeping the most recently updated version
+        let mut seen: HashMap<SmolStr, usize> = HashMap::new();
+        let mut deduped: Vec<EntryRow> = Vec::with_capacity(rows.len());
+
+        for row in rows {
+            if let Some(&existing_idx) = seen.get(&row.rkey) {
+                // Keep the one with the more recent updated_at
+                if row.updated_at > deduped[existing_idx].updated_at {
+                    deduped[existing_idx] = row;
+                }
+            } else {
+                seen.insert(row.rkey.clone(), deduped.len());
+                deduped.push(row);
+            }
+
+            // Stop once we have enough unique entries
+            if deduped.len() >= limit as usize {
+                break;
+            }
+        }
+
+        Ok(deduped)
     }
 
     /// Get an entry by rkey, picking the most recent version across collaborators.
···
                 tags,
                 author_dids,
                 created_at,
+                updated_at,
                 indexed_at,
                 record
             FROM entries FINAL
···
                 tags,
                 author_dids,
                 created_at,
+                updated_at,
                 indexed_at,
                 record
             FROM entries FINAL
···
                 tags,
                 author_dids,
                 created_at,
+                updated_at,
                 indexed_at,
                 record
             FROM entries FINAL
···
     ) -> Result<Vec<EntryRow>, IndexError> {
         let query = if cursor.is_some() {
             r#"
-                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, indexed_at, record
+                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record
                 FROM (
                     SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record,
                            ROW_NUMBER() OVER (PARTITION BY rkey ORDER BY updated_at DESC) as rn
···
             "#
         } else {
             r#"
-                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, indexed_at, record
+                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record
                 FROM (
                     SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record,
                            ROW_NUMBER() OVER (PARTITION BY rkey ORDER BY updated_at DESC) as rn
···
     ) -> Result<Vec<EntryRow>, IndexError> {
         let base_query = if tags.is_some() && cursor.is_some() {
             r#"
-                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, indexed_at, record
+                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record
                 FROM (
                     SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record,
                            ROW_NUMBER() OVER (PARTITION BY rkey ORDER BY updated_at DESC) as rn
···
             "#
         } else if tags.is_some() {
             r#"
-                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, indexed_at, record
+                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record
                 FROM (
                     SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record,
                            ROW_NUMBER() OVER (PARTITION BY rkey ORDER BY updated_at DESC) as rn
···
             "#
         } else if cursor.is_some() {
             r#"
-                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, indexed_at, record
+                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record
                 FROM (
                     SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record,
                            ROW_NUMBER() OVER (PARTITION BY rkey ORDER BY updated_at DESC) as rn
···
             "#
         } else {
             r#"
-                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, indexed_at, record
+                SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record
                 FROM (
                     SELECT did, rkey, cid, uri, title, path, tags, author_dids, created_at, updated_at, indexed_at, record,
                            ROW_NUMBER() OVER (PARTITION BY rkey ORDER BY updated_at DESC) as rn
···
                 e.tags AS tags,
                 e.author_dids AS author_dids,
                 e.created_at AS created_at,
+                e.updated_at AS updated_at,
                 e.indexed_at AS indexed_at,
                 e.record AS record
             FROM notebook_entries ne FINAL
-            INNER JOIN entries e ON
+            INNER JOIN entries FINAL AS e ON
                 e.did = ne.entry_did
                 AND e.rkey = ne.entry_rkey
                 AND e.deleted_at = toDateTime64(0, 3)

crates/weaver-index/src/endpoints/actor.rs

···
 use jacquard::IntoStatic;
 use jacquard::cowstr::ToCowStr;
 use jacquard::identity::resolver::IdentityResolver;
+use jacquard::prelude::*;
 use jacquard::types::ident::AtIdentifier;
 use jacquard::types::string::{AtUri, Cid, Did, Handle, Uri};
 use jacquard_axum::ExtractXrpc;
···
         })?;
 
     let Some(data) = profile_data else {
-        return Err(XrpcErrorResponse::not_found("Profile not found"));
+        // get the bluesky profile
+        // TODO: either cache this or yell at tap to start tracking their account!
+        let profile_resp = state
+            .resolver
+            .send(
+                weaver_api::app_bsky::actor::get_profile::GetProfile::new()
+                    .actor(did)
+                    .build(),
+            )
+            .await
+            .map_err(|e| XrpcErrorResponse::not_found(e.to_string()))?;
+        let bsky_profile = profile_resp
+            .into_output()
+            .map_err(|e| XrpcErrorResponse::not_found(e.to_string()))?
+            .value;
+        let inner_profile = ProfileView::new()
+            .did(bsky_profile.did)
+            .handle(bsky_profile.handle)
+            .maybe_display_name(bsky_profile.display_name)
+            .maybe_description(bsky_profile.description)
+            .maybe_avatar(bsky_profile.avatar)
+            .maybe_banner(bsky_profile.banner)
+            .build();
+
+        let inner = ProfileDataViewInner::ProfileView(Box::new(inner_profile));
+
+        let output = ProfileDataView::new().inner(inner).build();
+
+        return Ok(Json(
+            GetProfileOutput {
+                value: output,
+                extra_data: None,
+            }
+            .into_static(),
+        ));
     };
 
     // Build the response

crates/weaver-index/src/endpoints/bsky.rs

···
     State(state): State<AppState>,
     ExtractXrpc(args): ExtractXrpc<GetProfileRequest>,
 ) -> Result<Json<GetProfileOutput<'static>>, XrpcErrorResponse> {
+    // TODO: either cache this or yell at tap to start tracking their account!
     let response = state.resolver.send(args).await.map_err(|e| {
         tracing::warn!("Appview getProfile failed: {}", e);
         XrpcErrorResponse::internal_error("Failed to fetch profile from appview")

crates/weaver-index/src/endpoints/edit.rs

···
 
 /// Handle sh.weaver.edit.listDrafts
 ///
-/// Returns draft records for an actor.
+/// Returns draft records for an actor. Requires authentication.
+/// Only returns drafts if viewer is the actor or has collab permission.
 pub async fn list_drafts(
     State(state): State<AppState>,
     ExtractOptionalServiceAuth(viewer): ExtractOptionalServiceAuth,
     ExtractXrpc(args): ExtractXrpc<ListDraftsRequest>,
 ) -> Result<Json<ListDraftsOutput<'static>>, XrpcErrorResponse> {
-    let _viewer: Viewer = viewer;
+    // Require authentication
+    let viewer = viewer.ok_or_else(|| XrpcErrorResponse::auth_required("Authentication required"))?;
+    let viewer_did = viewer.did();
 
     let limit = args.limit.unwrap_or(50).min(100).max(1);
 
···
 
     // Resolve actor to DID
     let actor_did = resolve_actor(&state, &args.actor).await?;
+
+    // Permission check: viewer must be the actor (owner access)
+    // TODO: Add collab grant check for draft sharing
+    if viewer_did.as_str() != actor_did.as_str() {
+        return Err(XrpcErrorResponse::forbidden("Cannot view another user's drafts"));
+    }
 
     // Fetch drafts
     let draft_rows = state

crates/weaver-index/src/endpoints/notebook.rs

···
     let name = args.name.as_ref();
 
     let limit = args.entry_limit.unwrap_or(50).clamp(1, 100) as u32;
-    let cursor: Option<u32> = args
-        .entry_cursor
-        .as_deref()
-        .and_then(|c| c.parse().ok());
+    let cursor: Option<u32> = args.entry_cursor.as_deref().and_then(|c| c.parse().ok());
 
     // Fetch notebook first to get its rkey
     let notebook_row = state

crates/weaver-index/src/endpoints/repo.rs

···
             message: Some(message.into()),
         }
     }
+
+    pub fn auth_required(message: impl Into<String>) -> Self {
+        Self {
+            status: StatusCode::UNAUTHORIZED,
+            error: "AuthRequired".to_string(),
+            message: Some(message.into()),
+        }
+    }
+
+    pub fn forbidden(message: impl Into<String>) -> Self {
+        Self {
+            status: StatusCode::FORBIDDEN,
+            error: "Forbidden".to_string(),
+            message: Some(message.into()),
+        }
+    }
 }
 
 impl IntoResponse for XrpcErrorResponse {

crates/weaver-index/src/landing.html

···
     <body>
         <pre>
 
-    .dP'    db    `Yb                .dP'
-    dP'    db    db  88              dP'
-                88
-    `Yb d888b    'Yb     'Yb     88 d88b d88b     'Yb   `Yb    dP'
-    88P    88    88      88     88P   8Y   8b     88     Yb  dP
-    88     8P    88      88     88    8P   88     88      YbdP
-    88   .dP    .8P     .8P     88  .dP' .dP'    .8P      .8P
-    .88888888b.                  8888888888888b.         dP'  b
-                                        Y.  ,P
-                                            `""'</pre
+            `Yb.            db
+db                         `Yb        db    db
+"Ybaaaaaaaaad8'                                           Yb
+.dP'  dP'  88  `Yb d888b   'Yb `Yb    dP' `Yb.d888b       Yb        'Yb    `Yb    dP'
+88   88    88   88P    88   88   Yb  dP    88'    8Y     dPYb        88      Yb  dP
+Y8   Y8   .88   88     8P   88    YbdP     88     8P   ,dP  Yb       88       YbdP
+`Y88P`Y88P'88   88   .dP   .8P    .8P      88   ,dP  .dP'    `Yb.   .8P       .8P
+88  .88888888b.      dP'  b     88                               dP'  b
+88                   Y.  ,P     88                               Y.  ,P
+Y8.                   `""'     .8P                                `""'     </pre
         >
         <h1>Weaver Index</h1>
         <p class="subtitle">AT Protocol Record Index</p>

crates/weaver-index/src/parallel_tap.rs

···
 };
 use crate::config::{IndexerConfig, TapConfig};
 use crate::error::{ClickHouseError, Result};
-use crate::tap::{TapConfig as TapConsumerConfig, TapConsumer, TapEvent};
+use crate::tap::{
+    RecordAction, TapConfig as TapConsumerConfig, TapConsumer, TapEvent, TapRecordEvent,
+};
 
 /// Tap indexer with multiple parallel websocket connections
 ///
···
                             );
                             let raw_data = format!(
                                 r#"{{"did":"{}","collection":"{}","rkey":"{}","cid":"{}","error":"serialization_failed"}}"#,
-                                record.did, record.collection, record.rkey, record.cid
+                                record.did,
+                                record.collection,
+                                record.rkey,
+                                record
+                                    .cid
+                                    .as_ref()
+                                    .unwrap_or(&SmolStr::new_static("no cid"))
                             );
                             records
                                 .write_raw_to_dlq(
···
                     len = json.len(),
                     "writing record"
                 );
+
+                if record.action == RecordAction::Delete {
+                    let client = client.clone();
+                    let record_clone = record.clone();
+                    tokio::spawn(async move {
+                        if let Err(e) = handle_delete(&client, record_clone).await {
+                            warn!(error = ?e, "delete handling failed");
+                        }
+                    });
+                }
 
                 records
                     .write(RawRecordInsert {
                         did: record.did.clone(),
                         collection: record.collection.clone(),
                         rkey: record.rkey.clone(),
-                        cid: record.cid.clone(),
+                        cid: record.cid.clone().unwrap_or_default(),
                         rev: record.rev.clone(),
                         record: json.to_smolstr(),
                         operation: record.action.as_str().to_smolstr(),
···
 
     info!("backfill: all incremental MVs processed");
 }
+
+#[derive(Debug, Clone, clickhouse::Row, serde::Deserialize)]
+struct LookupRawRecord {
+    #[allow(dead_code)]
+    did: SmolStr,
+    #[allow(dead_code)]
+    collection: SmolStr,
+    #[allow(dead_code)]
+    cid: SmolStr,
+    #[allow(dead_code)]
+    record: SmolStr, // JSON string of the original record
+}
+
+async fn handle_delete(client: &Client, record: TapRecordEvent) -> Result<()> {
+    let deadline = Instant::now() + Duration::from_secs(15);
+
+    loop {
+        // Try to find the record by rkey
+        let query = format!(
+            r#"
+            SELECT did, collection, cid, record
+            FROM raw_records
+            WHERE did = '{}' AND rkey = '{}'
+            ORDER BY event_time DESC
+            LIMIT 1
+            "#,
+            record.did, record.rkey
+        );
+
+        let original: Option<LookupRawRecord> = client
+            .inner()
+            .query(&query)
+            .fetch_optional()
+            .await
+            .map_err(|e| crate::error::ClickHouseError::Query {
+                message: "delete lookup failed".into(),
+                source: e,
+            })?;
+
+        if let Some(original) = original {
+            // Found the record - the main insert path already handles creating
+            // the delete row, so we're done. In phase 2, this is where we'd
+            // parse original.record and insert count deltas for denormalized tables.
+            debug!(did = %record.did, cid = %original.cid, "delete found original record");
+            return Ok(());
+        }
+
+        if Instant::now() > deadline {
+            // Gave up - create stub tombstone
+            // The record will be inserted via the main batch path with operation='delete'
+            // and empty record content, which serves as our stub tombstone
+            warn!(
+                did = %record.did,
+                cid = %original.as_ref().map(|o| o.cid.clone()).unwrap_or(SmolStr::new_static("")),
+                "delete timeout, stub tombstone will be created"
+            );
+            return Ok(());
+        }
+
+        tokio::time::sleep(Duration::from_secs(1)).await;
+    }
+}

crates/weaver-index/src/tap/types.rs

···
     /// Operation: create, update, delete
     pub action: RecordAction,
     /// Content identifier
-    pub cid: SmolStr,
+    pub cid: Option<SmolStr>,
     /// The actual record data (only present for create/update)
     #[serde(default)]
     pub record: Option<serde_json::Value>,

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

···
                     self.write(&html)?;
                 }
             },
-            Html(html) | InlineHtml(html) => {
+            Html(html) => {
+                self.write(&html)?;
+            }
+            InlineHtml(html) => {
+                self.write(r#"<span class="html-embed html-embed-inline">"#)?;
                 self.write(&html)?;
+                self.write("</span>")?;
             }
             SoftBreak => self.write_newline()?,
             HardBreak => self.write("<br />\n")?,
···
 
     fn start_tag(&mut self, tag: Tag<'_>) -> Result<(), W::Error> {
         match tag {
-            Tag::HtmlBlock => Ok(()),
+            Tag::HtmlBlock => self.write(r#"<span class="html-embed html-embed-block">"#),
             Tag::Paragraph => {
                 if self.end_newline {
                     self.write("<p>")
···
                             self.consume_until_end();
                             return self.write(&html);
                         } else {
-                            tracing::debug!("[ClientWriter] No embed content from provider for {}", dest_url);
+                            tracing::debug!(
+                                "[ClientWriter] No embed content from provider for {}",
+                                dest_url
+                            );
                         }
                     } else {
                         tracing::debug!("[ClientWriter] No embed provider available");
···
     fn end_tag(&mut self, tag: markdown_weaver::TagEnd) -> Result<(), W::Error> {
         use markdown_weaver::TagEnd;
         match tag {
-            TagEnd::HtmlBlock => Ok(()),
+            TagEnd::HtmlBlock => self.write("</span>\n"),
             TagEnd::Paragraph => self.write("</p>\n"),
             TagEnd::Heading(level) => {
                 self.write("</")?;

crates/weaver-renderer/src/css.rs

···
     border-radius: 4px;
 }}
 
+/* Hygiene for iframes */
+.html-embed-block {{
+    max-width: 100%;
+    height: auto;
+    display: block;
+    margin: 1rem 0;
+}}
+
 /* AT Protocol Embeds - Container */
 /* Light mode: paper with shadow, dark mode: blueprint with borders */
 .atproto-embed {{
···
     margin-bottom: 0.75rem;
     white-space: pre-wrap;
 }}
+
+
 
 .embed-description {{
     display: block;

docker-compose.yml

···
       TAP_LOG_LEVEL: info
       TAP_OUTBOX_PARALLELISM: 5
       #TAP_FULL_NETWORK: true
-      TAP_SIGNAL_COLLECTION: place.stream.chat.profile
+      #TAP_SIGNAL_COLLECTION: place.stream.chat.profile
+      TAP_SIGNAL_COLLECTION: sh.weaver.actor.profile
       TAP_COLLECTION_FILTERS: "sh.weaver.*,app.bsky.actor.profile,sh.tangled.*,pub.leaflet.*,net.anisota.*,place.stream.*"
     healthcheck:
       test: ["CMD", "wget", "-q", "--spider", "http://localhost:2480/health"]

weaver_notes/.obsidian/workspace.json

···
   },
   "active": "6029beecc3d03bce",
   "lastOpenFiles": [
+    "weaver_index_html.png",
+    "2025-12-14T23:32:19.png",
     "diff_record.png",
     "Why I rewrote pdsls in Rust (tm).md",
     "Writing the AppView Last.md",
···
     "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_notes/Writing the AppView Last.md

···
+
 If you've been to this site before, you maybe noticed it loaded a fair bit more quickly this time. That's not really because the web server creating this HTML got a whole lot better. It did require some refactoring, but it was mostly in the vein of taking some code and adding new code that did the same thing gated behind a cargo feature. This did, however, have the side effect of, in the final binary, replacing functions that are literally hundreds of lines, that in turn call functions that may also be hundreds of lines, making several cascading network requests, with functions that look like this, which make by and large a single network request and return exactly what is required.
 
 ```rust
···
 Of course the reason is that I finally got round to building the Weaver AppView. I'm going to be calling mine the Index, because Weaver is about writing and I think "AppView" as a term kind of sucks and "index" is much more elegant, on top of being a good descriptor of what the big backend service now powering Weaver does. ![[at://did:plc:ragtjsm2j2vknwkz3zp4oxrd/app.bsky.feed.post/3lyucxfxq622w]]
 For the uninitiated, because I expect at least some people reading this aren't big into AT Protocol development, an AppView is an instance of the kind of big backend service that Bluesky PBLLC runs which powers essentially every Bluesky client, with a few notable exceptions, such as [Red Dwarf](https://reddwarf.app/), and (partially, eventually more completely) [Blacksky](https://blacksky.community/). It listens to the [Firehose](https://bsky.network/) [event stream](https://atproto.com/specs/event-stream) from the main Bluesky Relay and analyzes the data which comes through that pertains to Bluesky, producing your timeline feeds, figuring out who follows you, who you block and who blocks you (and filtering them out of your view of the app), how many people liked your last post, and so on. Because the records in your PDS (and those of all the other people on Bluesky) need context and relationship and so on to give them meaning, and then that context can be passed along to you without your app having to go collect it all. ![[at://did:plc:uu5axsmbm2or2dngy4gwchec/app.bsky.feed.post/3lsc2tzfsys2f]]
 It's a very normal backend with some weird constraints because of the protocol, and in it's practice the thing that separates the day-to-day Bluesky experience from the Mastodon experience the most. It's also by far the most centralising force in the network, because it also does moderation, and because it's quite expensive to run. A full index of all Bluesky activity takes a lot of storage (futur's Zeppelin experiment detailed above took about 16 terabytes of storage using PostgreSQL for the database and cost $200/month to run), and then it takes that much more computing power to calculate all the relationships between the data on the fly as new events come in and then serve personalized versions to everyone that uses it.
+
+
 
 It's not the only AppView out there, most atproto apps have something like this. Tangled, Streamplace, Leaflet, and so on all have substantial backends. Some (like Tangled) actually combine the front end you interact with and the AppView into a single service. But in general these are big, complicated persistent services you have to backfill from existing data to bootstrap, and they really strongly shape your app, whether they're literally part of the same executable or hosted on the same server or not. And when I started building Weaver in earnest, not only did I still have a few big unanswered questions about how I wanted Weaver to work, how it needed to work, I also didn't want to fundamentally tie it to some big server, create this centralising force. I wanted it to be possible for someone else to run it without being dependent on me personally, ideally possible even if all they had access to was a static site host like GitHub Pages or a browser runtime platform like Cloudflare Workers, so long as someone somewhere was running a couple of generic services. I wanted to be able to distribute the fullstack server version as basically just an executable in a directory of files with no other dependencies, which could easily be run in any container hosting environment with zero persistent storage required. Hell, you could technically serve it as a blob or series of blobs from your PDS with the right entry point if I did my job right.
 
···
 In contrast, notebook entry records lack links to other parts of the notebook in and of themselves because calculating them would be challenging, and updating one entry would require not just updating the entry itself and notebook it's in, but also neighbouring entries in said notebook. With the shape of collaborative publishing in Weaver, that would result in up to 4 writes to the PDS when you publish an entry, in addition to any blob uploads. And trying to link the other way in edit history (root to edit head) is similarly challenging.
 
 I anticipated some of these. but others emerged only because I ran into them while building the web app. I've had to manually fix up records more than once because I made breaking changes to my lexicons after discovering I really wanted X piece of metadata or cross-linkage. If I'd built the index first or alongside—particularly if the index remained a separate service from the web app as I intended it to, to keep the web app simple—it would likely have constrained my choices and potentially cut off certain solutions, due to the time it takes to dump the database and re-run backfill even at a very small scale. Building a big chunk of the front end first told me exactly what the index needed to provide easy access to.
+
+You can access it here: [index.weaver.sh](https://index.weaver.sh)
 # ClickHAUS
-So what does Weaver's index look like? Well it starts with either the firehose or the new Tap sync tool. The index ingests from either over a WebSocket connection, does a bit of processing (less is required when ingesting from Tap, and that's currently what I've deployed) and then dumps them in the Clickhouse database. I chose it as the primary index database on recommendation from a friend, and after doing a lot of reading. It fits atproto data well, as Graze found. Because it isolates concurrent inserts and selects so that you can just dump data in, while it cleans things up asynchronously after, it does wonderfully when you have a single major input point or a set of them to dump into that fans out, which you can then transform and then read from. 
+So what does Weaver's index look like? Well it starts with either the firehose or the new [Tap](https://docs.bsky.app/blog/introducing-tap) sync tool. The index ingests from either over a WebSocket connection, does a bit of processing (less is required when ingesting from Tap, and that's currently what I've deployed) and then dumps them in the Clickhouse database. I chose it as the primary index database on recommendation from a friend, and after doing a lot of reading. It fits atproto data well, as Graze found. Because it isolates concurrent inserts and selects so that you can just dump data in, while it cleans things up asynchronously after, it does wonderfully when you have a single major input point or a set of them to dump into that fans out, which you can then transform and then read from. 
+
+I will not claim that the tables you can find in the weaver repository are especially **good** database design overall, but they work, they're very much a work in progress, and we'll see how they scale. Also, Tap makes re-backfilling the data a hell of a lot easier.
 
-I will not claim that the tables you can find in the weaver repository are especially **good** database design overall, but they work, and we'll see how they scale. This is one of three main input tables. One for record writes, one for identity events, and one for account events.
+This is one of three main input tables. One for record writes, one for identity events, and one for account events.
 ```SQL
 CREATE TABLE IF NOT EXISTS raw_records (
     did String,
···
 ENGINE = MergeTree()
 ORDER BY (collection, did, rkey, event_time, indexed_at);
 ```
-From here we fan out into a cascading series of materialized views and other specialised tables. These break out the different record types, calculate metadata, and pull critical fields out of the record JSON for easier querying. Clickhouse's wild-ass compression means we're not too badly off replicating data on disk this way. Seriously, their JSON type ends up being the same size as a CBOR BLOB on disk in my testing, though it *does* have some quirks, as I discovered when I read back Datetime fields and got...not the format I put in. Thankfully there's a config setting for that. ![Clickhouse animation showing parallel inserts into a source table and a transformation query into a materialized view](https://clickhouse.com/docs/assets/images/incremental_materialized_view-1158726e31b08dc9808d96671239467f.gif)We also build out the list of who contributed to a published entry and determine the canonical record for it, so that fetching a fully hydrated entry with all contributor profiles only takes a couple of `SELECT` queries that themselves avoid performing extensive table scans due to reasonable choices of `ORDER BY` fields in the denormalized tables they query. And then I can do quirky things like power a profile fetch endpoint that will provide either a Weaver or a Bluesky profile, while also unifying fields so that we can easily get at the critical stuff in common. This is a relatively expensive calculation, but people thankfully don't edit their profiles that often, and this is why we don't keep the stats in the same table. 
+From here we fan out into a cascading series of materialized views and other specialised tables. These break out the different record types, calculate metadata, and pull critical fields out of the record JSON for easier querying. Clickhouse's wild-ass compression means we're not too badly off replicating data on disk this way. Seriously, their JSON type ends up being the same size as a CBOR BLOB on disk in my testing, though it *does* have some quirks, as I discovered when I read back Datetime fields and got...not the format I put in. Thankfully there's a config setting for that. ![Clickhouse animation showing parallel inserts into a source table and a transformation query into a materialized view](https://clickhouse.com/docs/assets/images/incremental_materialized_view-1158726e31b08dc9808d96671239467f.gif)We also build out the list of who contributed to a published entry and determine the canonical record for it, so that fetching a fully hydrated entry with all contributor profiles only takes a couple of `SELECT` queries that themselves avoid performing extensive table scans due to reasonable choices of `ORDER BY` fields in the denormalized tables they query and are thus very fast. And then I can do quirky things like power a profile fetch endpoint that will provide either a Weaver or a Bluesky profile, while also unifying fields so that we can easily get at the critical stuff in common. This is a relatively expensive calculation, but people thankfully don't edit their profiles that often, and this is why we don't keep the stats in the same table. 
 
 However, this is ***also*** why Clickhouse will not be the only database used in the index.
 
···
 
 If people have ideas, I'm all ears.
 
-I hope you found this interesting. I enjoyed writing it out.
+## Future
+Having this available obviously improves the performance of the app, but it also enables a lot of new stuff. I have plans for social features which would have been much harder to implement without it, and can later be backfilled into the non-indexed implementation. I have more substantial rewrites of the data fetching code planned as well, beyond the straightforward replacement I did in this first pass. And there's still a **lot** more to do on the editor before it's done.
+
+I've been joking about all sorts of ambitious things, but legitimately I think Weaver ends up being almost uniquely flexible and powerful among the atproto-based long-form writing platforms with how it's designed, and in particular how it enables people to create things together, and can end up filling some big shoes, given enough time and development effort.
+
+I hope you found this interesting. I enjoyed writing it out. There's still a lot more to do, but this was a big milestone for me. 
+
+If you'd like to support this project, there's a GitHub Sponsorship link at the bottom of the page, but honestly I'd love if you used it to write something.