more resiliency

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

···
     margin-left: auto;
 }
 
+.entry-card-stats {
+    display: flex;
+    gap: 0.5rem;
+    font-size: 0.75rem;
+    color: var(--color-muted);
+    margin-top: 0.5rem;
+}
+
+.entry-card-stats .word-count::after {
+    content: "·";
+    margin-left: 0.5rem;
+}
+
 .entry-card-tags {
     display: flex;
     gap: 0.4rem;
     flex-wrap: wrap;
+    margin-top: 0.5rem;
 }
 
 .entry-card-tag {

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

···
 
 /* Entry metadata header */
 .entry-metadata {
-    margin-bottom: calc(2rem * var(--spacing-scale, 1.5));
-    padding-bottom: calc(1rem * var(--spacing-scale, 1.5));
+    margin-bottom: calc(1rem * var(--spacing-scale, 1.5));
+    padding-bottom: calc(0.5rem * var(--spacing-scale, 1.5));
     border-bottom: 2px solid var(--color-border);
 }
 
···
 .entry-meta-info {
     display: flex;
     flex-wrap: wrap;
-    gap: calc(1.5rem * var(--spacing-scale, 1.5));
+    gap: calc(0.25rem * var(--spacing-scale, 1.5)) calc(1rem * var(--spacing-scale, 1.5));
     font-size: 0.95rem;
     color: var(--color-subtle);
 }
 
 .entry-authors,
 .entry-date,
-.entry-tags {
+.entry-tags,
+.entry-reading-stats {
     display: flex;
     align-items: center;
     font-family: var(--font-ui);
     gap: 0.5rem;
 }
 
+.entry-reading-stats {
+    color: var(--color-subtle);
+    margin-left: auto;
+    margin-top: 0.25rem;
+}
+
+.entry-reading-stats .word-count::after {
+    content: "·";
+    margin-left: 0.5rem;
+}
+
 .entry-date {
     margin-left: auto;
     font-weight: 400;
+    align-items: last baseline;
     color: var(--color-subtle);
 }
 
···
 .author-name:hover {
     color: var(--color-emphasis);
     text-decoration: underline;
+}
+
+.entry-meta-secondary {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 0.5rem 1rem;
+    flex-basis: 100%;
 }
 
 .entry-tags {

crates/weaver-app/public/editor_worker.js

···
             const ret = arg0.node;
             return ret;
         };
-        imports.wbg.__wbg_now_8a87c5466cc7d560 = function() {
-            const ret = Date.now();
-            return ret;
-        };
         imports.wbg.__wbg_now_8cf15d6e317793e1 = function(arg0) {
             const ret = arg0.now();
+            return ret;
+        };
+        imports.wbg.__wbg_now_c8bdc8efc8c495eb = function() {
+            const ret = Date.now();
             return ret;
         };
         imports.wbg.__wbg_performance_c77a440eff2efd9b = function(arg0) {
···
             const ret = arg0.versions;
             return ret;
         };
-        imports.wbg.__wbindgen_cast_1511eb630aa228f5 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 940, function: Function { arguments: [Externref], shim_idx: 941, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
-            return ret;
-        };
         imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
-            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-            const ret = getArrayU8FromWasm0(arg0, arg1);
+        imports.wbg.__wbindgen_cast_3fda284bdcf7704e = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 941, function: Function { arguments: [Externref], shim_idx: 942, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_ce6245619dc560a7 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 102, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 103, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+        imports.wbg.__wbindgen_cast_56c1ebb4e8528c2a = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 132, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 133, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         };
         imports.wbg.__wbindgen_init_externref_table = function() {

crates/weaver-app/public/embed_worker.js

···
 
     let WASM_VECTOR_LEN = 0;
 
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
+    }
+
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1) {
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1);
-    }
-
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2) {
···
         imports.wbg.__wbg_clearTimeout_15dfc3d1dcb635c6 = function() { return handleError(function (arg0, arg1) {
             arg0.clearTimeout(arg1);
         }, arguments) };
-        imports.wbg.__wbg_clearTimeout_7a42b49784aea641 = function(arg0) {
+        imports.wbg.__wbg_clearTimeout_3b6a9a13d4bde075 = function(arg0) {
             const ret = clearTimeout(arg0);
             return ret;
         };
···
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         };
-        imports.wbg.__wbg_fetch_74a3e84ebd2c9a0e = function(arg0) {
-            const ret = fetch(arg0);
-            return ret;
-        };
         imports.wbg.__wbg_fetch_90447c28cc0b095e = function(arg0, arg1) {
             const ret = arg0.fetch(arg1);
+            return ret;
+        };
+        imports.wbg.__wbg_fetch_df3fa17a5772dafb = function(arg0) {
+            const ret = fetch(arg0);
             return ret;
         };
         imports.wbg.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
···
             const ret = Promise.resolve(arg0);
             return ret;
         };
