Scope the partial-index warning to the room being searched

The warning was driven by `currentRoom() !== null`, which is a global signal:
it is non-null while the crawler has any outstanding checkpoint for any room.
Searching a fully-crawled room while an unrelated room was still being crawled
therefore claimed the results may be incomplete when they were not.

Drive it from `crawlingRooms()` instead, which reports the rooms with
outstanding checkpoints by id, and pass the search scope and room id in from
RoomSearchAuxPanel: a room-scoped search now asks only about that room, while
an all-rooms search still reacts to any outstanding checkpoint. Using room ids
throughout also avoids `currentRoom()` returning null, and so under-reporting a
crawl, when the js-sdk does not know the room at the head of the queue.

The `changedCheckpoint` payload only carries the globally-current room and
cannot answer a per-room question, so the handler re-reads the checkpoint set.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: hayaksi1

apps/web/src/components/views/elements/SearchWarning.tsx

@@ -6,12 +6,12 @@ SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Com
 Please see LICENSE files in the repository root for full details.
 */
 
-import React, { type JSX, type ReactNode, useEffect, useState } from "react";
+import React, { type JSX, type ReactNode, useCallback, useEffect, useState } from "react";
 import { logger } from "matrix-js-sdk/src/logger";
-import { type Room } from "matrix-js-sdk/src/matrix";
 
 import EventIndexPeg from "../../../indexing/EventIndexPeg";
 import type EventIndex from "../../../indexing/EventIndex";
+import { SearchScope } from "../../../Searching";
 import { _t } from "../../../languageHandler";
 import SdkConfig from "../../../SdkConfig";
 import dis from "../../../dispatcher/dispatcher";
@@ -28,55 +28,77 @@ interface IProps {
     isRoomEncrypted?: boolean;
     kind: WarningKind;
     showLogo?: boolean;
+    /** The scope of the search being warned about; only meaningful for {@link WarningKind.Search}. */
+    scope?: SearchScope;
+    /** The room being searched. Mirrors `SearchInfo.roomId`: `undefined` when searching all rooms. */
+    roomId?: string;
 }
 
 /**
- * Track whether the given event index is still crawling not-yet-indexed history.
+ * Track whether the index still has history left to crawl that is relevant to the given search.
  *
- * The index reports its progress via `currentRoom()`, which returns the room currently being
- * crawled, or `null` once every checkpoint has drained and the index is fully built. It emits a
- * `changedCheckpoint` event whenever that progresses, so we subscribe to it and re-evaluate, which
- * means the warning auto-clears the moment indexing finishes.
+ * Seshat has no notion of a room being *fully* indexed: {@link EventIndex.isRoomIndexed} only
+ * reports whether the index holds any events for a room, not whether it holds all of them. The
+ * closest available signal is whether the crawler still holds an outstanding checkpoint for the
+ * room, exposed via {@link EventIndex.crawlingRooms}. A room-scoped search therefore asks about
+ * that room alone, while an all-rooms search is affected by any outstanding checkpoint.
+ *
+ * Note that the absence of a checkpoint is not proof of completeness: a room also has no
+ * checkpoint if it never had a back-pagination token to crawl from, if its checkpoint was dropped
+ * because the server rejected the request, or before the initial checkpoints have been seeded. So
+ * this signal under-warns rather than over-warns.
+ *
+ * The index emits `changedCheckpoint` on each checkpoint transition, but the payload carries only
+ * the globally-current room, so we re-read the checkpoint set on each event rather than trust it.
  *
  * @param index The event index to observe, or `null` if there is no index.
- * @returns `true` while the crawl is still in progress, `false` otherwise.
+ * @param scope The scope of the search, if this warning is being rendered for one.
+ * @param roomId The room being searched, or `undefined` when searching all rooms.
+ * @returns `true` while history relevant to the search is still being crawled, `false` otherwise.
  */
