Improve inbox thread updates

desktop/src/app/AppShell.tsx

@@ -16,8 +16,10 @@ import {
 import { AppTopChrome } from "@/app/AppTopChrome";
 import { useAppNavigation } from "@/app/navigation/useAppNavigation";
 import { useBackForwardControls } from "@/app/navigation/useBackForwardControls";
+import { useLiveHomeFeedActions } from "@/app/useLiveHomeFeedActions";
 import { useMarkAsReadShortcuts } from "@/app/useMarkAsReadShortcuts";
 import { useSettingsShortcuts } from "@/app/useSettingsShortcuts";
+import { useThreadActivityFeedItems } from "@/app/useThreadActivityFeedItems";
 import { useWebviewZoomShortcuts } from "@/app/useWebviewZoomShortcuts";
 import {
   channelsQueryKey,
@@ -28,6 +30,7 @@ import {
 } from "@/features/channels/hooks";
 import { useUnreadChannels } from "@/features/channels/useUnreadChannels";
 import { useMembershipNotifications } from "@/features/channels/useMembershipNotifications";
+import { useFeedItemState } from "@/features/home/useFeedItemState";
 import { getThreadReference } from "@/features/messages/lib/threading";
 import { hasMentionForEvent } from "@/features/notifications/lib/shouldNotify";
 import { useThreadFollows } from "@/features/messages/lib/useThreadFollows";
@@ -161,13 +164,18 @@ export function AppShell() {
   const setUserStatusMutation = useSetUserStatusMutation(deferredPubkey);
   const { feedProfilesQuery, homeFeedQuery, notificationSettings } =
     useHomeFeedNotifications(identityQuery.data?.pubkey);
+  const feedItemState = useFeedItemState(identityQuery.data?.pubkey);
   useReminderNotifications(
     identityQuery.data?.pubkey,
     notificationSettings.settings,
   );
-  const refetchHomeFeedOnLiveMention = React.useEffectEvent(() => {
+  const refetchHomeFeedFromLiveSignal = React.useEffectEvent(() => {
     void homeFeedQuery.refetch();
   });
+  useLiveHomeFeedActions(
+    identityQuery.data?.pubkey,
+    refetchHomeFeedFromLiveSignal,
+  );
   const handleChannelNotification = React.useEffectEvent(
     (_channelId: string, _event: RelayEvent) => {
       if (!notificationSettings.settings.desktopEnabled) return;
@@ -306,7 +314,9 @@ export function AppShell() {
     unreadChannelIds,
     unreadChannelCounts,
     highPriorityUnreadChannelIds,
+    unreadChannelNotificationCount,
     getEffectiveTimestamp: getChannelReadAt,
+    getOwnTimestamp: getOwnReadAt,
     readStateVersion,
     setContextParentResolver,
     participatedRootIds,
@@ -324,14 +334,28 @@ export function AppShell() {
     notifyForActiveChannel: notificationSettings.settings.notifyWhileViewing,
     onChannelMessage: handleChannelNotification,
     onDmMessage: handleDmNotification,
-    onLiveMention: refetchHomeFeedOnLiveMention,
+    onLiveMention: refetchHomeFeedFromLiveSignal,
     onThreadReplyDesktopNotification: handleThreadReplyDesktopNotification,
     followedRootIds,
   });
 
   const getThreadReadAt = React.useCallback(
-    (rootId: string) => getChannelReadAt(`thread:${rootId}`),
-    [getChannelReadAt],
+    (rootId: string, channelId?: string | null) => {
+      const threadReadAt = getOwnReadAt(`thread:${rootId}`);
+      if (!channelId) {
+        return threadReadAt;
+      }
+
+      const channelReadAt = getChannelReadAt(channelId);
+      if (threadReadAt === null) {
+        return channelReadAt;
+      }
+      if (channelReadAt === null) {
+        return threadReadAt;
+      }
+      return Math.max(threadReadAt, channelReadAt);
+    },
+    [getChannelReadAt, getOwnReadAt],
   );
 
   const markThreadRead = React.useCallback(
@@ -343,6 +367,11 @@ export function AppShell() {
     },
     [markChannelRead],
   );
+  const threadActivityFeedItems = useThreadActivityFeedItems(
+    threadActivityItems,
+    mutedRootIds,
+    channels,
+  );
 
   // Badge count is computed here (rather than inside useHomeFeedNotifications)
   // so it can consume the NIP-RS read-state lifted from the single
@@ -361,6 +390,9 @@ export function AppShell() {
       highPriorityUnreadChannelIds,
       feedProfilesQuery.data?.profiles,
       mutedChannelIds,
+      feedItemState.unreadSet,
+      threadActivityFeedItems,
+      getThreadReadAt,
     );
 
   const isNotifiedForThread = React.useCallback(
@@ -537,19 +569,13 @@ export function AppShell() {
 
   React.useEffect(() => {
     const numericCount =
-      highPriorityUnreadChannelIds.size + homeBadgeCountExcludingHighPriority;
+      unreadChannelNotificationCount + homeBadgeCountExcludingHighPriority;
     if (numericCount > 0) {
       void setDesktopAppBadge({ kind: "count", count: numericCount });
-    } else if (unreadChannelIds.size > 0) {
-      void setDesktopAppBadge({ kind: "dot" });
     } else {
       void setDesktopAppBadge({ kind: "none" });
     }
-  }, [
-    homeBadgeCountExcludingHighPriority,
-    highPriorityUnreadChannelIds.size,
-    unreadChannelIds.size,
-  ]);
+  }, [homeBadgeCountExcludingHighPriority, unreadChannelNotificationCount]);
 
   // Dispatch `buzz://message` deep links into the router.
   useMessageDeepLinks();
@@ -707,7 +733,9 @@ export function AppShell() {
             unfollowThread: handleUnfollowThread,
             isFollowingThread,
             isNotifiedForThread,
+            isThreadMuted: (rootId) => mutedRootIds.has(rootId),
             threadActivityItems,
+            feedItemState,
           }}
         >
           <HuddleProvider>

desktop/src/app/AppShellContext.tsx

@@ -1,6 +1,9 @@
 import * as React from "react";
 import type { ContextParentResolver } from "@/features/channels/readState/readStateManager";
 import type { ThreadActivityItem } from "@/features/channels/useUnreadChannels";
+import type { FeedItemState } from "@/features/home/useFeedItemState";
+
+const EMPTY_SET = new Set<string>();
 
 type AppShellContextValue = {
   markAllChannelsRead: () => void;
@@ -18,7 +21,7 @@ type AppShellContextValue = {
   getChannelReadAt: (channelId: string) => number | null;
   // Thread read frontier as unix-seconds timestamp, or null when never read.
   // Uses `thread:<rootId>` context keys in the same ReadStateManager.
-  getThreadReadAt: (rootId: string) => number | null;
+  getThreadReadAt: (rootId: string, channelId?: string | null) => number | null;
   // Advance the thread read frontier to the given unix-seconds timestamp.
   markThreadRead: (rootId: string, timestamp: number) => void;
   // Bump-counter that invalidates whenever the read marker changes. Include
@@ -31,7 +34,9 @@ type AppShellContextValue = {
   unfollowThread: (rootId: string) => void;
   isFollowingThread: (rootId: string) => boolean;
   isNotifiedForThread: (rootId: string) => boolean;
+  isThreadMuted: (rootId: string) => boolean;
   threadActivityItems: ThreadActivityItem[];
+  feedItemState: FeedItemState;
 };
 
 const AppShellContext = React.createContext<AppShellContextValue>({
@@ -49,7 +54,16 @@ const AppShellContext = React.createContext<AppShellContextValue>({
   unfollowThread: () => {},
   isFollowingThread: () => false,
   isNotifiedForThread: () => false,
+  isThreadMuted: () => false,
   threadActivityItems: [],
+  feedItemState: {
+    doneSet: EMPTY_SET,
+    markDone: () => {},
+    markUnread: () => {},
+    undoDone: () => {},
+    undoUnread: () => {},
+    unreadSet: EMPTY_SET,
+  },
 });
 
 export function AppShellProvider({

desktop/src/app/routes/ChannelRouteScreen.tsx

@@ -4,6 +4,10 @@ import { getCachedSearchHitEvent } from "@/app/navigation/searchHitEventCache";
 import { useAppNavigation } from "@/app/navigation/useAppNavigation";
 import { useChannelsQuery } from "@/features/channels/hooks";
 import { ChannelScreen } from "@/features/channels/ui/ChannelScreen";
+import {
+  getThreadReference,
+  isBroadcastReply,
+} from "@/features/messages/lib/threading";
 import { useProfileQuery } from "@/features/profile/hooks";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import { getEventById } from "@/shared/api/tauri";
@@ -18,6 +22,77 @@ type ChannelRouteScreenProps = {
   targetThreadRootId: string | null;
 };
 
+const MAX_ROUTE_ANCESTOR_HOPS = 50;
+
+async function fetchRouteEvent(eventId: string): Promise<RelayEvent | null> {
+  try {
+    return await getEventById(eventId);
+  } catch (error) {
+    console.error("Failed to load route event", eventId, error);
+    return null;
+  }
+}
+
+function getReplyParentId(event: RelayEvent): string | null {
+  if (isBroadcastReply(event.tags)) {
+    return null;
+  }
+
+  return getThreadReference(event.tags).parentId;
+}
+
+async function fetchRouteTargetEvents(
+  eventIds: string[],
+  targetMessageId: string | null,
+  targetThreadRootId: string | null,
+): Promise<RelayEvent[]> {
+  const eventsById = new Map<string, RelayEvent>();
+  const addEvent = (event: RelayEvent | null) => {
+    if (event) {
+      eventsById.set(event.id, event);
+    }
+  };
+
+  const uniqueEventIds = [...new Set(eventIds)];
+  const initialEvents = await Promise.all(uniqueEventIds.map(fetchRouteEvent));
+  for (const event of initialEvents) {
+    addEvent(event);
+  }
+
+  const targetEvent = targetMessageId
+    ? (eventsById.get(targetMessageId) ?? null)
+    : null;
+  if (!targetEvent) {
+    return [...eventsById.values()];
+  }
+
+  const targetThreadRef = getThreadReference(targetEvent.tags);
+  const threadRootId = targetThreadRootId ?? targetThreadRef.rootId ?? null;
+  if (threadRootId && !eventsById.has(threadRootId)) {
+    addEvent(await fetchRouteEvent(threadRootId));
+  }
+
+  let parentId = getReplyParentId(targetEvent);
+  let guard = 0;
+  while (
+    parentId &&
+    parentId !== threadRootId &&
+    guard < MAX_ROUTE_ANCESTOR_HOPS
+  ) {
+    const parentEvent =
+      eventsById.get(parentId) ?? (await fetchRouteEvent(parentId));
+    if (!parentEvent) {
+      break;
+    }
+
+    eventsById.set(parentEvent.id, parentEvent);
+    parentId = getReplyParentId(parentEvent);
+    guard += 1;
+  }
+
+  return [...eventsById.values()];
+}
+
 export function ChannelRouteScreen({
   channelId,
   selectedPostId,
@@ -87,23 +162,15 @@ export function ChannelRouteScreen({
         : null,
     ].filter((eventId): eventId is string => eventId !== null);
 
-    void Promise.all(
-      eventIds.map(async (eventId) => {
-        try {
-          return await getEventById(eventId);
-        } catch (error) {
-          console.error("Failed to load route event", eventId, error);
-          return null;
-        }
-      }),
+    void fetchRouteTargetEvents(
+      eventIds,
+      targetMessageId,
+      targetThreadRootId,
     ).then((events) => {
       if (!isCancelled) {
         setTargetMessageEvents((currentEvents) => {
-          const fetchedEvents = events.filter(
-            (event): event is RelayEvent => event !== null,
-          );
           const eventsById = new Map<string, RelayEvent>();
-          for (const event of [...currentEvents, ...fetchedEvents]) {
+          for (const event of [...currentEvents, ...events]) {
             eventsById.set(event.id, event);
           }
           return Array.from(eventsById.values());

desktop/src/app/routes/index.tsx

@@ -79,11 +79,8 @@ function HomeRouteComponent() {
     <HomeScreen
       availableChannelIds={availableChannelIds}
       currentPubkey={identityQuery.data?.pubkey}
-      onOpenChannel={(channelId) => {
-        void goChannel(channelId);
-      }}
-      onOpenContext={(channelId, messageId) => {
-        void goChannel(channelId, { messageId });
+      onOpenContext={(channelId, messageId, threadRootId) => {
+        void goChannel(channelId, { messageId, threadRootId });
       }}
     />
   );