+        imports.wbg.__wbg_setTimeout_35a07631c669fbee = function(arg0, arg1) {
+            const ret = setTimeout(arg0, arg1);
+            return ret;
+        };
         imports.wbg.__wbg_setTimeout_4eb823e8b72fbe79 = function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.setTimeout(arg1, arg2);
             return ret;
         }, arguments) };
-        imports.wbg.__wbg_setTimeout_7bb3429662ab1e70 = function(arg0, arg1) {
-            const ret = setTimeout(arg0, arg1);
-            return ret;
-        };
         imports.wbg.__wbg_set_body_8e743242d6076a4f = function(arg0, arg1) {
             arg0.body = arg1;
         };
···
             const ret = arg0.value;
             return ret;
         };
+        imports.wbg.__wbindgen_cast_067e3c0104867449 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 225, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 226, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____);
+            return ret;
+        };
         imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_36dddc5933837ecc = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2216, function: Function { arguments: [Externref], shim_idx: 2217, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
-            return ret;
-        };
-        imports.wbg.__wbindgen_cast_3eeb44a0158730cb = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1188, function: Function { arguments: [], shim_idx: 1189, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        imports.wbg.__wbindgen_cast_4c40eebfb345262b = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1169, function: Function { arguments: [], shim_idx: 1170, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_b5fa8180acb99032 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1448, function: Function { arguments: [], shim_idx: 1449, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________1_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_);
+        imports.wbg.__wbindgen_cast_ba06f0048889102c = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2202, function: Function { arguments: [Externref], shim_idx: 2203, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_d976f3c9b97a6409 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 272, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 273, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____);
+        imports.wbg.__wbindgen_cast_dd8568660229206d = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1434, function: Function { arguments: [], shim_idx: 1435, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________1_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_);
             return ret;
         };
         imports.wbg.__wbindgen_init_externref_table = function() {

crates/weaver-app/src/components/author_list/author.css

···
     color: inherit;
 }
 
+.author-block .embed-author {
+    padding-bottom: 0px !important;
+}
+
 .author-block:hover .embed-author-name {
     color: var(--color-secondary);
 }

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

···
     }
 }
 