-function useIsCrawlInProgress(index: EventIndex | null): boolean {
-    const [crawlInProgress, setCrawlInProgress] = useState<boolean>(() =>
-        index ? index.currentRoom() !== null : false,
-    );
+function useIsCrawlInProgress(index: EventIndex | null, scope?: SearchScope, roomId?: string): boolean {
+    const readCrawlInProgress = useCallback((): boolean => {
+        if (!index) return false;
+        const { crawlingRooms } = index.crawlingRooms();
+        // Fall back to the global check when we don't know which room is being searched: the room
+        // id may still be undefined while a room alias is being resolved.
+        if (scope !== SearchScope.Room || roomId === undefined) return crawlingRooms.size > 0;
+        return crawlingRooms.has(roomId);
+    }, [index, scope, roomId]);
+
+    const [crawlInProgress, setCrawlInProgress] = useState<boolean>(readCrawlInProgress);
 
     useEffect(() => {
         if (!index) {
             setCrawlInProgress(false);
             return;
         }
 
-        const onChangedCheckpoint = (currentRoom: Room | null): void => {
-            setCrawlInProgress(currentRoom !== null);
+        const onChangedCheckpoint = (): void => {
+            setCrawlInProgress(readCrawlInProgress());
         };
 
         // Re-sync in case the crawl state changed between the initial render and the subscription.
-        setCrawlInProgress(index.currentRoom() !== null);
+        onChangedCheckpoint();
         index.on("changedCheckpoint", onChangedCheckpoint);
 
         return () => {
             index.removeListener("changedCheckpoint", onChangedCheckpoint);
         };
-    }, [index]);
+    }, [index, readCrawlInProgress]);
 
     return crawlInProgress;
 }
 
