element-hq · t3chguy · Jul 17, 2026 · Jun 27, 2026 · Jul 14, 2026 · Jul 14, 2026
@@ -6,10 +6,12 @@
 Please see LICENSE files in the repository root for full details.
 */
 
-import React, { type JSX, type ReactNode } from "react";
+import React, { type JSX, type ReactNode, useCallback, useEffect, useState } from "react";
 import { logger } from "matrix-js-sdk/src/logger";
 
 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";
@@ -26,11 +28,131 @@
     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;
 }
 
-export default function SearchWarning({ isRoomEncrypted, kind, showLogo = true }: IProps): JSX.Element {
+/**
+ * Track whether the index is still missing history that is relevant to the given search.
+ *
+ * A room-scoped search is incomplete if the crawler still holds a checkpoint for the room
+ * ({@link EventIndex.crawlingRooms}, which covers both the checkpoint being crawled right now and
+ * those still queued behind it), or if the index holds no events for it at all
+ * ({@link EventIndex.isRoomIndexed}) — which is how a room looks before its checkpoint has been
+ * seeded, and is the case the checkpoint set alone cannot see.
+ *
+ * The second question is only asked while the crawler still has work outstanding, for two reasons.
+ * It is what the warning claims ("your search index is still being built"), and the index has no
+ * event for its contents changing — `changedCheckpoint` fires only on checkpoint transitions, and
+ * an idle crawler is silent — so a warning raised once the crawler has drained would never be
+ * re-evaluated and would stick.
+ *
+ * Neither signal proves completeness: `isRoomIndexed` reports only that the index holds *some*
+ * events for a room, not all of them, and a room has no checkpoint if it never had a
+ * back-pagination token to crawl from or if its checkpoint was dropped because the server rejected
+ * the request. So this under-warns rather than over-warns.
+ *
+ * An all-rooms search cannot ask the per-room question, so it uses the checkpoint set alone.
+ *
+ * The `changedCheckpoint` payload carries only the globally-current room and so cannot answer a
+ * per-room question: we re-read the index on each event rather than trust it.
+ *
+ * @param index The event index to observe, or `null` if there is no index.
+ * @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 the index is known to be missing history for the search, `false` otherwise.
+ */
+function useIsIndexIncomplete(index: EventIndex | null, scope?: SearchScope, roomId?: string): boolean {
+    const readCheckpoints = useCallback((): { relevant: boolean; anyOutstanding: boolean } => {
+        if (!index) return { relevant: false, anyOutstanding: 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.
+        const roomScoped = scope === SearchScope.Room && roomId !== undefined;
+        return {
+            relevant: roomScoped ? crawlingRooms.has(roomId) : crawlingRooms.size > 0,
+            anyOutstanding: crawlingRooms.size > 0,
+        };
+    }, [index, scope, roomId]);
+
+    // The checkpoint half of the answer is known synchronously, so seed from it rather than
+    // rendering an unwarned search for a room we already know is being crawled.
+    const [incomplete, setIncomplete] = useState<boolean>(() => readCheckpoints().relevant);
+
+    useEffect(() => {
+        if (!index) {
+            setIncomplete(false);
+            return;
+        }
+
+        // Guards against a slow isRoomIndexed() response overwriting a newer one, or landing after
+        // the scope changed or the component unmounted.
+        let generation = 0;
+
+        // Answer this scope and room from the checkpoint set up front, so that the previous
+        // search's result is not left on screen while the first lookup below is in flight. Doing
+        // this per effect run rather than per event matters: a checkpoint change is not a new
+        // question, and resetting on one would blink an already-earned warning off and on again.
+        setIncomplete(readCheckpoints().relevant);
+
+        const update = async (): Promise<void> => {
+            const current = ++generation;
+            const { relevant, anyOutstanding } = readCheckpoints();
+
+            if (relevant) {
+                setIncomplete(true);
+                return;
+            }
+            if (!anyOutstanding || scope !== SearchScope.Room || roomId === undefined) {
+                setIncomplete(false);
+                return;
+            }
+
+            // Nothing is queued for this room yet, but the index may hold nothing for it at all.
+            // `undefined` means there is no index manager to ask, which is not evidence either way.
+            const indexed = await index.isRoomIndexed(roomId);
+            if (current === generation) setIncomplete(indexed === false);
+        };
+
+        const onChangedCheckpoint = (): void => {
+            void update();
+        };
+
+        // Re-sync in case the crawl state changed between the initial render and the subscription.
+        onChangedCheckpoint();
+        index.on("changedCheckpoint", onChangedCheckpoint);
+
+        return () => {
+            generation++;
+            index.removeListener("changedCheckpoint", onChangedCheckpoint);
+        };
+    }, [index, scope, roomId, readCheckpoints]);
+
+    return incomplete;
+}
+
+export default function SearchWarning({ isRoomEncrypted, kind, showLogo = true, scope, roomId }: IProps): JSX.Element {
+    const eventIndex = EventIndexPeg.get();
+    const indexIncomplete = useIsIndexIncomplete(eventIndex, scope, roomId);
+
     if (!isRoomEncrypted) return <></>;
-    if (EventIndexPeg.get()) return <></>;
+
+    if (eventIndex) {
+        // The index is still missing history for this search, so it may silently return partial
+        // results (#32253). Warn the user.
+        if (indexIncomplete && 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.
+            return (
+                <div className="mx_SearchWarning" role="status">
+                    <span>{_t("seshat|warning_kind_search_partial")}</span>
+                </div>
+            );
+        }
+        return <></>;
+    }
 
     if (EventIndexPeg.error) {
         return (

@@ -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">

@@ -2434,7 +2434,8 @@
         "warning_kind_files": "This version of %(brand)s does not support viewing some encrypted files",
         "warning_kind_files_app": "Use the <a>Desktop app</a> to see all encrypted files",
         "warning_kind_search": "This version of %(brand)s does not support searching encrypted messages",
-        "warning_kind_search_app": "Use the <a>Desktop app</a> to search encrypted messages"
+        "warning_kind_search_app": "Use the <a>Desktop app</a> to search encrypted messages",
+        "warning_kind_search_partial": "Results may be incomplete because your search index is still being built."
     },
     "setting": {
         "help_about": {

@@ -992,7 +992,10 @@ export default class EventIndex extends EventEmitter {
     }
 
     public crawlingRooms(): {
-        /** The rooms that we are currently crawling. */
+        /**
+         * The rooms with an outstanding crawler checkpoint: the one being crawled right now, and
+         * those still queued behind it.
+         */
         crawlingRooms: Set<string>;
 
         /** All the encrypted rooms known by the MatrixClient. */