+/// Calculate word count and estimated reading time (in minutes) for content
+pub fn calculate_reading_stats(content: &str) -> (usize, usize) {
+    let word_count = content.split_whitespace().count();
+    let reading_time_mins = (word_count + 199) / 200; // ~200 wpm, rounded up
+    (word_count, reading_time_mins.max(1))
+}
+
 /// Extract a plain-text preview from markdown content (first ~160 chars)
 pub fn extract_preview(content: &str, max_len: usize) -> String {
     // Simple extraction: skip markdown syntax, get plain text
···
             // Main content area
             div { class: "entry-content-main notebook-content",
                 // Metadata header
-                EntryMetadata {
-                    entry_view: entry_view.clone(),
-                    created_at: entry_record().created_at.clone(),
-                    entry_uri: entry_view.uri.clone().into_static(),
-                    book_title: Some(book_title()),
-                    ident: ident()
+                {
+                    let (word_count, reading_time_mins) = calculate_reading_stats(&entry_record().content);
+                    rsx! {
+                        EntryMetadata {
+                            entry_view: entry_view.clone(),
+                            created_at: entry_record().created_at.clone(),
+                            entry_uri: entry_view.uri.clone().into_static(),
+                            book_title: Some(book_title()),
+                            ident: ident(),
+                            word_count: Some(word_count),
+                            reading_time_mins: Some(reading_time_mins)
+                        }
+                    }
                 }
 
                 // Rendered markdown
···
         html_buf
     });
 
+    // Calculate reading stats
+    let reading_stats = parsed_entry
+        .as_ref()
+        .map(|entry| calculate_reading_stats(&entry.content));
+
     rsx! {
         div { class: "entry-card",
             div { class: "entry-card-meta",
···
                     }
                 }
             }
+            if let Some((words, mins)) = reading_stats {
+                div { class: "entry-card-stats",
+                    span { class: "word-count", "{words} words" }
+                    span { class: "reading-time", "{mins} min read" }
+                }
+            }
         }
     }
 }
···
         html_buf
     };
 
+    // Calculate reading stats
+    let (word_count, reading_time_mins) = calculate_reading_stats(&entry.content);
+
     rsx! {
         div { class: "entry-card feed-entry-card",
             // Header: title (and date if no author)
···
                         }
                     }
                 }
+            }
+            div { class: "entry-card-stats",
+                span { class: "word-count", "{word_count} words" }
+                span { class: "reading-time", "{reading_time_mins} min read" }
             }
         }
     }
 }
 
-/// Metadata header showing title, authors, date, tags
+/// Metadata header showing title, authors, date, tags, reading stats
 #[component]
 pub fn EntryMetadata(
     entry_view: EntryView<'static>,
···
     entry_uri: AtUri<'static>,
     book_title: Option<SmolStr>,
     ident: AtIdentifier<'static>,
+    #[props(default)] word_count: Option<usize>,
+    #[props(default)] reading_time_mins: Option<usize>,
 ) -> Element {
     let navigator = use_navigator();
 
···
                     }
                 }
 