-export default function SearchWarning({ isRoomEncrypted, kind, showLogo = true }: IProps): JSX.Element {
+export default function SearchWarning({ isRoomEncrypted, kind, showLogo = true, scope, roomId }: IProps): JSX.Element {
     const eventIndex = EventIndexPeg.get();
-    const crawlInProgress = useIsCrawlInProgress(eventIndex);
+    const crawlInProgress = useIsCrawlInProgress(eventIndex, scope, roomId);
 
     if (!isRoomEncrypted) return <></>;
 
     if (eventIndex) {
-        // The index exists but is still draining its checkpoint queue, so searches over
-        // not-yet-indexed history may silently return partial results (#32253). Warn the user.
+        // The index exists but still has history to crawl for this search, so it may silently
+        // return partial results (#32253). Warn the user.
         if (crawlInProgress && kind === WarningKind.Search) {
             // This warning appears dynamically while a search panel is already open (the crawler
             // finishes draining mid-session), so mark it as a polite live region for screen readers.

apps/web/src/components/views/rooms/RoomSearchAuxPanel.tsx

@@ -45,7 +45,13 @@ const RoomSearchAuxPanel: React.FC<Props> = ({ searchInfo, isRoomEncrypted, onSe
                         ) : (
                             <InlineSpinner />
                         )}
-                        <SearchWarning kind={WarningKind.Search} isRoomEncrypted={isRoomEncrypted} showLogo={false} />
+                        <SearchWarning
+                            kind={WarningKind.Search}
+                            isRoomEncrypted={isRoomEncrypted}
+                            showLogo={false}
+                            scope={scope}
+                            roomId={searchInfo?.roomId}
+                        />
                     </div>
                 </div>
                 <div className="mx_RoomSearchAuxPanel_buttons">

apps/web/test/unit-tests/components/views/elements/SearchWarning-test.tsx

@@ -14,18 +14,24 @@ import SdkConfig from "../../../../../src/SdkConfig";
 import SearchWarning, { WarningKind } from "../../../../../src/components/views/elements/SearchWarning";
 import EventIndexPeg from "../../../../../src/indexing/EventIndexPeg";
 import { type default as EventIndex } from "../../../../../src/indexing/EventIndex";
+import { SearchScope } from "../../../../../src/Searching";
+
+const SEARCHED_ROOM = "!searched:example.org";
+const OTHER_ROOM = "!other:example.org";
+const PARTIAL_WARNING = "Results may be incomplete because your search index is still being built.";
 
 /**
  * A minimal fake EventIndex exposing only the surface that SearchWarning consumes:
- * `currentRoom()` (null once the crawl is complete) and the `changedCheckpoint` emitter.
+ * `crawlingRooms()` (the rooms with outstanding crawler checkpoints) and the `changedCheckpoint`
+ * emitter.
  */
 class FakeEventIndex {
     private listeners = new Map<string, Set<(...args: any[]) => void>>();
 
-    public constructor(private current: Room | null) {}
+    public constructor(private crawling: string[] = []) {}
 
-    public currentRoom(): Room | null {
-        return this.current;
+    public crawlingRooms(): { crawlingRooms: Set<string>; totalRooms: Set<string> } {
+        return { crawlingRooms: new Set(this.crawling), totalRooms: new Set(this.crawling) };
     }
 
     public on(event: string, listener: (...args: any[]) => void): void {
@@ -37,10 +43,15 @@ class FakeEventIndex {
         this.listeners.get(event)?.delete(listener);
     }
 
-    /** Test helper: simulate the crawler advancing (or finishing, when `current` is null). */
-    public emitChangedCheckpoint(current: Room | null): void {
-        this.current = current;
-        this.listeners.get("changedCheckpoint")?.forEach((listener) => listener(current));
+    /**
+     * Test helper: simulate the crawler advancing (or finishing, when `crawling` is empty).
+     *
+     * The real index emits only the globally-current room, which cannot answer a per-room
+     * question, so `currentRoom` is passed through purely to prove consumers ignore it.
+     */
+    public emitChangedCheckpoint(crawling: string[], currentRoom: Room | null = null): void {
+        this.crawling = crawling;
+        this.listeners.get("changedCheckpoint")?.forEach((listener) => listener(currentRoom));
     }
 }
 
@@ -86,61 +97,137 @@ describe("<SearchWarning />", () => {
             EventIndexPeg.index = index as unknown as EventIndex;
         };
 
-        it("renders the partial-index warning while the crawl is still in progress", () => {
-            setIndex(new FakeEventIndex({ name: "Encrypted room" } as Room));
+        it("warns a room-scoped search while the searched room is still being crawled", () => {
+            setIndex(new FakeEventIndex([SEARCHED_ROOM]));
 
             const { queryByText, queryByRole } = render(
-                <SearchWarning isRoomEncrypted={true} kind={WarningKind.Search} />,
+                <SearchWarning
+                    isRoomEncrypted={true}
+                    kind={WarningKind.Search}
+                    scope={SearchScope.Room}
+                    roomId={SEARCHED_ROOM}
+                />,
             );
 
-            expect(
-                queryByText("Results may be incomplete because your search index is still being built."),
-            ).toBeInTheDocument();
+            expect(queryByText(PARTIAL_WARNING)).toBeInTheDocument();
             // The notice appears dynamically while the panel is open, so it must be a live region (#32253).
             expect(queryByRole("status")).toBeInTheDocument();
         });
 
+        it("does not warn a room-scoped search when only an unrelated room is still being crawled", () => {
+            setIndex(new FakeEventIndex([OTHER_ROOM]));
+
+            const { container } = render(
+                <SearchWarning
+                    isRoomEncrypted={true}
+                    kind={WarningKind.Search}
+                    scope={SearchScope.Room}
+                    roomId={SEARCHED_ROOM}
+                />,
+            );
+
+            expect(container).toBeEmptyDOMElement();
+        });
+
+        it("warns an all-rooms search while any room is still being crawled", () => {
+            setIndex(new FakeEventIndex([OTHER_ROOM]));
+
+            const { queryByText } = render(
+                <SearchWarning isRoomEncrypted={true} kind={WarningKind.Search} scope={SearchScope.All} />,
+            );
+
+            expect(queryByText(PARTIAL_WARNING)).toBeInTheDocument();
+        });
+
+        it("falls back to the global check when the searched room is not yet known", () => {
+            // RoomView can render before a room alias has resolved to an id.
+            setIndex(new FakeEventIndex([OTHER_ROOM]));
+
+            const { queryByText } = render(
+                <SearchWarning
+                    isRoomEncrypted={true}
+                    kind={WarningKind.Search}
+                    scope={SearchScope.Room}
+                    roomId={undefined}
+                />,
+            );
+
+            expect(queryByText(PARTIAL_WARNING)).toBeInTheDocument();
+        });
+
         it("renders nothing once the index has finished crawling", () => {
-            // currentRoom() returns null when the crawl is complete (fully indexed).
-            setIndex(new FakeEventIndex(null));
+            setIndex(new FakeEventIndex([]));
 
-            const { container } = render(<SearchWarning isRoomEncrypted={true} kind={WarningKind.Search} />);
+            const { container } = render(
+                <SearchWarning isRoomEncrypted={true} kind={WarningKind.Search} scope={SearchScope.All} />,
+            );
 
             expect(container).toBeEmptyDOMElement();
         });
 
         it("does not warn for the Files kind even while crawling", () => {
-            setIndex(new FakeEventIndex({ name: "Encrypted room" } as Room));
+            setIndex(new FakeEventIndex([SEARCHED_ROOM]));
 
             const { container } = render(<SearchWarning isRoomEncrypted={true} kind={WarningKind.Files} />);
 
             expect(container).toBeEmptyDOMElement();
         });
 
-        it("clears the warning when a changedCheckpoint event reports completion", () => {
-            const index = new FakeEventIndex({ name: "Encrypted room" } as Room);
+        it("clears the warning when the searched room's checkpoint drains", () => {
+            const index = new FakeEventIndex([SEARCHED_ROOM]);
             setIndex(index);
 
-            const { queryByText } = render(<SearchWarning isRoomEncrypted={true} kind={WarningKind.Search} />);
+            const { queryByText } = render(
+                <SearchWarning
+                    isRoomEncrypted={true}
+                    kind={WarningKind.Search}
+                    scope={SearchScope.Room}
+                    roomId={SEARCHED_ROOM}
+                />,
+            );
 
-            expect(
-                queryByText("Results may be incomplete because your search index is still being built."),
-            ).toBeInTheDocument();
+            expect(queryByText(PARTIAL_WARNING)).toBeInTheDocument();
 
-            // The crawler drains its last checkpoint: currentRoom() becomes null.
             act(() => {
-                index.emitChangedCheckpoint(null);
+                index.emitChangedCheckpoint([]);
             });
 
-            expect(
-                queryByText("Results may be incomplete because your search index is still being built."),
-            ).not.toBeInTheDocument();
+            expect(queryByText(PARTIAL_WARNING)).not.toBeInTheDocument();
         });
 
-        it("renders nothing when the room is not encrypted even while crawling", () => {
-            setIndex(new FakeEventIndex({ name: "Encrypted room" } as Room));
+        it("keeps warning when the crawler moves to another room but the searched room is still queued", () => {
+            const index = new FakeEventIndex([SEARCHED_ROOM, OTHER_ROOM]);
+            setIndex(index);
+
+            const { queryByText } = render(
+                <SearchWarning
+                    isRoomEncrypted={true}
+                    kind={WarningKind.Search}
+                    scope={SearchScope.Room}
+                    roomId={SEARCHED_ROOM}
+                />,
+            );
 
-            const { container } = render(<SearchWarning isRoomEncrypted={false} kind={WarningKind.Search} />);
+            // The event payload names a different room; the searched room is still outstanding, so
+            // the warning must survive. This fails if the handler trusts the payload.
+            act(() => {
+                index.emitChangedCheckpoint([SEARCHED_ROOM], { roomId: OTHER_ROOM } as Room);
+            });
+
+            expect(queryByText(PARTIAL_WARNING)).toBeInTheDocument();
+        });
+
+        it("renders nothing when the room is not encrypted even while crawling", () => {
+            setIndex(new FakeEventIndex([SEARCHED_ROOM]));
+
+            const { container } = render(
+                <SearchWarning
+                    isRoomEncrypted={false}
+                    kind={WarningKind.Search}
+                    scope={SearchScope.Room}
+                    roomId={SEARCHED_ROOM}
+                />,
+            );
 
             expect(container).toBeEmptyDOMElement();
         });