subdomain routing works

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

···
 #[component]
 pub fn AppLink(props: AppLinkProps) -> Element {
     let link_mode = use_context::<LinkMode>();
+    tracing::info!(?link_mode, "AppLink: reading LinkMode context");
     let class = props.class.clone().unwrap_or_default();
 
     match link_mode {

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

···
 #![allow(non_snake_case)]
 
-use crate::components::{AppLink, AppLinkTarget};
-use crate::Route;
 #[cfg(feature = "server")]
 use crate::blobcache::BlobCache;
 use crate::components::AuthorList;
+use crate::components::{AppLink, AppLinkTarget};
 use crate::{components::EntryActions, data::use_handle};
 use dioxus::prelude::*;
 use jacquard::types::aturi::AtUri;
···
 ) -> Element {
     // Use feature-gated hook for SSR support
     let (entry_res, entry) = crate::data::use_entry_data(ident, book_title, title);
-    let route = use_route::<Route>();
-    let mut last_route = use_signal(|| route.clone());
+
+    // Track props for change detection (works with both Route and SubdomainRoute)
+    let mut last_title = use_signal(|| title().clone());
 
     #[cfg(all(
         target_family = "wasm",
···
     let mut entry_res = entry_res?;
 
     #[cfg(feature = "fullstack-server")]
-    use_effect(use_reactive!(|route| {
-        if route != last_route() {
-            tracing::debug!("[EntryPage] route changed, restarting resource");
+    use_effect(use_reactive!(|title| {
+        if title != last_title() {
+            tracing::debug!("[EntryPage] title changed, restarting resource");
             entry_res.restart();
-            last_route.set(route.clone());
+            last_title.set(title());
         }
     }));
 

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

···
 use jacquard::oauth::session::ClientData;
 use jacquard::{oauth::types::AuthorizeOptions, smol_str::SmolStr};
 
-use crate::{CONFIG, Route};
-use crate::{
-    components::{
-        button::{Button, ButtonVariant},
-        dialog::{DialogContent, DialogRoot, DialogTitle},
-        input::Input,
-    },
-    fetch::Fetcher,
+use crate::components::{
+    button::{Button, ButtonVariant},
+    dialog::{DialogContent, DialogRoot, DialogTitle},
+    input::Input,
 };
+use crate::fetch::Fetcher;
+use crate::CONFIG;
 
 fn handle_submit(
-    full_route: Route,
+    cached_route: String,
     fetcher: Fetcher,
     mut error: Signal<Option<String>>,
     mut is_loading: Signal<bool>,
···
     #[cfg(target_arch = "wasm32")]
     {
         use gloo_storage::Storage;
-        gloo_storage::LocalStorage::set("cached_route", format!("{}", full_route)).ok();
+        gloo_storage::LocalStorage::set("cached_route", cached_route).ok();
         spawn(async move {
             match start_oauth_flow(handle, fetcher).await {
                 Ok(_) => {
···
 }
 
 #[component]
-pub fn LoginModal(open: Signal<bool>) -> Element {
+pub fn LoginModal(open: Signal<bool>, cached_route: String) -> Element {
     let mut handle_input = use_signal(|| String::new());
     let error = use_signal(|| Option::<String>::None);
     let is_loading = use_signal(|| false);
-    let full_route = use_route::<Route>();
     let fetcher = use_context::<Fetcher>();
-    let submit_route = full_route.clone();
+    let cached_route_clone = cached_route.clone();
     let submit_fetcher = fetcher.clone();
     let submit_closure1 = move || {
-        let submit_route = submit_route.clone();
+        let cached_route = cached_route_clone.clone();
         let submit_fetcher = submit_fetcher.clone();
         handle_submit(
-            submit_route,
+            cached_route,
             submit_fetcher,
             error,
             is_loading,
···
     };
 
     let submit_closure2 = move || {
-        let submit_route = full_route.clone();
+        let cached_route = cached_route.clone();
         let submit_fetcher = fetcher.clone();
         handle_submit(
-            submit_route,
+            cached_route,
             submit_fetcher,
             error,
             is_loading,

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

···
 
 use std::sync::Arc;
 
-use crate::Route;
 use crate::components::button::{Button, ButtonVariant};
 use crate::components::collab::api::{ReceivedInvite, accept_invite, fetch_received_invites};
 use crate::components::{
     BskyIcon, TangledIcon,
     avatar::{Avatar, AvatarImage},
 };
+use crate::env::WEAVER_APP_HOST;
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
···
                         use gloo_timers::future::TimeoutFuture;
                         TimeoutFuture::new(500).await;
                     }
-                    // Navigate to the entry - parse AT-URI into path segments
-                    // at://did/collection/rkey -> ["did", "collection", "rkey"]
-                    let uri_str = resource_uri_nav.to_string();
-                    let uri_parts: Vec<String> = uri_str
-                        .strip_prefix("at://")
-                        .unwrap_or(&uri_str)
-                        .split('/')
-                        .map(|s| s.to_string())
-                        .collect();
-                    nav.push(Route::RecordPage { uri: uri_parts });
+                    // Navigate to record page on main domain
+                    let url = format!("{}/record/{}", WEAVER_APP_HOST, resource_uri_nav);
+                    nav.push(url);
                 }
                 Err(e) => {
                     error.set(Some(format!("Failed: {}", e)));

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

···
 //! Actions sidebar/menubar for profile page.
 
-use crate::Route;
 use crate::auth::AuthState;
+use crate::components::app_link::{AppLink, AppLinkTarget};
 use crate::components::button::{Button, ButtonVariant};
 use dioxus::prelude::*;
 use jacquard::types::ident::AtIdentifier;
···
         aside { class: "profile-actions",
             div { class: "profile-actions-container",
                 div { class: "profile-actions-list",
-                    Link {
-                        to: Route::NewDraft { ident: ident(), notebook: None },
-                        class: "profile-action-link",
+                    AppLink {
+                        to: AppLinkTarget::NewDraft { ident: ident(), notebook: None },
+                        class: "profile-action-link".to_string(),
                         Button {
                             variant: ButtonVariant::Outline,
                             "New Entry"
···
                         "New Notebook"
                     }
 
-                    Link {
-                        to: Route::DraftsList { ident: ident() },
-                        class: "profile-action-link",
+                    AppLink {
+                        to: AppLinkTarget::Drafts { ident: ident() },
+                        class: "profile-action-link".to_string(),
                         Button {
                             variant: ButtonVariant::Ghost,
                             "Drafts"
                         }
                     }
 
-                    Link {
-                        to: Route::InvitesPage { ident: ident() },
-                        class: "profile-action-link",
+                    AppLink {
+                        to: AppLinkTarget::Invites { ident: ident() },
+                        class: "profile-action-link".to_string(),
                         Button {
                             variant: ButtonVariant::Ghost,
                             "Invites"
···
 
     rsx! {
         div { class: "profile-actions-menubar",
-            Link {
-                to: Route::NewDraft { ident: ident(), notebook: None },
+            AppLink {
+                to: AppLinkTarget::NewDraft { ident: ident(), notebook: None },
                 Button {
                     variant: ButtonVariant::Primary,
                     "New Entry"
                 }
             }
 
-            Link {
-                to: Route::DraftsList { ident: ident() },
+            AppLink {
+                to: AppLinkTarget::Drafts { ident: ident() },
                 Button {
                     variant: ButtonVariant::Ghost,
                     "Drafts"
                 }
             }
 
-            Link {
-                to: Route::InvitesPage { ident: ident() },
+            AppLink {
+                to: AppLinkTarget::Invites { ident: ident() },
                 Button {
                     variant: ButtonVariant::Ghost,
                     "Invites"

crates/weaver-app/src/data.rs

···
     ident: ReadSignal<AtIdentifier<'static>>,
     rkey: ReadSignal<SmolStr>,
 ) -> (
-    Result<Resource<Option<(serde_json::Value, serde_json::Value, Option<String>, Option<String>)>>, RenderError>,
+    Result<
+        Resource<
+            Option<(
+                serde_json::Value,
+                serde_json::Value,
+                Option<String>,
+                Option<String>,
+            )>,
+        >,
+        RenderError,
+    >,
     Memo<Option<crate::fetch::LeafletDocumentData>>,
 ) {
     use weaver_api::pub_leaflet::document::Document;
···
                 for page in &record.value.pages {
                     match page {
                         DocumentPagesItem::LinearDocument(linear_doc) => {
-                            html.push_str(&render_linear_document(linear_doc, &ctx, &fetcher).await);
+                            html.push_str(
+                                &render_linear_document(linear_doc, &ctx, &fetcher).await,
+                            );
                         }
                         DocumentPagesItem::Canvas(_) => {
                             html.push_str("<div class=\"embed-video-placeholder\">[Canvas layout not yet supported]</div>");
                         }
                         DocumentPagesItem::Unknown(_) => {
-                            html.push_str("<div class=\"embed-video-placeholder\">[Unknown page type]</div>");
+                            html.push_str(
+                                "<div class=\"embed-video-placeholder\">[Unknown page type]</div>",
+                            );
                         }
                     }
                 }
···
                 for page in &record.value.pages {
                     match page {
                         DocumentPagesItem::LinearDocument(linear_doc) => {
-                            html.push_str(&render_linear_document(linear_doc, &ctx, &fetcher).await);
+                            html.push_str(
+                                &render_linear_document(linear_doc, &ctx, &fetcher).await,
+                            );
                         }
                         DocumentPagesItem::Canvas(_) => {
                             html.push_str("<div class=\"embed-video-placeholder\">[Canvas layout not yet supported]</div>");
                         }
                         DocumentPagesItem::Unknown(_) => {
-                            html.push_str("<div class=\"embed-video-placeholder\">[Unknown page type]</div>");
+                            html.push_str(
+                                "<div class=\"embed-video-placeholder\">[Unknown page type]</div>",
+                            );
                         }
                     }
                 }
···
     ident: ReadSignal<AtIdentifier<'static>>,
     rkey: ReadSignal<SmolStr>,
 ) -> (
-    Result<Resource<Option<(serde_json::Value, serde_json::Value, Option<String>, Option<String>)>>, RenderError>,
+    Result<
+        Resource<
+            Option<(
+                serde_json::Value,
+                serde_json::Value,
+                Option<String>,
+                Option<String>,
+            )>,
+        >,
+        RenderError,
+    >,
     Memo<Option<crate::fetch::PcktDocumentData>>,
 ) {
     let fetcher = use_context::<crate::fetch::Fetcher>();

crates/weaver-app/src/lib.rs

···
           #[layout(RecordIndex)]
             #[route("/:..uri")]
             RecordPage { uri: Vec<String> },
-                     #[end_layout]
+          #[end_layout]
         #[end_nest]
         #[route("/callback?:state&:iss&:code")]
         Callback { state: SmolStr, iss: SmolStr, code: SmolStr },
···
                 #[route("/e/:rkey")]
                 NotebookEntryByRkey { ident: AtIdentifier<'static>, book_title: SmolStr, rkey: SmolStr },
                 #[route("/e/:rkey/edit")]
-                NotebookEntryEdit { ident: AtIdentifier<'static>, book_title: SmolStr, rkey: SmolStr }
-
+                NotebookEntryEdit { ident: AtIdentifier<'static>, book_title: SmolStr, rkey: SmolStr },
 }
 
 pub static CONFIG: LazyLock<Config> = LazyLock::new(|| Config {
···
                     tracing::warn!("Host header not valid UTF-8");
                     return None;
                 };
-                tracing::info!(host, "Subdomain detection: got host");
 
                 let host_str = host.split(':').next().unwrap_or(host);
                 let Some(subdomain) = extract_subdomain(host_str, WEAVER_APP_DOMAIN) else {
-                    tracing::info!(host_str, domain = WEAVER_APP_DOMAIN, "Not a subdomain request");
+                    tracing::info!(
+                        host_str,
+                        domain = WEAVER_APP_DOMAIN,
+                        "Not a subdomain request"
+                    );
                     return None;
                 };
-                tracing::info!(subdomain, "Subdomain detection: extracted subdomain");
-
                 // Look up notebook by global path
                 let result = lookup_subdomain_context(&fetcher, &subdomain).await;
                 if result.is_none() {
···
     #[cfg(feature = "fullstack-server")]
     let ctx = match &*ctx_resource.read() {
         Some(ctx) => ctx.clone(),
-        None => return rsx! { div { "Loading..." } },
+        None => {
+            return rsx! { div { "Loading..." } };
+        }
     };
 
     #[cfg(not(feature = "fullstack-server"))]
-    let ctx = None::<SubdomainContext>;
+    let ctx = { None::<SubdomainContext> };
 
     let auth_state = use_signal(|| AuthState::default());
     #[allow(unused)]
···
         });
     }
 
-    #[cfg(all(target_family = "wasm", target_os = "unknown"))]
     use_context_provider(|| restore_result);
 
     if sub == LinkMode::Subdomain {
+        tracing::info!("App: rendering SubdomainApp");
         use_context_provider(|| ctx.unwrap());
         rsx! {
              SubdomainApp {}
         }
     } else {
+        tracing::info!("App: rendering MainDomainApp");
         rsx! {
             MainDomainApp {}
         }

crates/weaver-app/src/main.rs

···
 //! Weaver App main binary.
 
+#[allow(unused)]
 use dioxus::prelude::*;
-
+#[cfg(target_arch = "wasm32")]
+use lol_alloc::{FreeListAllocator, LockedAllocator};
 #[cfg(feature = "server")]
 use std::sync::Arc;
-
 #[cfg(feature = "server")]
 use tower::Service;
-
-#[cfg(feature = "server")]
+#[allow(unused)]
 use weaver_app::{App, CONFIG, SubdomainApp, SubdomainContext, fetch};
-
-#[cfg(not(feature = "server"))]
-use weaver_app::{App, SubdomainApp};
-
-#[cfg(target_arch = "wasm32")]
-use lol_alloc::{FreeListAllocator, LockedAllocator};
-
 #[cfg(target_arch = "wasm32")]
 #[global_allocator]
 static ALLOCATOR: LockedAllocator<FreeListAllocator> =

crates/weaver-app/src/subdomain_app.rs

···
 //! Separate router for subdomain hosting with simpler route structure.
 
 use dioxus::prelude::*;
-use jacquard::oauth::client::OAuthClient;
-use jacquard::oauth::session::ClientData;
 use jacquard::smol_str::{SmolStr, ToSmolStr};
 use jacquard::types::string::AtIdentifier;
 
-use crate::auth;
-use crate::auth::{AuthState, AuthStore};
 use crate::components::identity::RepositoryIndex;
 use crate::components::{EntryPage, NotebookCss};
-use crate::host_mode::{LinkMode, SubdomainContext};
+use crate::host_mode::SubdomainContext;
 use crate::views::{NotebookEntryByRkey, NotebookEntryEdit, NotebookIndex, SubdomainNavbar};
-use crate::{CONFIG, fetch};
 
 /// Subdomain route enum - simpler paths without /:ident/:notebook prefix.
 #[derive(Debug, Clone, Routable, PartialEq)]
···
     let request = ResolveGlobalNotebook::new().path(path).build();
 
     match fetcher.send(request).await {
-        Ok(response) => {
-            let output = response.into_output().ok()?;
-            let notebook = output.notebook;
+        Ok(response) => match response.into_output() {
+            Ok(output) => {
+                let notebook = output.notebook;
 
-            let owner = notebook.uri.authority().clone().into_static();
-            let rkey = notebook.uri.rkey()?.0.to_smolstr();
-            let notebook_path = notebook
-                .path
-                .map(|p| SmolStr::new(p.as_ref()))
-                .unwrap_or_else(|| SmolStr::new(path));
+                let owner = notebook.uri.authority().clone().into_static();
+                let Some(rkey) = notebook.uri.rkey() else {
+                    tracing::warn!(path, uri = %notebook.uri, "Notebook URI missing rkey");
+                    return None;
+                };
+                let rkey = rkey.0.to_smolstr();
+                let notebook_path = notebook
+                    .path
+                    .map(|p| SmolStr::new(p.as_ref()))
+                    .unwrap_or_else(|| SmolStr::new(path));
 
-            Some(SubdomainContext {
-                owner,
-                notebook_path,
-                notebook_rkey: rkey,
-                notebook_title: notebook.title.clone().unwrap_or_default().to_smolstr(),
-            })
-        }
+                tracing::info!(path, %owner, %rkey, "Notebook lookup succeeded");
+                Some(SubdomainContext {
+                    owner,
+                    notebook_path,
+                    notebook_rkey: rkey,
+                    notebook_title: notebook.title.clone().unwrap_or_default().to_smolstr(),
+                })
+            }
+            Err(e) => {
+                tracing::warn!(path, error = %e, "Failed to parse notebook response");
+                None
+            }
+        },
         Err(e) => {
-            tracing::debug!(path = path, error = %e, "Global notebook lookup failed");
+            tracing::warn!(path, error = %e, "Global notebook lookup request failed");
             None
         }
     }

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

···
 
 /// Determines if the current route should show the full footer or just the minimal version.
 /// Full footer shows on shell pages (Home, Editor) and on owner's content pages.
-fn should_show_full_footer(route: &Route) -> bool {
+pub fn should_show_full_footer(route: &Route) -> bool {
     match route {
         // Shell pages: always show full footer
         Route::Home {}
···
 }
 
 #[component]
-pub fn Footer() -> Element {
-    let route = use_route::<Route>();
-    let show_full = should_show_full_footer(&route);
-
+pub fn Footer(#[props(default = true)] show_full: bool) -> Element {
     rsx! {
         document::Link { rel: "stylesheet", href: FOOTER_CSS }
 
···
                         rel: "noopener",
                         "Report Bug"
                     }
+
+                    span { class: "footer-separator", "|" }
+
+                    Link {
+                        to: crate::env::WEAVER_APP_HOST,
+                        class: "footer-link",
+                        "weaver.sh"
+                    }
+
                 }
             }
         }

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

···
 pub use invites::InvitesPage;
 
 mod footer;
-pub use footer::Footer;
+pub use footer::{Footer, should_show_full_footer};
 
 mod static_page;
 pub use static_page::{AboutPage, PrivacyPage, TermsPage};

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

···
 use crate::components::login::LoginModal;
 use crate::data::{use_get_handle, use_load_handle};
 use crate::fetch::Fetcher;
-use crate::views::Footer;
+use crate::views::{Footer, should_show_full_footer};
 use dioxus::prelude::*;
 use dioxus_primitives::toast::{ToastOptions, use_toast};
 use jacquard::types::ident::AtIdentifier;
···
     #[cfg(feature = "fullstack-server")]
     route_handle_res?;
 
+    #[allow(unused)]
     let fetcher = use_context::<Fetcher>();
     let mut show_login_modal = use_signal(|| false);
 
···
 
                     }
                     LoginModal {
-                        open: show_login_modal
+                        open: show_login_modal,
+                        cached_route: format!("{}", route),
                     }
                 }
             }
···
                 Outlet::<Route> {}
             }
 
-            Footer {}
+            Footer { show_full: should_show_full_footer(&route) }
         }
     }
 }

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

···
 use jacquard::types::string::{AtIdentifier, Did};
 
 use crate::SubdomainRoute;
+#[allow(unused_imports)]
 use crate::auth::{AuthState, RestoreResult};
 use crate::components::button::{Button, ButtonVariant};
 use crate::components::login::LoginModal;
 use crate::data::{use_get_handle, use_handle};
+#[allow(unused_imports)]
+use crate::env::WEAVER_APP_HOST;
 use crate::fetch::Fetcher;
 use crate::host_mode::SubdomainContext;
 use crate::views::Footer;
···
     let ctx = use_context::<SubdomainContext>();
     let route = use_route::<SubdomainRoute>();
     let auth_state = use_context::<Signal<AuthState>>();
+
+    #[allow(unused)]
     let fetcher = use_context::<Fetcher>();
     let mut show_login_modal = use_signal(|| false);
 
···
             div {
                 id: "navbar",
                 nav { class: "breadcrumbs",
-                // Notebook title links to index
-                Link {
-                    to: SubdomainRoute::SubdomainLanding {},
-                    class: "breadcrumb",
-                    "{ctx.notebook_title}"
-                }
-
-                // Show current location breadcrumb based on route
-                match &route {
-                    SubdomainRoute::SubdomainLanding {} | SubdomainRoute::SubdomainIndexPage {} => {
-                        rsx! {}
-                    }
-                    SubdomainRoute::SubdomainEntry { title } => {
-                        rsx! {
-                            span { class: "breadcrumb-separator", " > " }
-                            span { class: "breadcrumb breadcrumb-current", "{title}" }
-                        }
+                    // Notebook title links to index
+                    Link {
+                        to: SubdomainRoute::SubdomainLanding {},
+                        class: "breadcrumb",
+                        "{ctx.notebook_title}"
                     }
-                    SubdomainRoute::SubdomainEntryByRkey { rkey } => {
-                        rsx! {
-                            span { class: "breadcrumb-separator", " > " }
-                            span { class: "breadcrumb breadcrumb-current", "{rkey}" }
+
+                    // Show current location breadcrumb based on route
+                    match &route {
+                        SubdomainRoute::SubdomainLanding {} | SubdomainRoute::SubdomainIndexPage {} | SubdomainRoute::SubdomainEntryByRkey { .. } | SubdomainRoute::SubdomainEntry { .. } => {
+                            rsx! {}
                         }
-                    }
-                    SubdomainRoute::SubdomainEntryEdit { rkey } => {
-                        rsx! {
-                            span { class: "breadcrumb-separator", " > " }
-                            Link {
-                                to: SubdomainRoute::SubdomainEntryByRkey { rkey: rkey.clone() },
-                                class: "breadcrumb",
-                                "{rkey}"
+                        SubdomainRoute::SubdomainEntryEdit { rkey } => {
+                            rsx! {
+                                span { class: "breadcrumb-separator", " > " }
+                                Link {
+                                    to: SubdomainRoute::SubdomainEntryByRkey { rkey: rkey.clone() },
+                                    class: "breadcrumb",
+                                    "{rkey}"
+                                }
                             }
-                            span { class: "breadcrumb-separator", " > " }
-                            span { class: "breadcrumb breadcrumb-current", "Edit" }
                         }
-                    }
-                    SubdomainRoute::SubdomainProfile { ident } => {
-                        rsx! {
-                            span { class: "breadcrumb-separator", " > " }
-                            span { class: "breadcrumb breadcrumb-current", "@{ident}" }
+                        SubdomainRoute::SubdomainProfile { ident } => {
+                            rsx! {
+                                span { class: "breadcrumb-separator", " > " }
+                                span { class: "breadcrumb breadcrumb-current", "@{ident}" }
+                            }
                         }
                     }
                 }
-            }
-
-            // Author profile link
-            nav { class: "nav-tools",
-                AuthorProfileLink { ident: ctx.owner.clone() }
-            }
+                // Author profile link
+                nav { class: "nav-tools",
+                    AuthorProfileLink { ident: ctx.owner.clone() }
+                }
 
                 // Auth button
                 if auth_state.read().is_authenticated() {
···
                         }
                     }
                     LoginModal {
-                        open: show_login_modal
+                        open: show_login_modal,
+                        cached_route: format!("{}", route),
                     }
                 }
             }
 
+
+
+
             main { class: "app-main",
                 Outlet::<SubdomainRoute> {}
             }
 
-            Footer {}
+            Footer { show_full: false }
         }
     }
 }
···
     let (handle_res, handle) = use_handle(ident);
 
     #[cfg(feature = "fullstack-server")]
-    let mut handle_res = handle_res?;
+    handle_res?;
 
     rsx! {
         Link {

crates/weaver-index/migrations/clickhouse/009_handle_mappings_identity_mv.sql

···
     'active' as account_status,
     'identity' as source,
     event_time,
-    now64(3) as indexed_at
+    indexed_at
 FROM raw_identity_events
 WHERE handle != ''

crates/weaver-index/migrations/clickhouse/010_handle_mappings_account_mv.sql

···
     a.status as account_status,
     'account' as source,
     a.event_time,
-    now64(3) as indexed_at
+    a.indexed_at
 FROM raw_account_events a
 INNER JOIN handle_mappings h ON h.did = a.did AND h.freed = 0
 WHERE a.active = 0 AND a.status != ''

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

···
     coalesce(record.banner.ref.`$link`, '') as banner_cid,
     parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.actor.profile'

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

···
     coalesce(record.banner.ref.`$link`, '') as banner_cid,
     parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'app.bsky.actor.profile'

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

···
     parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     parseDateTime64BestEffortOrZero(toString(record.updatedAt), 3) as updated_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at,
     record
 FROM raw_records

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

···
     parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     parseDateTime64BestEffortOrZero(toString(record.updatedAt), 3) as updated_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at,
     record
 FROM raw_records

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

···
     cid,
     parseDateTime64BestEffortOrZero(toString(record.createdAt), 3) as created_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.edit.draft'

crates/weaver-index/migrations/clickhouse/026_edit_roots_mv.sql

···
 
     event_time as created_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.edit.root'

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

···
 
     coalesce(parseDateTime64BestEffortOrNull(toString(record.createdAt), 3), event_time) as created_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.edit.diff'

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

···
     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,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.collab.invite'

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

···
 
     coalesce(parseDateTime64BestEffortOrNull(toString(record.createdAt), 3), event_time) as created_at,
     event_time,
-    now64(3) as indexed_at,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.collab.accept'

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

···
     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,
+    indexed_at,
     if(operation = 'delete', event_time, toDateTime64(0, 3)) as deleted_at
 FROM raw_records
 WHERE collection = 'sh.weaver.collab.session'

crates/weaver-index/migrations/clickhouse/039_notebook_entries_mv.sql

···
     -- Position from array index
     assumeNotNull(entry_position) as position,
 
-    now64(3) as indexed_at
+    indexed_at
 FROM notebooks
 ARRAY JOIN
     record.entryList[].uri as entry_uri,

docker-compose.yml

···
       #TAP_FULL_NETWORK: true
       #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.*"
+      TAP_COLLECTION_FILTERS: "sh.weaver.*,app.bsky.actor.profile,sh.tangled.*,pub.leaflet.*,net.anisota.*,place.stream.*,site.standard.*"
     healthcheck:
       test: ["CMD", "wget", "-q", "--spider", "http://localhost:2480/health"]
       interval: 20s
···
       TAP_URL: ws://tap:2480/channel
       TAP_SEND_ACKS: "true"
       FIREHOSE_RELAY_URL: wss://bsky.network
-      INDEXER_COLLECTIONS: "sh.weaver.*,app.bsky.actor.profile,sh.tangled.*,pub.leaflet.*,net.anisota.*,place.stream.*"
+      INDEXER_COLLECTIONS: "sh.weaver.*,app.bsky.actor.profile,sh.tangled.*,pub.leaflet.*,net.anisota.*,place.stream.*,site.standard.*"
     depends_on:
       tap:
         condition: service_healthy