-                // Tags
-                if let Some(ref tags) = entry_view.tags {
-                    div { class: "entry-tags",
-                        // TODO: Parse tags structure
-                        span { class: "meta-label", "Tags:" }
-                        for tag in tags.iter() {
-                            span { class: "entry-tag", "{tag}" }
+                // Tags and reading stats on their own line
+                div { class: "entry-meta-secondary",
+                    if let Some(ref tags) = entry_view.tags {
+                        div { class: "entry-tags",
+                            span { class: "meta-label", "Tags:" }
+                            for tag in tags.iter() {
+                                span { class: "entry-tag", "{tag}" }
+                            }
+                        }
+                    }
+
+                    if let (Some(words), Some(mins)) = (word_count, reading_time_mins) {
+                        div { class: "entry-reading-stats",
+                            span { class: "word-count", "{words} words" }
+                            span { class: "reading-time", "{mins} min read" }
                         }
                     }
                 }

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

···
 #[allow(unused_imports)]
 pub use entry::{
     ENTRY_CSS, EntryCard, EntryMarkdown, EntryMetadata, EntryOgMeta, EntryPage, FeedEntryCard,
-    NavButton, extract_preview,
+    NavButton, calculate_reading_stats, extract_preview,
 };
 
 pub mod identity;

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

···
     rkey: ReadSignal<SmolStr>,
 ) -> Element {
     use crate::components::{
-        ENTRY_CSS, EntryMarkdown, EntryMetadata, EntryOgMeta, NavButton, extract_preview,
+        ENTRY_CSS, EntryMarkdown, EntryMetadata, EntryOgMeta, NavButton, calculate_reading_stats, extract_preview,
     };
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 
···
                         }
 
                         div { class: "entry-content-main notebook-content",
-                            EntryMetadata {
-                                entry_view: entry_view.clone(),
-                                created_at: entry_record.created_at.clone(),
-                                entry_uri: entry_view.uri.clone(),
-                                book_title: Some(book_title.clone()),
-                                ident: ident()
+                            {
+                                let (word_count, reading_time_mins) = calculate_reading_stats(&entry_record.content);
+                                rsx! {
+                                    EntryMetadata {
+                                        entry_view: entry_view.clone(),
+                                        created_at: entry_record.created_at.clone(),
+                                        entry_uri: entry_view.uri.clone(),
+                                        book_title: Some(book_title.clone()),
+                                        ident: ident(),
+                                        word_count: Some(word_count),
+                                        reading_time_mins: Some(reading_time_mins)
+                                    }
+                                }
                             }
                             EntryMarkdown { content: entry_signal, ident }
                         }
···
 
                     div { class: "entry-page-layout",
                         div { class: "entry-content-main notebook-content",
-                            EntryMetadata {
-                                entry_view: entry_view.clone(),
-                                created_at: entry_record.created_at.clone(),
-                                entry_uri: entry_view.uri.clone(),
-                                book_title: None,
-                                ident: ident()
+                            {
+                                let (word_count, reading_time_mins) = calculate_reading_stats(&entry_record.content);
+                                rsx! {
+                                    EntryMetadata {
+                                        entry_view: entry_view.clone(),
+                                        created_at: entry_record.created_at.clone(),
+                                        entry_uri: entry_view.uri.clone(),
+                                        book_title: None,
+                                        ident: ident(),
+                                        word_count: Some(word_count),
+                                        reading_time_mins: Some(reading_time_mins)
+                                    }
+                                }
                             }
                             EntryMarkdown { content: entry_signal, ident }
                         }
···
     rkey: ReadSignal<SmolStr>,
 ) -> Element {
     use crate::components::{
-        ENTRY_CSS, EntryMarkdown, EntryMetadata, EntryOgMeta, NavButton, extract_preview,
+        ENTRY_CSS, EntryMarkdown, EntryMetadata, EntryOgMeta, NavButton, calculate_reading_stats, extract_preview,
     };
     use weaver_api::sh_weaver::actor::ProfileDataViewInner;
 
···
                     }
 
                     div { class: "entry-content-main notebook-content",
-                        EntryMetadata {
-                            entry_view: entry_view.clone(),
-                            created_at: entry_record.created_at.clone(),
-                            entry_uri: entry_view.uri.clone(),
-                            book_title: Some(book_title()),
-                            ident: ident()
+                        {
+                            let (word_count, reading_time_mins) = calculate_reading_stats(&entry_record.content);
+                            rsx! {
+                                EntryMetadata {
+                                    entry_view: entry_view.clone(),
+                                    created_at: entry_record.created_at.clone(),
+                                    entry_uri: entry_view.uri.clone(),
+                                    book_title: Some(book_title()),
+                                    ident: ident(),
+                                    word_count: Some(word_count),
+                                    reading_time_mins: Some(reading_time_mins)
+                                }
+                            }
                         }
                         EntryMarkdown { content: entry_signal, ident }
                     }

crates/weaver-index/migrations/clickhouse/012_profiles_weaver_mv.sql

···
     coalesce(record.description, '') as description,
     coalesce(record.avatar.ref.`$link`, '') as avatar_cid,
     coalesce(record.banner.ref.`$link`, '') as banner_cid,
-    coalesce(toDateTime64(record.createdAt, 3), toDateTime64(0, 3)) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/014_profiles_bsky_mv.sql

···
     coalesce(record.description, '') as description,
     coalesce(record.avatar.ref.`$link`, '') as avatar_cid,
     coalesce(record.banner.ref.`$link`, '') as banner_cid,
-    coalesce(toDateTime64(record.createdAt, 3), toDateTime64(0, 3)) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/018_notebooks_mv.sql

···
     if(record.publishGlobal = true, 1, 0) as publish_global,
     arrayMap(x -> JSONExtractString(x, 'did'), JSONExtractArrayRaw(toString(record), 'authors')) as author_dids,
     length(JSONExtractArrayRaw(toString(record), 'entryList')) as entry_count,
-    coalesce(toDateTime64(record.createdAt, 3), toDateTime64(0, 3)) as created_at,
-    coalesce(toDateTime64(record.updatedAt, 3), toDateTime64(0, 3)) as updated_at,
+    parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.updatedAt), 3) as updated_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/021_entries_mv.sql

···
     JSONExtract(toString(record), 'tags', 'Array(String)') as tags,
     arrayMap(x -> JSONExtractString(x, 'did'), JSONExtractArrayRaw(toString(record), 'authors')) as author_dids,
     substring(coalesce(record.content, ''), 1, 500) as content_preview,
-    coalesce(toDateTime64(record.createdAt, 3), toDateTime64(0, 3)) as created_at,
-    coalesce(toDateTime64(record.updatedAt, 3), toDateTime64(0, 3)) as updated_at,
+    parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.updatedAt), 3) as updated_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/024_drafts_mv.sql

···
     did,
     rkey,
     cid,
-    coalesce(toDateTime64(record.createdAt, 3), toDateTime64(0, 3)) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/027_edit_diffs_mv.sql

···
     if(length(toString(record.inlineDiff)) > 0, 1, 0) as has_inline_diff,
     if(toString(record.snapshot.ref.`$link`) != '', 1, 0) as has_snapshot,
 
-    coalesce(toDateTime64(record.createdAt, 3), event_time) as created_at,
+    coalesce(parseDateTime64BestEffortOrNull(toString(record.createdAt), 3), event_time) as created_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/030_collab_invites_mv.sql

···
     toString(record.invitee) as invitee_did,
     coalesce(toString(record.scope), '') as scope,
     coalesce(toString(record.message), '') as message,
-    coalesce(toDateTime64(record.expiresAt, 3), toDateTime64(0, 3)) as expires_at,
-    coalesce(toDateTime64(record.createdAt, 3), event_time) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.expiresAt), 3) as expires_at,
+    coalesce(parseDateTime64BestEffortOrNull(toString(record.createdAt), 3), event_time) as created_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/032_collab_accepts_mv.sql

