Merge upstream develop

Author: github-actions[bot]

apps/polycentric/src/features/composer/ComposeSheetInner.tsx

@@ -185,9 +185,20 @@ export function ComposeSheetInner({
 
       resetComposer();
       await dismissSheet(DismissReason.PostSubmitted);
-      void client.sync().catch((err) => {
-        console.warn('compose sync failed:', err);
-      });
+      void client
+        .sync()
+        .then(() => {
+          // Force the feed observables to re-fetch from servers so the
+          // newly-synced post appears alongside whatever else changed.
+          // The local-post injection already showed it optimistically.
+          const identity = currentIdentityKey ?? '';
+          client.core.invalidateQuery(['following_feed', identity]);
+          client.core.invalidateQuery(['identity_feed', identity]);
+          client.core.invalidateQuery(['explore_feed', identity]);
+        })
+        .catch((err) => {
+          console.warn('compose sync failed:', err);
+        });
       // TODO
       // await onPostCreatedRef.current(signedEvent);
     } catch (err) {
@@ -202,6 +213,7 @@ export function ComposeSheetInner({
     attachments,
     submitting,
     client,
+    currentIdentityKey,
     dismissSheet,
     isReply,
     replyToEventKey,

apps/polycentric/src/features/feed/hooks/useExploreFeed.ts

@@ -1,86 +1,55 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { QueryStatus, v2 } from '@polycentric/react-native';
-import {
-  decodeV2PostBundle,
-  usePolycentricContext,
-  type PostData,
-} from '@/src/common/lib/polycentric-hooks';
-import { EMPTY_POSTS, NOOP, type FeedHookResult } from './types';
-
-type Sub = { unsubscribe: () => void };
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { Query } from '@polycentric/react-native';
+import { usePolycentricContext } from '@/src/common/lib/polycentric-hooks';
+import { type FeedHookResult, NOOP } from './types';
+import { EMPTY_FEED, useFeedsStore } from './useFeeds';
 
 export function useExploreFeed(options?: {
   perServerLimit?: number;
   enabled?: boolean;
 }): FeedHookResult {
   const { client } = usePolycentricContext();
   const enabled = options?.enabled ?? true;
-  const [items, setItems] = useState<PostData[]>(EMPTY_POSTS);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  // Hold the live subscription so we can cancel on unmount / refresh.
-  // The rust core fans out to every configured server and emits each
-  // merged response as it arrives.
-  const subscriptionRef = useRef<Sub | null>(null);
-
-  const cleanup = useCallback(() => {
-    subscriptionRef.current?.unsubscribe();
-    subscriptionRef.current = null;
-  }, []);
-
-  const fetchFeed = useCallback(() => {
-    cleanup();
-    setItems(EMPTY_POSTS);
-    setError(null);
-    setIsLoading(true);
 
-    // Rust-side merge_fn already dedupes by EventKey — each next()
-    // carries the full merged feed plus a status. `Loading` stays in
-    // effect until the last per-server response arrives.
-    const observable = client.core.getExploreFeed(
-      client.activeIdentityKey ?? undefined,
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-    );
-    subscriptionRef.current = observable.subscribe({
-      next: (result) => {
-        if (result.data) {
-          const response = v2.GetFeedResponse.fromBinary(
-            new Uint8Array(result.data),
-          );
-          const posts: PostData[] = [];
-          for (const bundle of response.eventBundles) {
-            const decoded = decodeV2PostBundle(bundle);
-            if (decoded) posts.push(decoded);
-          }
-          setItems(posts);
-        }
-        setIsLoading(result.status === QueryStatus.Loading);
-      },
-      error: (message: string) => {
-        console.warn('useExploreFeed error:', message);
-        setError(new Error(message));
-      },
-      complete: () => {
-        setIsLoading(false);
-      },
-    });
-  }, [client, cleanup]);
+  const identity = client.activeIdentityKey ?? '';
+  const feedKey = `explore:${identity}`;
+  const queryKey = useMemo(() => ['explore_feed', identity], [identity]);
+  const query = useMemo(
+    () =>
+      new Query.GetExploreFeed({
+        identity: identity === '' ? undefined : identity,
+      }),
+    [identity],
+  );
+
+  const feed = useFeedsStore((s) => s.feeds.get(feedKey) ?? EMPTY_FEED);
+  const subscribe = useFeedsStore((s) => s.subscribe);
+
+  // Re-subscribe on every mount so the rust observable re-emits cached
+  // state (instant) and `FetchMode::Default` triggers a fresh fan-out.
+  // State persists in the store across mount/unmount.
+  const unsubscribeRef = useRef<(() => void) | null>(null);
 
   useEffect(() => {
-    if (enabled) fetchFeed();
-    return cleanup;
-  }, [enabled, fetchFeed, cleanup]);
+    if (!enabled) return;
+    unsubscribeRef.current = subscribe(client, feedKey, queryKey, query);
+    return () => {
+      unsubscribeRef.current?.();
+      unsubscribeRef.current = null;
+    };
+  }, [enabled, subscribe, client, feedKey, queryKey, query]);
+
+  const refresh = useCallback(() => {
+    unsubscribeRef.current?.();
+    unsubscribeRef.current = subscribe(client, feedKey, queryKey, query);
+  }, [subscribe, client, feedKey, queryKey, query]);
 
   return {
-    items,
-    isLoading,
-    error,
+    items: feed.items,
+    isLoading: feed.isLoading,
+    error: feed.error,
     loadMore: NOOP,
     hasMore: false,
-    refresh: fetchFeed,
+    refresh,
   };
 }

apps/polycentric/src/features/feed/hooks/useFeeds.ts

@@ -0,0 +1,134 @@
+import { create } from 'zustand';
+import {
+  Query,
+  QueryStatus,
+  v2,
+  type PolycentricClient,
+} from '@polycentric/react-native';
+import {
+  decodeV2PostBundle,
+  type PostData,
+} from '@/src/common/lib/polycentric-hooks';
+
+type FeedKey = string;
+
+type Sub = { unsubscribe: () => void };
+
+export type FeedEntry = {
+  items: PostData[];
+  isLoading: boolean;
+  error: Error | null;
+};
+
+const EMPTY_ITEMS: PostData[] = [];
+
+/**
+ * Stable empty entry used as the selector fallback. Returning a fresh
+ * `{}` on each render would defeat zustand's `Object.is` short-circuit
+ * and force every consumer to re-render on any unrelated store update.
+ */
+export const EMPTY_FEED: FeedEntry = Object.freeze({
+  items: EMPTY_ITEMS,
+  isLoading: false,
+  error: null,
+});
+
+type FeedsState = {
+  feeds: Map<FeedKey, FeedEntry>;
+  setFeed: (key: FeedKey, patch: Partial<FeedEntry>) => void;
+  /**
+   * Subscribe to the underlying rust observable for `key`. Returns
+   * an unsubscribe function — the caller (the hook's `useEffect`)
+   * owns the subscription's lifetime. State stays in the store, so
+   * remount sees the cached items immediately while a fresh fan-out
+   * runs on the rust side (`FetchMode::Default` always re-fetches
+   * unless one is already in flight).
+   */
+  subscribe: (
+    client: PolycentricClient,
+    key: FeedKey,
+    queryKey: string[],
+    query: Query,
+  ) => () => void;
+  /**
+   * Prepend a locally-authored post (deduped by id). Used by the
+   * `useLocalPosts` listener so newly-created posts appear without
+   * waiting for the server round-trip.
+   */
+  insertLocal: (key: FeedKey, post: PostData) => void;
+};
+
+export const useFeedsStore = create<FeedsState>((set, get) => {
+  const writeFeed = (key: FeedKey, patch: Partial<FeedEntry>) => {
+    set((state) => {
+      const prev = state.feeds.get(key) ?? EMPTY_FEED;
+      const merged = { ...prev, ...patch };
+      // Skip the Map clone if nothing actually changed — keeps selector
+      // identity stable across no-op writes (e.g. duplicate emissions
+      // from multiple concurrent subscribers to the same key).
+      if (
+        merged.items === prev.items &&
+        merged.isLoading === prev.isLoading &&
+        merged.error === prev.error
+      ) {
+        return {};
+      }
+      const next = new Map(state.feeds);
+      next.set(key, merged);
+      return { feeds: next };
+    });
+  };
+
+  const subscribe = (
+    client: PolycentricClient,
+    key: FeedKey,
+    queryKey: string[],
+    query: Query,
+  ): (() => void) => {
+    writeFeed(key, { isLoading: true, error: null });
+
+    const observable = client.core.fetchQuery(queryKey, query, undefined);
+    const sub: Sub = observable.subscribe({
+      next: (result) => {
+        if (result.data) {
+          const response = v2.GetFeedResponse.fromBinary(
+            new Uint8Array(result.data),
+          );
+          const items: PostData[] = [];
+          for (const bundle of response.eventBundles) {
+            const decoded = decodeV2PostBundle(bundle);
+            if (decoded) items.push(decoded);
+          }
+          writeFeed(key, {
+            items,
+            isLoading: result.status === QueryStatus.Loading,
+          });
+        } else {
+          writeFeed(key, {
+            isLoading: result.status === QueryStatus.Loading,
+          });
+        }
+      },
+      error: (message: string) => {
+        console.warn(`feed ${key} error:`, message);
+        writeFeed(key, { error: new Error(message), isLoading: false });
+      },
+      complete: () => {
+        writeFeed(key, { isLoading: false });
+      },
+    });
+
+    return () => sub.unsubscribe();
+  };
+
+  return {
+    feeds: new Map(),
+    setFeed: writeFeed,
+    subscribe,
+    insertLocal: (key, post) => {
+      const prev = get().feeds.get(key) ?? EMPTY_FEED;
+      if (prev.items.some((p) => p.id === post.id)) return;
+      writeFeed(key, { items: [post, ...prev.items] });
+    },
+  };
+});