···
     splitByChar('/', replaceOne(toString(record.resource), 'at://', ''))[2] as resource_collection,
     splitByChar('/', replaceOne(toString(record.resource), 'at://', ''))[3] as resource_rkey,
 
-    coalesce(toDateTime64(record.createdAt, 3), event_time) as created_at,
+    coalesce(parseDateTime64BestEffortOrNull(toString(record.createdAt), 3), event_time) as created_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/migrations/clickhouse/034_collab_sessions_mv.sql

···
 
     toString(record.nodeId) as node_id,
     coalesce(toString(record.relayUrl), '') as relay_url,
-    coalesce(toDateTime64(record.createdAt, 3), event_time) as created_at,
-    coalesce(toDateTime64(record.expiresAt, 3), toDateTime64(0, 3)) as expires_at,
+    coalesce(parseDateTime64BestEffortOrNull(toString(record.createdAt), 3), event_time) as created_at,
+    parseDateTime64BestEffortOrZero(toString(record.expiresAt), 3) as expires_at,
     event_time,
     now64(3) as indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at

crates/weaver-index/src/clickhouse.rs

···
 mod client;
 mod migrations;
+mod resilient_inserter;
 mod schema;
 
 pub use client::{Client, TableSize};
 pub use migrations::{DbObject, MigrationResult, Migrator, ObjectType};
+pub use resilient_inserter::{InserterConfig, ResilientRecordInserter};
 pub use schema::{
     AccountRevState, FirehoseCursor, RawAccountEvent, RawEventDlq, RawIdentityEvent,
     RawRecordInsert, Tables,

crates/weaver-index/src/clickhouse/resilient_inserter.rs

···
+use std::time::Duration;
+
+use clickhouse::inserter::{Inserter, Quantities};
+use smol_str::{SmolStr, ToSmolStr};
+use tracing::{debug, warn};
+
+use super::schema::{RawEventDlq, RawRecordInsert, Tables};
+use crate::error::{ClickHouseError, IndexError};
+
+/// An inserter wrapper for RawRecordInsert that handles failures gracefully
+/// by retrying individual rows and sending failures to a dead-letter queue.
+///
+/// This is specifically for raw record inserts since that's where untrusted
+/// input (arbitrary JSON from the firehose) enters the system.
+///
+/// When a batch insert fails, this wrapper:
+/// 1. Creates a fresh inserter (since the old one is poisoned after error)
+/// 2. Retries each pending row individually
+/// 3. Sends failures to the DLQ with error details and the original row data
+/// 4. Continues processing without crashing
+pub struct ResilientRecordInserter {
+    client: clickhouse::Client,
+    inner: Inserter<RawRecordInsert>,
+    pending: Vec<RawRecordInsert>,
+    dlq: Inserter<RawEventDlq>,
+    config: InserterConfig,
+}
+
+/// Configuration for the inserter thresholds
+#[derive(Clone)]
+pub struct InserterConfig {
+    pub max_rows: u64,
+    pub max_bytes: u64,
+    pub period: Option<Duration>,
+    pub period_bias: f64,
+}
+
+impl Default for InserterConfig {
+    fn default() -> Self {
+        Self {
+            max_rows: 1000,
+            max_bytes: 1_048_576, // 1MB
+            period: Some(Duration::from_secs(1)),
+            period_bias: 0.1,
+        }
+    }
+}
+
+impl ResilientRecordInserter {
+    /// Create a new resilient inserter for raw records
+    pub fn new(client: clickhouse::Client, config: InserterConfig) -> Self {
+        let inner = Self::create_inserter(&client, &config);
+        let dlq = Self::create_dlq_inserter(&client, &config);
+
+        Self {
+            client,
+            inner,
+            pending: Vec::new(),
+            dlq,
+            config,
+        }
+    }
+
+    fn create_inserter(
+        client: &clickhouse::Client,
+        config: &InserterConfig,
+    ) -> Inserter<RawRecordInsert> {
+        let mut inserter = client
+            .inserter(Tables::RAW_RECORDS)
+            .with_max_rows(config.max_rows)
+            .with_max_bytes(config.max_bytes)
+            .with_period_bias(config.period_bias);
+
+        if let Some(period) = config.period {
+            inserter = inserter.with_period(Some(period));
+        }
+
+        inserter
+    }
+
+    fn create_dlq_inserter(
+        client: &clickhouse::Client,
+        config: &InserterConfig,
+    ) -> Inserter<RawEventDlq> {
+        let mut inserter = client
+            .inserter(Tables::RAW_EVENTS_DLQ)
+            .with_max_rows(config.max_rows)
+            .with_max_bytes(config.max_bytes)
+            .with_period_bias(config.period_bias);
+
+        if let Some(period) = config.period {
+            inserter = inserter.with_period(Some(period));
+        }
+
+        inserter
+    }
+
+    /// Write a row to the inserter
+    ///
+    /// The row is buffered both in the underlying inserter and in our
+    /// pending queue for retry on failure.
+    pub async fn write(&mut self, row: RawRecordInsert) -> Result<(), IndexError> {
+        self.inner
+            .write(&row)
+            .await
+            .map_err(|e| ClickHouseError::Insert {
+                message: "write failed".into(),
+                source: e,
+            })?;
+
+        self.pending.push(row);
+        Ok(())
+    }
+
+    /// Commit pending data if thresholds are met
+    ///
+    /// On success, clears the pending buffer if rows were actually flushed.
+    /// On failure, retries rows individually and sends failures to DLQ.
+    pub async fn commit(&mut self) -> Result<Quantities, IndexError> {
+        match self.inner.commit().await {
+            Ok(q) => {
+                if q.rows > 0 {
+                    debug!(
+                        rows = q.rows,
+                        bytes = q.bytes,
+                        "batch committed successfully"
+                    );
+                    self.pending.clear();
+                }
+                Ok(q)
+            }
+            Err(e) => {
+                warn!(
+                    error = ?e,
+                    pending = self.pending.len(),
+                    "batch commit failed, retrying individually"
+                );
+                self.handle_batch_failure(e).await
+            }
+        }
+    }
+
+    /// Force commit all pending data
+    ///
+    /// Same semantics as commit() but unconditionally flushes.
+    pub async fn force_commit(&mut self) -> Result<Quantities, IndexError> {
+        match self.inner.force_commit().await {
+            Ok(q) => {
+                if q.rows > 0 {
+                    debug!(
+                        rows = q.rows,
+                        bytes = q.bytes,
+                        "batch force-committed successfully"
+                    );
+                    self.pending.clear();
+                }
+                Ok(q)
+            }
+            Err(e) => {
+                warn!(
+                    error = ?e,
+                    pending = self.pending.len(),
+                    "batch force-commit failed, retrying individually"
+                );
+                self.handle_batch_failure(e).await
+            }
+        }
+    }
+
+    /// End the inserter, flushing all remaining data
+    ///
+    /// Consumes self. On failure, retries rows individually.
+    pub async fn end(mut self) -> Result<Quantities, IndexError> {
+        // Take ownership of inner to end it
+        let inner_result = self.inner.end().await;
+
+        match inner_result {
+            Ok(q) => {
+                debug!(
+                    rows = q.rows,
+                    bytes = q.bytes,
+                    "inserter ended successfully"
+                );
+                // Flush DLQ too
+                self.dlq.end().await.map_err(|e| ClickHouseError::Insert {
+                    message: "DLQ end failed".into(),
+                    source: e,
+                })?;
+                Ok(q)
+            }
+            Err(e) => {
+                warn!(
+                    error = ?e,
+                    pending = self.pending.len(),
+                    "inserter end failed, retrying individually"
+                );
+                // Need a fresh inserter for recovery since old one is consumed
+                self.inner = Self::create_inserter(&self.client, &self.config);
+                let result = self.handle_batch_failure(e).await;
+                // Flush DLQ
+                self.dlq.end().await.map_err(|e| ClickHouseError::Insert {
+                    message: "DLQ end failed".into(),
+                    source: e,
+                })?;
+                result
+            }
+        }
+    }
+
+    /// Get statistics on pending (unbuffered) data in the underlying inserter
+    pub fn pending(&self) -> &Quantities {
+        self.inner.pending()
+    }
+
+    /// Get count of rows in our retry buffer
+    pub fn pending_retry_count(&self) -> usize {
+        self.pending.len()
+    }
+
+    /// Handle a batch failure by retrying rows individually
+    async fn handle_batch_failure(
+        &mut self,
+        original_error: clickhouse::error::Error,
+    ) -> Result<Quantities, IndexError> {
+        // Take pending rows
+        let rows = std::mem::take(&mut self.pending);
+        let total = rows.len();
+
+        if rows.is_empty() {
+            // Nothing to retry, just propagate the error context
+            return Err(ClickHouseError::Insert {
+                message: "batch failed with no pending rows".into(),
+                source: original_error,
+            }
+            .into());
+        }
+
+        // Create fresh inserter (old one is poisoned after error)
+        self.inner = Self::create_inserter(&self.client, &self.config);
+
+        let mut succeeded = 0u64;
+        let mut failed = 0u64;
+
+        for row in rows {
+            match self.try_single_insert(&row).await {
+                Ok(()) => {
+                    succeeded += 1;
+                }
+                Err(e) => {
+                    failed += 1;
+                    warn!(
+                        did = %row.did,
+                        collection = %row.collection,
+                        rkey = %row.rkey,
+                        seq = row.seq,
+                        error = ?e,
+                        "row insert failed, sending to DLQ"
+                    );
+                    self.send_to_dlq(&row, &e).await?;
+                }
+            }
+        }
+
+        debug!(total, succeeded, failed, "batch failure recovery complete");
+
+        Ok(Quantities {
+            rows: succeeded,
+            bytes: 0,
+            transactions: 0,
+        })
+    }
+
+    /// Try to insert a single row using a fresh one-shot inserter
+    async fn try_single_insert(
+        &self,
+        row: &RawRecordInsert,
+    ) -> Result<(), clickhouse::error::Error> {
+        let mut inserter: Inserter<RawRecordInsert> =
+            self.client.inserter(Tables::RAW_RECORDS).with_max_rows(1);
+
+        inserter.write(row).await?;
+        inserter.end().await?;
+        Ok(())
+    }
+
+    /// Send a failed row to the dead-letter queue
+    async fn send_to_dlq(
+        &mut self,
+        row: &RawRecordInsert,
+        error: &clickhouse::error::Error,
+    ) -> Result<(), IndexError> {
+        let raw_data = serde_json::to_string(row)
+            .unwrap_or_else(|e| format!("{{\"serialization_error\": \"{}\"}}", e));
+
+        let dlq_row = RawEventDlq {
+            event_type: row.operation.clone(),
+            raw_data: raw_data.to_smolstr(),
+            error_message: error.to_smolstr(),
+            seq: row.seq,
+        };
+
+        self.dlq
+            .write(&dlq_row)
+            .await
+            .map_err(|e| ClickHouseError::Insert {
+                message: "DLQ write failed".into(),
+                source: e,
+            })?;
+
+        // Force commit DLQ to ensure failures are persisted immediately
+        self.dlq
+            .force_commit()
+            .await
+            .map_err(|e| ClickHouseError::Insert {
+                message: "DLQ commit failed".into(),
+                source: e,
+            })?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    // TODO: Add tests with mock clickhouse client
+}

crates/weaver-index/src/indexer.rs

···
                             source: e,
                         })?;
                     records.commit().await.map_err(|e| ClickHouseError::Query {
-                        message: format!("record commit failed for id {}", event_id),
+                        message: format!("record commit failed for id {}:\n{}", event_id, json),
                         source: e,
                     })?;
 

crates/weaver-renderer/src/css.rs

···
     display: flex;
     align-items: center;
     gap: 0.75rem;
-    margin-bottom: 0.75rem;
+    padding-bottom: 0.5rem;
 }}
 
 .embed-avatar {{

docker-compose.yml

···
   # Build from local indigo checkout, or use pre-built image
   tap:
     container_name: weaver-tap
-    build:
-      # Build from local indigo checkout on sync-tool branch
-      # git clone https://github.com/bluesky-social/indigo.git && git checkout sync-tool
-      context: ../../Git_Repos/indigo
-      dockerfile: cmd/tap/Dockerfile
+    image: ghcr.io/bluesky-social/indigo/tap:latest
     ports:
       - "2480:2480"
     volumes:
···
       TAP_DISABLE_ACKS: "false"
       TAP_LOG_LEVEL: info
       # Filter to weaver collections only
-      TAP_SIGNAL_COLLECTION: sh.weaver.edit.root
-      TAP_COLLECTION_FILTERS: "sh.weaver.*,app.bsky.actor.profile"
+      #TAP_SIGNAL_COLLECTION: sh.weaver.edit.root
+      TAP_SIGNAL_COLLECTION: sh.tangled.actor.profile
+      TAP_COLLECTION_FILTERS: "sh.weaver.*,app.bsky.actor.profile,sh.tangled.*,pub.leaflet.*"
     healthcheck:
       test: ["CMD", "wget", "-q", "--spider", "http://localhost:2480/health"]
       interval: 20s
···
       # Firehose connection (when INDEXER_SOURCE=firehose)
       FIREHOSE_RELAY_URL: wss://bsky.network
       # Collection filters
-      INDEXER_COLLECTIONS: "sh.weaver.*,app.bsky.actor.profile"
+      INDEXER_COLLECTIONS: "sh.weaver.*,app.bsky.actor.profile,sh.tangled.*,pub.leaflet.*"
     depends_on:
       tap:
         condition: service_healthy