From 3cbafe799d6bbebb4de17ab43a0b1c772451e8b0 Mon Sep 17 00:00:00 2001
From: Chuck Dries <chuck@expensify.com>
Date: Fri, 15 May 2026 18:27:17 -0700
Subject: [PATCH 1/5] Add sidebarOrderedReports as Derived value

---
 src/ONYXKEYS.ts                               |   2 +
 src/components/TestToolMenu.tsx               |  11 -
 src/hooks/useSidebarOrderedReports.tsx        | 347 ++++--------------
 .../OnyxDerived/ONYX_DERIVED_VALUES.ts        |   2 +
 .../configs/sidebarOrderedReports.ts          | 208 +++++++++++
 src/libs/actions/OnyxDerived/types.ts         |   5 +-
 src/types/onyx/DerivedValues.ts               |  23 ++
 src/types/onyx/index.ts                       |   2 +
 ...barOrderedReportsDerivedValue.perf-test.ts |  88 +++++
 .../SidebarOrderedReportsDerivedValueTest.ts  | 161 ++++++++
 tests/unit/useSidebarOrderedReportsTest.tsx   | 265 +++----------
 11 files changed, 616 insertions(+), 498 deletions(-)
 create mode 100644 src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
 create mode 100644 tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts
 create mode 100644 tests/unit/SidebarOrderedReportsDerivedValueTest.ts

diff --git a/src/ONYXKEYS.ts b/src/ONYXKEYS.ts
index 2bcf9e3f036d..11499409fdfd 100755
--- a/src/ONYXKEYS.ts
+++ b/src/ONYXKEYS.ts
@@ -1166,6 +1166,7 @@ const ONYXKEYS = {
         TODOS: 'todos',
         RAM_ONLY_SORTED_REPORT_ACTIONS: 'sortedReportActions',
         OPEN_AND_SUBMITTED_REPORTS_BY_POLICY_ID: 'openAndSubmittedReportsByPolicyID',
+        SIDEBAR_ORDERED_REPORTS: 'sidebarOrderedReports',
     },
 
     /** Stores HybridApp specific state required to interoperate with OldDot */
@@ -1647,6 +1648,7 @@ type OnyxDerivedValuesMapping = {
     [ONYXKEYS.DERIVED.TODOS]: OnyxTypes.TodosDerivedValue;
     [ONYXKEYS.DERIVED.RAM_ONLY_SORTED_REPORT_ACTIONS]: OnyxTypes.SortedReportActionsDerivedValue;
     [ONYXKEYS.DERIVED.OPEN_AND_SUBMITTED_REPORTS_BY_POLICY_ID]: OnyxTypes.OpenAndSubmittedReportsByPolicyIDDerivedValue;
+    [ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS]: OnyxTypes.SidebarOrderedReportsDerivedValue;
 };
 
 type OnyxValues = OnyxValuesMapping & OnyxCollectionValuesMapping & OnyxFormValuesMapping & OnyxFormDraftValuesMapping & OnyxDerivedValuesMapping;
diff --git a/src/components/TestToolMenu.tsx b/src/components/TestToolMenu.tsx
index ffebc26007ff..6eed5d6ec797 100644
--- a/src/components/TestToolMenu.tsx
+++ b/src/components/TestToolMenu.tsx
@@ -4,7 +4,6 @@ import useBiometricRegistrationStatus, {REGISTRATION_STATUS} from '@hooks/useBio
 import useIsAuthenticated from '@hooks/useIsAuthenticated';
 import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
-import {useSidebarOrderedReportsActions} from '@hooks/useSidebarOrderedReports';
 import useSingleExecution from '@hooks/useSingleExecution';
 import useThemeStyles from '@hooks/useThemeStyles';
 import useWaitForNavigation from '@hooks/useWaitForNavigation';
@@ -32,7 +31,6 @@ function TestToolMenu() {
     const [shouldShowBranchNameInTitle = false] = useOnyx(ONYXKEYS.SHOULD_SHOW_BRANCH_NAME_IN_TITLE);
     const styles = useThemeStyles();
     const {translate} = useLocalize();
-    const {clearLHNCache} = useSidebarOrderedReportsActions();
     const [isMFARevokeLoading, setIsMFARevokeLoading] = useState(false);
     const {localCredentialID, isCurrentDeviceRegistered, otherDeviceCount, registrationStatus} = useBiometricRegistrationStatus();
 
@@ -120,15 +118,6 @@ function TestToolMenu() {
                         />
                     </TestToolRow>
 
-                    {/* Clears the useSidebarOrderedReports cache to re-compute from latest onyx values */}
-                    <TestToolRow title={translate('initialSettingsPage.troubleshoot.leftHandNavCache')}>
-                        <Button
-                            small
-                            text={translate('initialSettingsPage.troubleshoot.clearleftHandNavCache')}
-                            onPress={clearLHNCache}
-                        />
-                    </TestToolRow>
-
                     {/* Allows testing the biometric multifactor authentication flow */}
                     <TestToolRow title={biometricsTitle}>
                         <View style={[styles.flexRow, styles.gap2]}>
diff --git a/src/hooks/useSidebarOrderedReports.tsx b/src/hooks/useSidebarOrderedReports.tsx
index bd6bb42e0257..eda2d089a5f6 100644
--- a/src/hooks/useSidebarOrderedReports.tsx
+++ b/src/hooks/useSidebarOrderedReports.tsx
@@ -1,8 +1,4 @@
-import React, {createContext, useCallback, useContext, useEffect, useMemo, useRef, useState} from 'react';
-import type {OnyxEntry} from 'react-native-onyx';
-import Log from '@libs/Log';
-import {getTransactionThreadReportID} from '@libs/MergeTransactionUtils';
-import {isOneTransactionReport} from '@libs/ReportUtils';
+import React, {createContext, useContext, useEffect, useMemo, useRef} from 'react';
 import SidebarUtils from '@libs/SidebarUtils';
 import type {BrickRoad} from '@libs/WorkspacesSettingsUtils';
 import {getChatTabBrickRoad} from '@libs/WorkspacesSettingsUtils';
@@ -12,17 +8,13 @@ import type * as OnyxTypes from '@src/types/onyx';
 import {useCurrentReportIDState} from './useCurrentReportID';
 import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails';
 import useLocalize from './useLocalize';
-import useMappedPolicies from './useMappedPolicies';
 import useNetwork from './useNetwork';
 import useOnyx from './useOnyx';
-import usePrevious from './usePrevious';
 import useReportAttributes from './useReportAttributes';
 import useResponsiveLayout from './useResponsiveLayout';
 
 const componentsUsingHook = new Map<string, {renderDuration: number}>();
 
-type PartialPolicyForSidebar = Pick<OnyxTypes.Policy, 'type' | 'name' | 'avatarURL' | 'employeeList'>;
-
 type SidebarOrderedReportsContextProviderProps = {
     children: React.ReactNode;
     currentReportIDForTests?: string;
@@ -35,10 +27,6 @@ type SidebarOrderedReportsStateContextValue = {
     chatTabBrickRoad: BrickRoad;
 };
 
-type SidebarOrderedReportsActionsContextValue = {
-    clearLHNCache: () => void;
-};
-
 type ReportsToDisplayInLHN = Record<string, OnyxTypes.Report & {hasErrorsOtherThanFailedReceipt?: boolean; requiresAttention?: boolean}>;
 
 const SidebarOrderedReportsStateContext = createContext<SidebarOrderedReportsStateContextValue>({
@@ -48,18 +36,6 @@ const SidebarOrderedReportsStateContext = createContext<SidebarOrderedReportsSta
     chatTabBrickRoad: undefined,
 });
 
-const SidebarOrderedReportsActionsContext = createContext<SidebarOrderedReportsActionsContextValue>({
-    clearLHNCache: () => {},
-});
-
-const policyMapper = (policy: OnyxEntry<OnyxTypes.Policy>): PartialPolicyForSidebar =>
-    (policy && {
-        type: policy.type,
-        name: policy.name,
-        avatarURL: policy.avatarURL,
-        employeeList: policy.employeeList,
-    }) as PartialPolicyForSidebar;
-
 function SidebarOrderedReportsContextProvider({
     children,
     /**
@@ -73,285 +49,106 @@ function SidebarOrderedReportsContextProvider({
     currentReportIDForTests,
 }: SidebarOrderedReportsContextProviderProps) {
     const {localeCompare} = useLocalize();
-    const [priorityMode = CONST.PRIORITY_MODE.DEFAULT] = useOnyx(ONYXKEYS.NVP_PRIORITY_MODE);
-    const [chatReports, {sourceValue: reportUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
-    const [, {sourceValue: policiesUpdates}] = useMappedPolicies(policyMapper);
-    const [transactions, {sourceValue: transactionsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION);
-    const [transactionViolations, {sourceValue: transactionViolationsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS);
-    const [reportNameValuePairs, {sourceValue: reportNameValuePairsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS);
-    const [reportsDrafts, {sourceValue: reportsDraftsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT);
+    const [derived] = useOnyx(ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS);
+    const [chatReports] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
+    const [reportNameValuePairs] = useOnyx(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS);
+    const [reportsDrafts] = useOnyx(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT);
+    const [transactions] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION);
+    const [transactionViolations] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS);
     const [betas] = useOnyx(ONYXKEYS.BETAS);
+    const [priorityMode = CONST.PRIORITY_MODE.DEFAULT] = useOnyx(ONYXKEYS.NVP_PRIORITY_MODE);
     const reportAttributes = useReportAttributes();
-    const [currentReportsToDisplay, setCurrentReportsToDisplay] = useState<ReportsToDisplayInLHN>({});
     const {shouldUseNarrowLayout} = useResponsiveLayout();
     const {isOffline} = useNetwork();
     const {accountID, login: currentUserLogin} = useCurrentUserPersonalDetails();
     const {currentReportID: currentReportIDValue} = useCurrentReportIDState();
     const derivedCurrentReportID = currentReportIDForTests ?? currentReportIDValue;
-    const prevDerivedCurrentReportID = usePrevious(derivedCurrentReportID);
-
-    // we need to force reportsToDisplayInLHN to re-compute when we clear currentReportsToDisplay, but the way it currently works relies on not having currentReportsToDisplay as a memo dependency, so we just need something we can change to trigger it
-    // I don't like it either, but clearing the cache is only a hack for the debug modal and I will endeavor to make it better as I work to improve the cache correctness of the LHN more broadly
-    const [clearCacheDummyCounter, setClearCacheDummyCounter] = useState(0);
-
-    const prevBetas = usePrevious(betas);
-    const prevPriorityMode = usePrevious(priorityMode);
-    const prevIsOffline = usePrevious(isOffline);
 
-    const perfRef = useRef<{hookDuration: number}>({
-        hookDuration: 0,
-    });
-    const hookStartTime = useRef<number>(performance.now());
+    const baseOrderedReportIDs = derived?.orderedReportIDs ?? [];
+    const baseReportsToDisplay = derived?.reportsToDisplay;
 
-    /**
-     * Find the reports that need to be updated in the LHN
-     */
-    const getUpdatedReports = useCallback(() => {
-        const reportsToUpdate = new Set<string>();
+    // Web parity: when the active report would not normally pass `shouldDisplayReportInLHN` we still
+    // need it to appear in the LHN. Recompute once with `currentReportID` set when that happens.
+    // Mobile (narrow layout) only triggers the recompute when the list is otherwise empty.
+    const orderedReportIDs = useMemo(() => {
+        const needsCurrentReportInjected =
+            (!shouldUseNarrowLayout || baseOrderedReportIDs.length === 0) &&
+            !!derivedCurrentReportID &&
+            derivedCurrentReportID !== '-1' &&
+            baseOrderedReportIDs.indexOf(derivedCurrentReportID) === -1;
 
-        if (betas !== prevBetas || priorityMode !== prevPriorityMode || isOffline !== prevIsOffline) {
-            for (const key of Object.keys(chatReports ?? {})) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (reportUpdates) {
-            for (const key of Object.keys(reportUpdates ?? {})) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (reportNameValuePairsUpdates) {
-            for (const key of Object.keys(reportNameValuePairsUpdates ?? {}).map((reportKey) => reportKey.replace(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS, ONYXKEYS.COLLECTION.REPORT))) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (transactionsUpdates) {
-            // We need to select the report linked to a transaction, to properly recalculate getReceiptUploadErrorReason, which is the expense report if it is isOneTransactionReport
-            // or the transaction thread report if it is otherwise.
-            for (const key of Object.values(transactionsUpdates ?? {}).map((transaction) =>
-                transaction?.reportID && isOneTransactionReport(chatReports?.[`${ONYXKEYS.COLLECTION.REPORT}${transaction.reportID}`])
-                    ? `${ONYXKEYS.COLLECTION.REPORT}${transaction?.reportID}`
-                    : `${ONYXKEYS.COLLECTION.REPORT}${getTransactionThreadReportID(transaction)}`,
-            )) {
-                reportsToUpdate.add(key);
-            }
+        if (!needsCurrentReportInjected) {
+            return baseOrderedReportIDs;
         }
-        if (transactionViolationsUpdates) {
-            for (const key of Object.keys(transactionViolationsUpdates ?? {})
-                .map((violationKey) => violationKey.replace(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS, ONYXKEYS.COLLECTION.TRANSACTION))
-                .map((transactionKey) => `${ONYXKEYS.COLLECTION.REPORT}${transactions?.[transactionKey]?.reportID}`)) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (reportsDraftsUpdates) {
-            for (const key of Object.keys(reportsDraftsUpdates).map((draftKey) => draftKey.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, ONYXKEYS.COLLECTION.REPORT))) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (policiesUpdates) {
-            const updatedPolicies = new Set(Object.keys(policiesUpdates).map((policyKey) => policyKey.replace(ONYXKEYS.COLLECTION.POLICY, '')));
-            for (const key of Object.entries(chatReports ?? {})
-                .filter(([, value]) => {
-                    if (!value?.policyID) {
-                        return;
-                    }
 
-                    return updatedPolicies.has(value.policyID);
-                })
-                .map(([reportKey]) => reportKey)) {
-                reportsToUpdate.add(key);
+        const reportsToDisplay = SidebarUtils.getReportsToDisplayInLHN({
+            currentReportId: derivedCurrentReportID,
+            reports: chatReports,
+            betas,
+            priorityMode,
+            draftComments: reportsDrafts,
+            transactionViolations,
+            transactions,
+            isOffline,
+            currentUserLogin: currentUserLogin ?? '',
+            currentUserAccountID: accountID,
+            reportNameValuePairs,
+            reportAttributes,
+        });
+
+        const hasDraftByReportID: Record<string, boolean> = {};
+        if (reportsDrafts) {
+            for (const [key, value] of Object.entries(reportsDrafts)) {
+                if (value) {
+                    hasDraftByReportID[key.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, '')] = true;
+                }
             }
         }
 
-        // Make sure the previous and current reports are always included in the updates when we switch reports.
-        if (prevDerivedCurrentReportID !== derivedCurrentReportID) {
-            reportsToUpdate.add(`${ONYXKEYS.COLLECTION.REPORT}${prevDerivedCurrentReportID}`);
-            reportsToUpdate.add(`${ONYXKEYS.COLLECTION.REPORT}${derivedCurrentReportID}`);
-        }
-
-        return Array.from(reportsToUpdate);
+        return SidebarUtils.sortReportsToDisplayInLHN(reportsToDisplay, priorityMode, localeCompare, hasDraftByReportID, reportNameValuePairs, reportAttributes);
     }, [
-        reportUpdates,
-        reportNameValuePairsUpdates,
-        transactionsUpdates,
-        transactionViolationsUpdates,
-        reportsDraftsUpdates,
-        policiesUpdates,
-        chatReports,
-        transactions,
-        betas,
-        priorityMode,
-        prevBetas,
-        prevPriorityMode,
-        isOffline,
-        prevIsOffline,
-        prevDerivedCurrentReportID,
+        baseOrderedReportIDs,
+        shouldUseNarrowLayout,
         derivedCurrentReportID,
-    ]);
-
-    const reportsToDisplayInLHN = useMemo(() => {
-        const updatedReports = getUpdatedReports();
-        const hasCachedReports = Object.keys(currentReportsToDisplay).length > 0;
-
-        // When reportAttributes changes (e.g. on startup hydration) but no report-specific keys were
-        // updated, getUpdatedReports() returns []. Rather than falling through to a full scan of all
-        // reports, recheck only the already-displayed reports with the new reportAttributes.
-        const effectiveUpdatedReports = updatedReports.length === 0 && hasCachedReports ? Object.keys(currentReportsToDisplay) : updatedReports;
-        const shouldDoIncrementalUpdate = effectiveUpdatedReports.length > 0 && hasCachedReports;
-        let reportsToDisplay = {};
-        if (shouldDoIncrementalUpdate) {
-            reportsToDisplay = SidebarUtils.updateReportsToDisplayInLHN({
-                displayedReports: currentReportsToDisplay,
-                reports: chatReports,
-                updatedReportsKeys: effectiveUpdatedReports,
-                currentReportId: derivedCurrentReportID,
-                isInFocusMode: priorityMode === CONST.PRIORITY_MODE.GSD,
-                betas,
-                transactionViolations,
-                reportNameValuePairs,
-                reportAttributes,
-                draftComments: reportsDrafts,
-                transactions,
-                isOffline,
-                currentUserLogin: currentUserLogin ?? '',
-                currentUserAccountID: accountID,
-            });
-        } else {
-            Log.info('[useSidebarOrderedReports] building reportsToDisplay from scratch');
-            reportsToDisplay = SidebarUtils.getReportsToDisplayInLHN({
-                currentReportId: derivedCurrentReportID,
-                reports: chatReports,
-                betas,
-                priorityMode,
-                draftComments: reportsDrafts,
-                transactionViolations,
-                transactions,
-                isOffline,
-                currentUserLogin: currentUserLogin ?? '',
-                currentUserAccountID: accountID,
-                reportNameValuePairs,
-                reportAttributes,
-            });
-        }
-
-        return reportsToDisplay;
-        // Rule disabled intentionally — triggering a re-render on currentReportsToDisplay would cause an infinite loop
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        getUpdatedReports,
         chatReports,
-        derivedCurrentReportID,
-        priorityMode,
         betas,
-        transactionViolations,
-        reportNameValuePairs,
-        reportAttributes,
+        priorityMode,
         reportsDrafts,
+        transactionViolations,
+        transactions,
         isOffline,
-        clearCacheDummyCounter,
         currentUserLogin,
         accountID,
+        reportNameValuePairs,
+        reportAttributes,
+        localeCompare,
     ]);
 
-    // Derive a stable boolean map indicating which reports have drafts.
-    const hasDraftByReportIDRef = useRef<Record<string, boolean>>({});
-    const hasDraftByReportID = useMemo(() => {
-        const result: Record<string, boolean> = {};
-        if (reportsDrafts) {
-            for (const [key, value] of Object.entries(reportsDrafts)) {
-                if (value) {
-                    result[key.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, '')] = true;
-                }
-            }
-        }
-        const prev = hasDraftByReportIDRef.current;
-        const prevKeys = Object.keys(prev);
-        const newKeys = Object.keys(result);
-        if (prevKeys.length === newKeys.length && newKeys.every((k) => k in prev)) {
-            return prev;
+    const orderedReports = useMemo(() => {
+        if (!chatReports) {
+            return [];
         }
-        hasDraftByReportIDRef.current = result;
-        return result;
-    }, [reportsDrafts]);
-
-    useEffect(() => {
-        setCurrentReportsToDisplay(reportsToDisplayInLHN);
-    }, [reportsToDisplayInLHN]);
-
-    const getOrderedReportIDs = useCallback(
-        () => SidebarUtils.sortReportsToDisplayInLHN(reportsToDisplayInLHN, priorityMode, localeCompare, hasDraftByReportID, reportNameValuePairs, reportAttributes),
-        // Rule disabled intentionally - reports should be sorted only when the reportsToDisplayInLHN changes
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        [reportsToDisplayInLHN, localeCompare, hasDraftByReportID, reportAttributes],
-    );
-
-    const orderedReportIDs = useMemo(() => getOrderedReportIDs(), [getOrderedReportIDs]);
-
-    // Get the actual reports based on the ordered IDs
-    const getOrderedReports = useCallback(
-        (reportIDs: string[]): OnyxTypes.Report[] => {
-            if (!chatReports) {
-                return [];
+        const result: OnyxTypes.Report[] = [];
+        for (const reportID of orderedReportIDs) {
+            const report = chatReports[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`] ?? baseReportsToDisplay?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
+            if (report) {
+                result.push(report);
             }
-            return reportIDs.map((reportID) => chatReports[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]).filter(Boolean) as OnyxTypes.Report[];
-        },
-        [chatReports],
-    );
-
-    const orderedReports = useMemo(() => getOrderedReports(orderedReportIDs), [getOrderedReports, orderedReportIDs]);
-
-    const clearLHNCache = useCallback(() => {
-        Log.info('[useSidebarOrderedReports] Clearing sidebar cache manually via debug modal');
-        setCurrentReportsToDisplay({});
-        setClearCacheDummyCounter((current) => current + 1);
-    }, []);
-
-    const stateValue: SidebarOrderedReportsStateContextValue = useMemo(() => {
-        // We need to make sure the current report is in the list of reports, but we do not want
-        // to have to re-generate the list every time the currentReportID changes. To do that
-        // we first generate the list as if there was no current report, then we check if
-        // the current report is missing from the list, which should very rarely happen. In this
-        // case we re-generate the list a 2nd time with the current report included.
-
-        // We also execute the following logic if `shouldUseNarrowLayout` is false because this is
-        // requirement for web. Consider a case, where we have report with expenses and we click on
-        // any expense, a new LHN item is added in the list and is visible on web. But on mobile, we
-        // just navigate to the screen with expense details, so there seems no point to execute this logic on mobile.
-        if (
-            (!shouldUseNarrowLayout || orderedReportIDs.length === 0) &&
-            derivedCurrentReportID &&
-            derivedCurrentReportID !== '-1' &&
-            orderedReportIDs.indexOf(derivedCurrentReportID) === -1
-        ) {
-            const updatedReportIDs = getOrderedReportIDs();
-            const updatedReports = getOrderedReports(updatedReportIDs);
-            return {
-                orderedReports: updatedReports,
-                orderedReportIDs: updatedReportIDs,
-                currentReportID: derivedCurrentReportID,
-                chatTabBrickRoad: getChatTabBrickRoad(updatedReportIDs, reportAttributes),
-            };
         }
+        return result;
+    }, [orderedReportIDs, chatReports, baseReportsToDisplay]);
 
-        return {
+    const stateValue: SidebarOrderedReportsStateContextValue = useMemo(
+        () => ({
             orderedReports,
             orderedReportIDs,
             currentReportID: derivedCurrentReportID,
             chatTabBrickRoad: getChatTabBrickRoad(orderedReportIDs, reportAttributes),
-        };
-    }, [getOrderedReportIDs, orderedReportIDs, derivedCurrentReportID, shouldUseNarrowLayout, getOrderedReports, orderedReports, reportAttributes]);
-
-    const actionsValue: SidebarOrderedReportsActionsContextValue = useMemo(() => ({clearLHNCache}), [clearLHNCache]);
-
-    useEffect(() => {
-        const hookExecutionDuration = performance.now() - hookStartTime.current;
-        perfRef.current.hookDuration = hookExecutionDuration;
-    }, [stateValue]);
-
-    return (
-        <SidebarOrderedReportsStateContext.Provider value={stateValue}>
-            <SidebarOrderedReportsActionsContext.Provider value={actionsValue}>{children}</SidebarOrderedReportsActionsContext.Provider>
-        </SidebarOrderedReportsStateContext.Provider>
+        }),
+        [orderedReports, orderedReportIDs, derivedCurrentReportID, reportAttributes],
     );
+
+    return <SidebarOrderedReportsStateContext.Provider value={stateValue}>{children}</SidebarOrderedReportsStateContext.Provider>;
 }
 
 function useSidebarOrderedReportsState(componentName?: string) {
@@ -359,14 +156,8 @@ function useSidebarOrderedReportsState(componentName?: string) {
     return useContext(SidebarOrderedReportsStateContext);
 }
 
-function useSidebarOrderedReportsActions() {
-    return useContext(SidebarOrderedReportsActionsContext);
-}
-
 function useSidebarOrderedReports(componentName?: string) {
-    const state = useSidebarOrderedReportsState(componentName);
-    const actions = useSidebarOrderedReportsActions();
-    return {...state, ...actions};
+    return useSidebarOrderedReportsState(componentName);
 }
 
 function useSidebarOrderedReportsPerformance(componentName?: string) {
@@ -403,5 +194,5 @@ function useSidebarOrderedReportsPerformance(componentName?: string) {
     }, [componentName]);
 }
 
-export {SidebarOrderedReportsContextProvider, useSidebarOrderedReports, useSidebarOrderedReportsState, useSidebarOrderedReportsActions};
+export {SidebarOrderedReportsContextProvider, useSidebarOrderedReports, useSidebarOrderedReportsState};
 export type {ReportsToDisplayInLHN};
diff --git a/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts b/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts
index 161c7f72ecf8..e9a692129a16 100644
--- a/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts
+++ b/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts
@@ -7,6 +7,7 @@ import outstandingReportsByPolicyIDConfig from './configs/outstandingReportsByPo
 import personalAndWorkspaceCardListConfig from './configs/personalAndWorkspaceCardList';
 import reportAttributesConfig from './configs/reportAttributes';
 import reportTransactionsAndViolationsConfig from './configs/reportTransactionsAndViolations';
+import sidebarOrderedReportsConfig from './configs/sidebarOrderedReports';
 import sortedReportActionsConfig from './configs/sortedReportActions';
 import todosConfig from './configs/todos';
 import visibleReportActionsConfig from './configs/visibleReportActions';
@@ -27,6 +28,7 @@ const ONYX_DERIVED_VALUES = {
     [ONYXKEYS.DERIVED.TODOS]: todosConfig,
     [ONYXKEYS.DERIVED.RAM_ONLY_SORTED_REPORT_ACTIONS]: sortedReportActionsConfig,
     [ONYXKEYS.DERIVED.OPEN_AND_SUBMITTED_REPORTS_BY_POLICY_ID]: openAndSubmittedReportsByPolicyIDConfig,
+    [ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS]: sidebarOrderedReportsConfig,
 } as const satisfies {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [Key in ValueOf<typeof ONYXKEYS.DERIVED>]: OnyxDerivedValueConfig<Key, any>;
diff --git a/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts b/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
new file mode 100644
index 000000000000..b2102e2faa81
--- /dev/null
+++ b/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
@@ -0,0 +1,208 @@
+import {shallowEqual} from 'fast-equals';
+import {getTransactionThreadReportID} from '@libs/MergeTransactionUtils';
+import {getIsOffline} from '@libs/NetworkState';
+import {isOneTransactionReport} from '@libs/ReportUtils';
+import SidebarUtils from '@libs/SidebarUtils';
+import createOnyxDerivedValueConfig from '@userActions/OnyxDerived/createOnyxDerivedValueConfig';
+import CONST from '@src/CONST';
+import IntlStore from '@src/languages/IntlStore';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Transaction} from '@src/types/onyx';
+import type {SidebarOrderedReportsDerivedValue, SidebarReportForLHN} from '@src/types/onyx/DerivedValues';
+
+const EMPTY_VALUE: SidebarOrderedReportsDerivedValue = {reportsToDisplay: {}, orderedReportIDs: []};
+
+const COLLATOR_OPTIONS: Intl.CollatorOptions = {usage: 'sort', sensitivity: 'variant', numeric: true, caseFirst: 'upper'};
+
+const COLLECTION_DEP_KEYS = [
+    ONYXKEYS.COLLECTION.REPORT,
+    ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS,
+    ONYXKEYS.COLLECTION.TRANSACTION,
+    ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
+    ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT,
+    ONYXKEYS.COLLECTION.POLICY,
+] as const;
+
+function buildHasDraftMap(reportsDrafts: Record<string, string | null | undefined> | null | undefined): Record<string, boolean> {
+    const result: Record<string, boolean> = {};
+    if (!reportsDrafts) {
+        return result;
+    }
+    for (const [key, value] of Object.entries(reportsDrafts)) {
+        if (value) {
+            result[key.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, '')] = true;
+        }
+    }
+    return result;
+}
+
+export default createOnyxDerivedValueConfig({
+    key: ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS,
+    dependencies: [
+        ONYXKEYS.COLLECTION.REPORT,
+        ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS,
+        ONYXKEYS.COLLECTION.TRANSACTION,
+        ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
+        ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT,
+        ONYXKEYS.COLLECTION.POLICY,
+        ONYXKEYS.NVP_PRIORITY_MODE,
+        ONYXKEYS.BETAS,
+        ONYXKEYS.NETWORK,
+        ONYXKEYS.NVP_PREFERRED_LOCALE,
+        ONYXKEYS.DERIVED.REPORT_ATTRIBUTES,
+        ONYXKEYS.SESSION,
+    ],
+    compute: (
+        [reports, reportNameValuePairs, transactions, transactionViolations, reportsDrafts, , priorityMode, betas, , locale, reportAttributesDerived, session],
+        {currentValue, sourceValues},
+    ): SidebarOrderedReportsDerivedValue => {
+        if (!reports || Object.keys(reports).length === 0) {
+            return EMPTY_VALUE;
+        }
+
+        const effectivePriorityMode = priorityMode ?? CONST.PRIORITY_MODE.DEFAULT;
+        const isInFocusMode = effectivePriorityMode === CONST.PRIORITY_MODE.GSD;
+        const isOffline = getIsOffline();
+        const reportAttributes = reportAttributesDerived?.reports;
+        const currentUserAccountID = session?.accountID ?? CONST.DEFAULT_NUMBER_ID;
+        const currentUserLogin = session?.email ?? '';
+
+        // Compute incremental updates only when a collection dep changed AND we have a cached value.
+        // Scalar/non-collection changes (BETAS, NVP_PRIORITY_MODE, NETWORK, NVP_PREFERRED_LOCALE,
+        // DERIVED.REPORT_ATTRIBUTES) force a full recompute.
+        const collectionUpdates = sourceValues
+            ? COLLECTION_DEP_KEYS.reduce<Record<string, Record<string, unknown> | undefined>>((acc, collectionKey) => {
+                  const update = sourceValues[collectionKey];
+                  if (update) {
+                      acc[collectionKey] = update;
+                  }
+                  return acc;
+              }, {})
+            : {};
+        const hasCollectionUpdate = Object.keys(collectionUpdates).length > 0;
+        const canIncremental = !!currentValue && hasCollectionUpdate && Object.keys(currentValue.reportsToDisplay).length > 0;
+
+        let reportsToDisplay: Record<string, SidebarReportForLHN>;
+        if (canIncremental && currentValue) {
+            const updatedReportsKeys = new Set<string>();
+
+            const reportUpdates = collectionUpdates[ONYXKEYS.COLLECTION.REPORT];
+            if (reportUpdates) {
+                for (const key of Object.keys(reportUpdates)) {
+                    updatedReportsKeys.add(key);
+                }
+            }
+
+            const rnvpUpdates = collectionUpdates[ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS];
+            if (rnvpUpdates) {
+                for (const key of Object.keys(rnvpUpdates)) {
+                    updatedReportsKeys.add(key.replace(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS, ONYXKEYS.COLLECTION.REPORT));
+                }
+            }
+
+            const transactionUpdates = collectionUpdates[ONYXKEYS.COLLECTION.TRANSACTION];
+            if (transactionUpdates) {
+                for (const transaction of Object.values(transactionUpdates)) {
+                    const txn = transaction as Transaction | null | undefined;
+                    if (!txn?.reportID) {
+                        continue;
+                    }
+                    const reportKey = `${ONYXKEYS.COLLECTION.REPORT}${txn.reportID}`;
+                    const reportForTxn = reports[reportKey];
+                    if (isOneTransactionReport(reportForTxn)) {
+                        updatedReportsKeys.add(reportKey);
+                    } else {
+                        const threadID = getTransactionThreadReportID(txn);
+                        updatedReportsKeys.add(`${ONYXKEYS.COLLECTION.REPORT}${threadID}`);
+                    }
+                }
+            }
+
+            const violationUpdates = collectionUpdates[ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS];
+            if (violationUpdates) {
+                for (const violationKey of Object.keys(violationUpdates)) {
+                    const transactionKey = violationKey.replace(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS, ONYXKEYS.COLLECTION.TRANSACTION);
+                    const linkedReportID = transactions?.[transactionKey]?.reportID;
+                    if (linkedReportID) {
+                        updatedReportsKeys.add(`${ONYXKEYS.COLLECTION.REPORT}${linkedReportID}`);
+                    }
+                }
+            }
+
+            const draftUpdates = collectionUpdates[ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT];
+            if (draftUpdates) {
+                for (const draftKey of Object.keys(draftUpdates)) {
+                    updatedReportsKeys.add(draftKey.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, ONYXKEYS.COLLECTION.REPORT));
+                }
+            }
+
+            const policyUpdates = collectionUpdates[ONYXKEYS.COLLECTION.POLICY];
+            if (policyUpdates) {
+                const updatedPolicyIDs = new Set(Object.keys(policyUpdates).map((policyKey) => policyKey.replace(ONYXKEYS.COLLECTION.POLICY, '')));
+                for (const [reportKey, report] of Object.entries(reports)) {
+                    if (report?.policyID && updatedPolicyIDs.has(report.policyID)) {
+                        updatedReportsKeys.add(reportKey);
+                    }
+                }
+            }
+
+            reportsToDisplay = SidebarUtils.updateReportsToDisplayInLHN({
+                displayedReports: currentValue.reportsToDisplay,
+                reports,
+                updatedReportsKeys: Array.from(updatedReportsKeys),
+                currentReportId: undefined,
+                isInFocusMode,
+                betas,
+                transactionViolations,
+                reportNameValuePairs,
+                reportAttributes,
+                draftComments: reportsDrafts,
+                transactions,
+                isOffline,
+                currentUserLogin,
+                currentUserAccountID,
+            });
+        } else {
+            reportsToDisplay = SidebarUtils.getReportsToDisplayInLHN({
+                currentReportId: undefined,
+                reports,
+                betas,
+                priorityMode: effectivePriorityMode,
+                draftComments: reportsDrafts,
+                transactionViolations,
+                transactions,
+                isOffline,
+                currentUserLogin,
+                currentUserAccountID,
+                reportNameValuePairs,
+                reportAttributes,
+            });
+        }
+
+        const collator = new Intl.Collator(locale ?? IntlStore.getCurrentLocale() ?? undefined, COLLATOR_OPTIONS);
+        const localeCompare = (a: string, b: string) => collator.compare(a, b);
+        const hasDraftByReportID = buildHasDraftMap(reportsDrafts);
+
+        const nextOrderedReportIDs = SidebarUtils.sortReportsToDisplayInLHN(
+            reportsToDisplay,
+            effectivePriorityMode,
+            localeCompare,
+            hasDraftByReportID,
+            reportNameValuePairs,
+            reportAttributes,
+        );
+
+        // Preserve referential stability when nothing meaningful changed downstream.
+        const stableReportsToDisplay = currentValue && reportsToDisplay === currentValue.reportsToDisplay ? currentValue.reportsToDisplay : reportsToDisplay;
+        const stableOrderedReportIDs = currentValue && shallowEqual(nextOrderedReportIDs, currentValue.orderedReportIDs) ? currentValue.orderedReportIDs : nextOrderedReportIDs;
+
+        if (stableReportsToDisplay === currentValue?.reportsToDisplay && stableOrderedReportIDs === currentValue?.orderedReportIDs) {
+            return currentValue;
+        }
+
+        return {
+            reportsToDisplay: stableReportsToDisplay,
+            orderedReportIDs: stableOrderedReportIDs,
+        };
+    },
+});
diff --git a/src/libs/actions/OnyxDerived/types.ts b/src/libs/actions/OnyxDerived/types.ts
index a7b14999a9ba..5aae5ddd4714 100644
--- a/src/libs/actions/OnyxDerived/types.ts
+++ b/src/libs/actions/OnyxDerived/types.ts
@@ -13,7 +13,10 @@ type DerivedSourceValues<Deps extends readonly OnyxKey[]> = Partial<{
     [K in Deps[number]]: OnyxCollectionSourceValue<K>;
 }>;
 
-type DerivedValueContext<Key extends OnyxKey, Deps extends NonEmptyTuple<Exclude<OnyxKey, Key>>> = {
+// Deps is loosened to `readonly OnyxKey[]` here so the framework's init loop (which collapses all
+// configs' Key types into a union) doesn't have its `Exclude<OnyxKey, Key>` constraint reject every
+// derived key. Per-config self-reference is still prevented by `OnyxDerivedValueConfig` below.
+type DerivedValueContext<Key extends OnyxKey, Deps extends readonly OnyxKey[]> = {
     currentValue?: OnyxValue<Key>;
     sourceValues?: DerivedSourceValues<Deps>;
 };
diff --git a/src/types/onyx/DerivedValues.ts b/src/types/onyx/DerivedValues.ts
index bbcecb4f4d6f..1df5b4cc0d57 100644
--- a/src/types/onyx/DerivedValues.ts
+++ b/src/types/onyx/DerivedValues.ts
@@ -283,6 +283,27 @@ type SortedReportActionsDerivedValue = {
  */
 type PersonalAndWorkspaceCardListDerivedValue = CardList;
 
+/**
+ * A report enriched with LHN-only metadata used during sidebar filtering/sorting.
+ */
+type SidebarReportForLHN = Report & {
+    /** True when report has non-receipt errors surfaced in LHN. */
+    hasErrorsOtherThanFailedReceipt?: boolean;
+    /** True when report requires action from current user (GBR). */
+    requiresAttention?: boolean;
+};
+
+/**
+ * The derived value for the LHN sidebar ordering. Computed outside React to avoid React's
+ * batching dropping intermediate Onyx source-value updates.
+ */
+type SidebarOrderedReportsDerivedValue = {
+    /** Reports kept after LHN filtering, keyed by `reports_<id>` (the same shape as the REPORT collection). */
+    reportsToDisplay: Record<string, SidebarReportForLHN>;
+    /** Sorted report IDs (no `reports_` prefix) representing LHN row order. */
+    orderedReportIDs: string[];
+};
+
 export type {
     ReportAttributes,
     ReportAttributesDerivedValue,
@@ -301,4 +322,6 @@ export type {
     CardFeedErrorState,
     CardFeedErrors,
     CardErrors,
+    SidebarOrderedReportsDerivedValue,
+    SidebarReportForLHN,
 };
diff --git a/src/types/onyx/index.ts b/src/types/onyx/index.ts
index 574568fa4d17..22bc20081107 100644
--- a/src/types/onyx/index.ts
+++ b/src/types/onyx/index.ts
@@ -52,6 +52,7 @@ import type {
     PersonalAndWorkspaceCardListDerivedValue,
     ReportAttributesDerivedValue,
     ReportTransactionsAndViolationsDerivedValue,
+    SidebarOrderedReportsDerivedValue,
     SortedReportActionsDerivedValue,
     TodoMetadata,
     TodosDerivedValue,
@@ -390,6 +391,7 @@ export type {
     OpenAndSubmittedReportsByPolicyIDDerivedValue,
     VisibleReportActionsDerivedValue,
     SortedReportActionsDerivedValue,
+    SidebarOrderedReportsDerivedValue,
     NonPersonalAndWorkspaceCardListDerivedValue,
     PersonalAndWorkspaceCardListDerivedValue,
     CardFeedErrorsDerivedValue,
diff --git a/tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts b/tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts
new file mode 100644
index 000000000000..42f8df1cf2db
--- /dev/null
+++ b/tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts
@@ -0,0 +1,88 @@
+import {rand} from '@ngneat/falso';
+import type {OnyxCollection} from 'react-native-onyx';
+import Onyx from 'react-native-onyx';
+import {measureFunction} from 'reassure';
+import type {DerivedValueContext} from '@libs/actions/OnyxDerived/types';
+import CONST from '@src/CONST';
+import sidebarOrderedReportsConfig from '@src/libs/actions/OnyxDerived/configs/sidebarOrderedReports';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Beta, Network} from '@src/types/onyx';
+import type PriorityMode from '@src/types/onyx/PriorityMode';
+import type Report from '@src/types/onyx/Report';
+import createCollection from '../utils/collections/createCollection';
+import {getRandomDate} from '../utils/collections/reportActions';
+import {createRandomReport} from '../utils/collections/reports';
+import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
+
+type ConfigArgs = Parameters<typeof sidebarOrderedReportsConfig.compute>[0];
+
+const REPORTS_COUNT = 15000;
+const REPORT_THRESHOLD = 5;
+const SOURCE_UPDATE_BATCH = 10;
+
+const allReports: OnyxCollection<Report> = createCollection<Report>(
+    (item) => `${ONYXKEYS.COLLECTION.REPORT}${item.reportID}`,
+    (index) => ({
+        ...createRandomReport(index, undefined),
+        type: rand(Object.values(CONST.REPORT.TYPE)),
+        lastVisibleActionCreated: getRandomDate(),
+        statusNum: index % REPORT_THRESHOLD ? 0 : CONST.REPORT.STATUS_NUM.CLOSED,
+        stateNum: index % REPORT_THRESHOLD ? 0 : CONST.REPORT.STATE_NUM.APPROVED,
+        isUnreadWithMention: false,
+    }),
+    REPORTS_COUNT,
+);
+
+const mockedBetas: Beta[] = Object.values(CONST.BETAS) as Beta[];
+const defaultPriorityMode = CONST.PRIORITY_MODE.DEFAULT as PriorityMode;
+const network: Network = {};
+const locale = 'en';
+
+const EMPTY_CONTEXT: DerivedValueContext<typeof sidebarOrderedReportsConfig.key, typeof sidebarOrderedReportsConfig.dependencies> = {
+    currentValue: undefined,
+    sourceValues: undefined,
+};
+
+function buildArgs(): ConfigArgs {
+    return [allReports, undefined, undefined, undefined, undefined, undefined, defaultPriorityMode, mockedBetas, network, locale] as unknown as ConfigArgs;
+}
+
+describe('SidebarOrderedReports derived value', () => {
+    beforeAll(() => {
+        Onyx.init({keys: ONYXKEYS, evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS]});
+        Onyx.multiSet({[ONYXKEYS.NVP_PREFERRED_LOCALE]: 'en'});
+    });
+
+    afterAll(() => {
+        Onyx.clear();
+    });
+
+    test('[sidebarOrderedReports] full compute, 15k reports, DEFAULT priorityMode', async () => {
+        await waitForBatchedUpdates();
+        await measureFunction(() => sidebarOrderedReportsConfig.compute(buildArgs(), EMPTY_CONTEXT));
+    });
+
+    test('[sidebarOrderedReports] full compute, 15k reports, GSD priorityMode', async () => {
+        await waitForBatchedUpdates();
+        const args = buildArgs();
+        args[6] = CONST.PRIORITY_MODE.GSD as PriorityMode;
+        await measureFunction(() => sidebarOrderedReportsConfig.compute(args, EMPTY_CONTEXT));
+    });
+
+    test('[sidebarOrderedReports] incremental compute, 15k reports, ~10 changed', async () => {
+        await waitForBatchedUpdates();
+        const seeded = sidebarOrderedReportsConfig.compute(buildArgs(), EMPTY_CONTEXT);
+        const reportKeys = Object.keys(allReports ?? {}).slice(0, SOURCE_UPDATE_BATCH);
+        const sourceValue: Record<string, Report | undefined> = {};
+        for (const key of reportKeys) {
+            sourceValue[key] = allReports?.[key];
+        }
+
+        await measureFunction(() =>
+            sidebarOrderedReportsConfig.compute(buildArgs(), {
+                currentValue: seeded,
+                sourceValues: {[ONYXKEYS.COLLECTION.REPORT]: sourceValue},
+            }),
+        );
+    });
+});
diff --git a/tests/unit/SidebarOrderedReportsDerivedValueTest.ts b/tests/unit/SidebarOrderedReportsDerivedValueTest.ts
new file mode 100644
index 000000000000..305782be44b2
--- /dev/null
+++ b/tests/unit/SidebarOrderedReportsDerivedValueTest.ts
@@ -0,0 +1,161 @@
+import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
+import type {DerivedValueContext} from '@libs/actions/OnyxDerived/types';
+import SidebarUtils from '@libs/SidebarUtils';
+import CONST from '@src/CONST';
+import sidebarOrderedReportsConfig from '@src/libs/actions/OnyxDerived/configs/sidebarOrderedReports';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Beta, Network, Report} from '@src/types/onyx';
+import type PriorityMode from '@src/types/onyx/PriorityMode';
+
+type ConfigArgs = Parameters<typeof sidebarOrderedReportsConfig.compute>[0];
+type DerivedContext = DerivedValueContext<typeof sidebarOrderedReportsConfig.key, typeof sidebarOrderedReportsConfig.dependencies>;
+
+const EMPTY_CONTEXT: DerivedContext = {currentValue: undefined, sourceValues: undefined};
+
+function makeReport(id: string, millisAgo: number, overrides: Partial<Report> = {}): Report {
+    const ts = new Date(Date.now() - millisAgo).toISOString().replace('T', ' ').slice(0, -1);
+    return {
+        reportID: id,
+        type: CONST.REPORT.TYPE.CHAT,
+        chatType: CONST.REPORT.CHAT_TYPE.GROUP,
+        reportName: `Report ${id}`,
+        lastVisibleActionCreated: ts,
+        lastReadTime: ts,
+        lastMessageText: `msg ${id}`,
+        participants: Object.fromEntries([1, 2].map((accountID) => [accountID, {notificationPreference: 'always'}])),
+        ...overrides,
+    } as Report;
+}
+
+function buildArgs(reports: OnyxCollection<Report>, overrides: Partial<{priorityMode: PriorityMode; betas: Beta[]; network: Network; locale: string}> = {}): ConfigArgs {
+    const priorityMode: OnyxEntry<PriorityMode> = overrides.priorityMode ?? (CONST.PRIORITY_MODE.DEFAULT as PriorityMode);
+    const betas: OnyxEntry<Beta[]> = overrides.betas ?? [];
+    const network: OnyxEntry<Network> = overrides.network ?? {};
+    const locale = overrides.locale ?? 'en';
+    return [reports, undefined, undefined, undefined, undefined, undefined, priorityMode, betas, network, locale] as unknown as ConfigArgs;
+}
+
+describe('SidebarOrderedReports Derived Value', () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it('returns empty value when reports collection is empty', () => {
+        const result = sidebarOrderedReportsConfig.compute(buildArgs({}), EMPTY_CONTEXT);
+        expect(result.orderedReportIDs).toEqual([]);
+        expect(result.reportsToDisplay).toEqual({});
+    });
+
+    it('returns empty value when reports is undefined', () => {
+        const result = sidebarOrderedReportsConfig.compute(buildArgs(undefined), EMPTY_CONTEXT);
+        expect(result.orderedReportIDs).toEqual([]);
+        expect(result.reportsToDisplay).toEqual({});
+    });
+
+    it('takes the full-compute path when no currentValue exists', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}1`]: makeReport('1', 1_000)};
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), EMPTY_CONTEXT);
+
+        expect(getSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('takes the incremental path when a collection sourceValue is present and the cache is populated', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}1`]: makeReport('1', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: reports[`${ONYXKEYS.COLLECTION.REPORT}1`]},
+            orderedReportIDs: ['1'],
+        };
+
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.REPORT]: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: reports[`${ONYXKEYS.COLLECTION.REPORT}1`]}},
+        });
+
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(getSpy).not.toHaveBeenCalled();
+    });
+
+    it('falls back to the full path when sourceValues is undefined even if currentValue exists', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}1`]: makeReport('1', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: reports[`${ONYXKEYS.COLLECTION.REPORT}1`]},
+            orderedReportIDs: ['1'],
+        };
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {currentValue: seededCurrent, sourceValues: undefined});
+
+        expect(getSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('translates REPORT_NAME_VALUE_PAIRS source keys to REPORT keys in the incremental path', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}99`]: makeReport('99', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}99`]: reports[`${ONYXKEYS.COLLECTION.REPORT}99`]},
+            orderedReportIDs: ['99'],
+        };
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS]: {[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}99`]: {}}},
+        });
+
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        const callArgs = updateSpy.mock.calls.at(0)?.at(0);
+        expect(callArgs?.updatedReportsKeys).toEqual([`${ONYXKEYS.COLLECTION.REPORT}99`]);
+    });
+
+    it('translates REPORT_DRAFT_COMMENT source keys to REPORT keys in the incremental path', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}42`]: makeReport('42', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}42`]: reports[`${ONYXKEYS.COLLECTION.REPORT}42`]},
+            orderedReportIDs: ['42'],
+        };
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT]: {[`${ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT}42`]: 'draft'}},
+        });
+
+        const callArgs = updateSpy.mock.calls.at(0)?.at(0);
+        expect(callArgs?.updatedReportsKeys).toEqual([`${ONYXKEYS.COLLECTION.REPORT}42`]);
+    });
+
+    it('cascades a POLICY change to every report under that policy', () => {
+        const policyID = 'POL1';
+        const reports: Record<string, Report> = {
+            [`${ONYXKEYS.COLLECTION.REPORT}a`]: makeReport('a', 1_000, {policyID}),
+            [`${ONYXKEYS.COLLECTION.REPORT}b`]: makeReport('b', 2_000, {policyID}),
+            [`${ONYXKEYS.COLLECTION.REPORT}c`]: makeReport('c', 3_000, {policyID: 'OTHER'}),
+        };
+        const seededCurrent = {
+            reportsToDisplay: {
+                [`${ONYXKEYS.COLLECTION.REPORT}a`]: reports[`${ONYXKEYS.COLLECTION.REPORT}a`],
+                [`${ONYXKEYS.COLLECTION.REPORT}b`]: reports[`${ONYXKEYS.COLLECTION.REPORT}b`],
+                [`${ONYXKEYS.COLLECTION.REPORT}c`]: reports[`${ONYXKEYS.COLLECTION.REPORT}c`],
+            },
+            orderedReportIDs: ['a', 'b', 'c'],
+        };
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.POLICY]: {[`${ONYXKEYS.COLLECTION.POLICY}${policyID}`]: {}}} as never,
+        });
+
+        const callArgs = updateSpy.mock.calls.at(0)?.at(0);
+        const keys = (callArgs?.updatedReportsKeys ?? []).slice().sort();
+        expect(keys).toEqual([`${ONYXKEYS.COLLECTION.REPORT}a`, `${ONYXKEYS.COLLECTION.REPORT}b`]);
+    });
+});
diff --git a/tests/unit/useSidebarOrderedReportsTest.tsx b/tests/unit/useSidebarOrderedReportsTest.tsx
index 442bd868d9d9..58783f8d8725 100644
--- a/tests/unit/useSidebarOrderedReportsTest.tsx
+++ b/tests/unit/useSidebarOrderedReportsTest.tsx
@@ -11,11 +11,10 @@ import ONYXKEYS from '@src/ONYXKEYS';
 import type {Report} from '@src/types/onyx';
 import waitForBatchedUpdatesWithAct from '../utils/waitForBatchedUpdatesWithAct';
 
-// Mock dependencies
 jest.mock('@libs/SidebarUtils', () => ({
-    sortReportsToDisplayInLHN: jest.fn(),
-    getReportsToDisplayInLHN: jest.fn(),
-    updateReportsToDisplayInLHN: jest.fn(),
+    sortReportsToDisplayInLHN: jest.fn(() => []),
+    getReportsToDisplayInLHN: jest.fn(() => ({})),
+    updateReportsToDisplayInLHN: jest.fn(({displayedReports}: {displayedReports: unknown}) => displayedReports),
 }));
 jest.mock('@libs/Navigation/Navigation', () => ({
     getActiveRouteWithoutParams: jest.fn(() => ''),
@@ -29,10 +28,19 @@ jest.mock('@libs/ReportUtils', () => ({
 
 const mockSidebarUtils = SidebarUtils as jest.Mocked<typeof SidebarUtils>;
 
+function makeReport(id: string, overrides: Partial<Report> = {}): Report {
+    return {
+        reportID: id,
+        reportName: `Report ${id}`,
+        lastVisibleActionCreated: '2024-01-01 10:00:00',
+        type: CONST.REPORT.TYPE.CHAT,
+        ...overrides,
+    } as Report;
+}
+
 describe('useSidebarOrderedReports', () => {
     beforeAll(async () => {
         Onyx.init({keys: ONYXKEYS});
-        // Set up basic session data
         await act(async () => {
             await Onyx.set(ONYXKEYS.SESSION, {
                 accountID: 12345,
@@ -45,18 +53,14 @@ describe('useSidebarOrderedReports', () => {
 
     beforeEach(async () => {
         jest.clearAllMocks();
+        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue([]);
+        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
+        mockSidebarUtils.updateReportsToDisplayInLHN.mockImplementation(({displayedReports}) => displayedReports);
+
         await act(async () => {
             await Onyx.clear();
-
-            // Set up basic session data for each test
-            await Onyx.set(ONYXKEYS.SESSION, {
-                accountID: 12345,
-                email: 'test@example.com',
-                authTokenType: CONST.AUTH_TOKEN_TYPES.ANONYMOUS,
-            });
-
-            // Set up required Onyx data that the hook depends on
             await Onyx.multiSet({
+                [ONYXKEYS.SESSION]: {accountID: 12345, email: 'test@example.com', authTokenType: CONST.AUTH_TOKEN_TYPES.ANONYMOUS},
                 [ONYXKEYS.NVP_PRIORITY_MODE]: CONST.PRIORITY_MODE.DEFAULT,
                 [ONYXKEYS.COLLECTION.REPORT]: {},
                 [ONYXKEYS.COLLECTION.POLICY]: {},
@@ -66,16 +70,9 @@ describe('useSidebarOrderedReports', () => {
                 [ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT]: {},
                 [ONYXKEYS.BETAS]: [],
                 [ONYXKEYS.DERIVED.REPORT_ATTRIBUTES]: {reports: {}},
+                [ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS]: {reportsToDisplay: {}, orderedReportIDs: []},
             } as unknown as OnyxMultiSetInput);
         });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Default mock implementations
-        mockSidebarUtils.getReportsToDisplayInLHN.mockImplementation(() => ({}));
-        mockSidebarUtils.updateReportsToDisplayInLHN.mockImplementation(({displayedReports}) => displayedReports);
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue([]);
-
         await waitForBatchedUpdatesWithAct();
     });
 
@@ -86,227 +83,79 @@ describe('useSidebarOrderedReports', () => {
         await waitForBatchedUpdatesWithAct();
     });
 
-    const createMockReports = (reports: Record<string, Partial<Report>>) => {
-        const mockReports: Record<string, Report> = {};
-        for (const [key, report] of Object.entries(reports)) {
-            const reportId = key.replace('report', '');
-            mockReports[reportId] = {
-                reportID: reportId,
-                reportName: `Report ${reportId}`,
-                lastVisibleActionCreated: '2024-01-01 10:00:00',
-                type: CONST.REPORT.TYPE.CHAT,
-                ...report,
-            } as Report;
-        }
-        return mockReports;
-    };
-
-    let currentReportIDForTestsValue: string | undefined;
+    let currentReportIDForTest: string | undefined;
 
     function TestWrapper({children}: {children: React.ReactNode}) {
         return (
             <OnyxListItemProvider>
                 <CurrentReportIDContextProvider>
-                    <SidebarOrderedReportsContextProvider currentReportIDForTests={currentReportIDForTestsValue}>{children}</SidebarOrderedReportsContextProvider>
+                    <SidebarOrderedReportsContextProvider currentReportIDForTests={currentReportIDForTest}>{children}</SidebarOrderedReportsContextProvider>
                 </CurrentReportIDContextProvider>
             </OnyxListItemProvider>
         );
     }
 
-    it('should prevent unnecessary re-renders when reports have same content but different references', async () => {
-        // Given reports with same content but different object references
-        const reportsContent = {
-            report1: {reportName: 'Chat 1', lastVisibleActionCreated: '2024-01-01 10:00:00'},
-            report2: {reportName: 'Chat 2', lastVisibleActionCreated: '2024-01-01 11:00:00'},
-        };
-
-        // When the initial reports are set
-        const initialReports = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(initialReports);
-        mockSidebarUtils.updateReportsToDisplayInLHN.mockImplementation(({displayedReports}) => displayedReports);
-        currentReportIDForTestsValue = '1';
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-
-        // When the reports are updated
-        const newReportsWithSameContent = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(newReportsWithSameContent);
-
-        rerender({});
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then sortReportsToDisplayInLHN should not be called again since deep comparison shows no change
-        expect(mockSidebarUtils.sortReportsToDisplayInLHN).not.toHaveBeenCalled();
-    });
-
-    it('should trigger re-render when reports content actually changes', async () => {
-        // Given the initial reports are set
-        const initialReports = createMockReports({
-            report1: {reportName: 'Chat 1'},
-            report2: {reportName: 'Chat 2'},
-        });
-
-        // When the reports are updated
-        const updatedReports = createMockReports({
-            report1: {reportName: 'Chat 1 Updated'}, // Content changed
-            report2: {reportName: 'Chat 2'},
-            report3: {reportName: 'Chat 3'}, // New report added
-        });
-
-        // Then the initial reports are set
+    it('surfaces orderedReportIDs and orderedReports from the derived Onyx value', async () => {
+        currentReportIDForTest = '1';
+        const report1 = makeReport('1');
+        const report2 = makeReport('2');
         await act(async () => {
             await Onyx.multiSet({
-                [`${ONYXKEYS.COLLECTION.REPORT}1`]: initialReports['1'],
-                [`${ONYXKEYS.COLLECTION.REPORT}2`]: initialReports['2'],
+                [`${ONYXKEYS.COLLECTION.REPORT}1`]: report1,
+                [`${ONYXKEYS.COLLECTION.REPORT}2`]: report2,
+                [ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS]: {
+                    reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: report1, [`${ONYXKEYS.COLLECTION.REPORT}2`]: report2},
+                    orderedReportIDs: ['2', '1'],
+                },
             } as unknown as OnyxMultiSetInput);
         });
-
         await waitForBatchedUpdatesWithAct();
 
-        // When the mock is updated
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(initialReports);
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
+        const {result} = renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-
-        // When the mocks are updated to reflect the new content
-        // getReportsToDisplayInLHN covers the full-scan path; updateReportsToDisplayInLHN covers
-        // the incremental path (taken when priority mode changes and the cache is already populated).
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(updatedReports);
-        mockSidebarUtils.updateReportsToDisplayInLHN.mockReturnValue(updatedReports);
-
-        // When the priority mode is changed
-        await act(async () => {
-            await Onyx.set(ONYXKEYS.NVP_PRIORITY_MODE, CONST.PRIORITY_MODE.GSD);
-        });
-
-        rerender({});
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then sortReportsToDisplayInLHN should be called with the updated reports
-        expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalledWith(
-            updatedReports,
-            expect.any(String), // priorityMode
-            expect.any(Function), // localeCompare
-            expect.any(Object), // reportsDrafts
-            expect.any(Object), // reportNameValuePairs
-            expect.anything(), // reportAttributes
-        );
+        expect(result.current.orderedReportIDs).toEqual(['2', '1']);
+        expect(result.current.orderedReports.map((r) => r.reportID)).toEqual(['2', '1']);
+        expect(result.current.currentReportID).toBe('1');
     });
 
-    it('should handle empty reports correctly with deep comparison', async () => {
-        // Given the initial reports are set
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
+    it('does not call SidebarUtils when the current report is already in the derived list', async () => {
+        currentReportIDForTest = '1';
+        const report1 = makeReport('1');
+        await act(async () => {
+            await Onyx.multiSet({
+                [`${ONYXKEYS.COLLECTION.REPORT}1`]: report1,
+                [ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS]: {
+                    reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: report1},
+                    orderedReportIDs: ['1'],
+                },
+            } as unknown as OnyxMultiSetInput);
         });
-
         await waitForBatchedUpdatesWithAct();
 
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-
-        // When the mock is updated
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
-
-        rerender({});
-
+        renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        // Then sortReportsToDisplayInLHN should not be called again since reports are empty
+        expect(mockSidebarUtils.getReportsToDisplayInLHN).not.toHaveBeenCalled();
         expect(mockSidebarUtils.sortReportsToDisplayInLHN).not.toHaveBeenCalled();
     });
 
-    it('should maintain referential stability across multiple renders with same content', async () => {
-        // Given the initial reports are set
-        const reportsContent = {
-            report1: {reportName: 'Stable Chat'},
-        };
-
-        // When the initial reports are set
-        const initialReports = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(initialReports);
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue(['1']);
-        currentReportIDForTestsValue = '1';
-
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // When the mock is updated
-        const newReportsWithSameContent = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(newReportsWithSameContent);
-
-        rerender({});
-        await waitForBatchedUpdatesWithAct();
-        currentReportIDForTestsValue = '2';
-
-        // When the mock is updated
-        const thirdReportsWithSameContent = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(thirdReportsWithSameContent);
-
-        rerender({});
-        await waitForBatchedUpdatesWithAct();
-        currentReportIDForTestsValue = '3';
-
-        // Then sortReportsToDisplayInLHN should be called only once (initial render)
-        expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle priority mode changes correctly with deep comparison', async () => {
-        // Given the initial reports are set
-        const reports = createMockReports({
-            report1: {reportName: 'Chat A'},
-            report2: {reportName: 'Chat B'},
-        });
-
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(reports);
-        currentReportIDForTestsValue = '1';
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-        currentReportIDForTestsValue = '2';
-
-        // When the priority mode is changed
+    it('runs the SidebarUtils fallback when the current report is missing and the derived list is empty', async () => {
+        currentReportIDForTest = '2';
         await act(async () => {
-            await Onyx.set(ONYXKEYS.NVP_PRIORITY_MODE, CONST.PRIORITY_MODE.GSD);
+            await Onyx.multiSet({
+                [ONYXKEYS.DERIVED.SIDEBAR_ORDERED_REPORTS]: {reportsToDisplay: {}, orderedReportIDs: []},
+            } as unknown as OnyxMultiSetInput);
         });
-
         await waitForBatchedUpdatesWithAct();
 
-        rerender({});
+        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
+        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue(['2']);
 
+        renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        // Then sortReportsToDisplayInLHN should be called when priority mode changes
+        expect(mockSidebarUtils.getReportsToDisplayInLHN).toHaveBeenCalled();
         expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalled();
     });
 });

From 820717d4aa32e136f6fab946b794dafaf535f657 Mon Sep 17 00:00:00 2001
From: Chuck Dries <chuck@expensify.com>
Date: Fri, 29 May 2026 14:32:59 -0700
Subject: [PATCH 2/5] Use updateReportsToDisplayInLHN to inject currently
 focused report into cached value in hook

---
 src/hooks/useSidebarOrderedReports.tsx      | 19 +++++++----
 tests/unit/SidebarUtilsTest.ts              | 36 +++++++++++++++++++++
 tests/unit/useSidebarOrderedReportsTest.tsx | 15 ++++++---
 3 files changed, 58 insertions(+), 12 deletions(-)

diff --git a/src/hooks/useSidebarOrderedReports.tsx b/src/hooks/useSidebarOrderedReports.tsx
index eda2d089a5f6..f838b14c7f34 100644
--- a/src/hooks/useSidebarOrderedReports.tsx
+++ b/src/hooks/useSidebarOrderedReports.tsx
@@ -15,6 +15,8 @@ import useResponsiveLayout from './useResponsiveLayout';
 
 const componentsUsingHook = new Map<string, {renderDuration: number}>();
 
+const EMPTY_ORDERED_REPORT_IDS: string[] = [];
+
 type SidebarOrderedReportsContextProviderProps = {
     children: React.ReactNode;
     currentReportIDForTests?: string;
@@ -64,7 +66,7 @@ function SidebarOrderedReportsContextProvider({
     const {currentReportID: currentReportIDValue} = useCurrentReportIDState();
     const derivedCurrentReportID = currentReportIDForTests ?? currentReportIDValue;
 
-    const baseOrderedReportIDs = derived?.orderedReportIDs ?? [];
+    const baseOrderedReportIDs = derived?.orderedReportIDs ?? EMPTY_ORDERED_REPORT_IDS;
     const baseReportsToDisplay = derived?.reportsToDisplay;
 
     // Web parity: when the active report would not normally pass `shouldDisplayReportInLHN` we still
@@ -81,19 +83,21 @@ function SidebarOrderedReportsContextProvider({
             return baseOrderedReportIDs;
         }
 
-        const reportsToDisplay = SidebarUtils.getReportsToDisplayInLHN({
-            currentReportId: derivedCurrentReportID,
+        const reportsToDisplay = SidebarUtils.updateReportsToDisplayInLHN({
+            displayedReports: baseReportsToDisplay ?? {},
             reports: chatReports,
+            updatedReportsKeys: [`${ONYXKEYS.COLLECTION.REPORT}${derivedCurrentReportID}`],
+            currentReportId: derivedCurrentReportID,
+            isInFocusMode: priorityMode === CONST.PRIORITY_MODE.GSD,
             betas,
-            priorityMode,
-            draftComments: reportsDrafts,
             transactionViolations,
+            reportNameValuePairs,
+            reportAttributes,
+            draftComments: reportsDrafts,
             transactions,
             isOffline,
             currentUserLogin: currentUserLogin ?? '',
             currentUserAccountID: accountID,
-            reportNameValuePairs,
-            reportAttributes,
         });
 
         const hasDraftByReportID: Record<string, boolean> = {};
@@ -108,6 +112,7 @@ function SidebarOrderedReportsContextProvider({
         return SidebarUtils.sortReportsToDisplayInLHN(reportsToDisplay, priorityMode, localeCompare, hasDraftByReportID, reportNameValuePairs, reportAttributes);
     }, [
         baseOrderedReportIDs,
+        baseReportsToDisplay,
         shouldUseNarrowLayout,
         derivedCurrentReportID,
         chatReports,
diff --git a/tests/unit/SidebarUtilsTest.ts b/tests/unit/SidebarUtilsTest.ts
index 058c41917496..c8fad8ca88ae 100644
--- a/tests/unit/SidebarUtilsTest.ts
+++ b/tests/unit/SidebarUtilsTest.ts
@@ -3867,6 +3867,42 @@ describe('SidebarUtils', () => {
                 expect(result).not.toBe(displayedReports);
                 expect(result['0']).toBeUndefined();
             });
+
+            it('includes a report that is otherwise hidden only when it is the focused report', () => {
+                // A report with no participants is hidden for the current user. With no pin/draft/error/attention,
+                // the only thing that can surface it is the focus override (currentReportId === reportID).
+                const reportKey = `${ONYXKEYS.COLLECTION.REPORT}7`;
+                const report: Report = {
+                    ...createRandomReport(7, undefined),
+                    reportID: '7',
+                    type: CONST.REPORT.TYPE.CHAT,
+                    isPinned: false,
+                    isOwnPolicyExpenseChat: false,
+                };
+                const reports: OnyxCollection<Report> = {[reportKey]: report};
+
+                const baseParams = {
+                    displayedReports: {},
+                    reports,
+                    updatedReportsKeys: [reportKey],
+                    isInFocusMode: false,
+                    betas: [],
+                    transactions: {},
+                    transactionViolations: {},
+                    reportNameValuePairs: {},
+                    reportAttributes: undefined,
+                    draftComments: {},
+                    isOffline: false,
+                    currentUserLogin: CURRENT_USER_LOGIN,
+                    currentUserAccountID: CURRENT_USER_ACCOUNT_ID,
+                };
+
+                const resultWithoutFocus = SidebarUtils.updateReportsToDisplayInLHN({...baseParams, currentReportId: undefined});
+                expect(resultWithoutFocus[reportKey]).toBeUndefined();
+
+                const resultWithFocus = SidebarUtils.updateReportsToDisplayInLHN({...baseParams, currentReportId: '7'});
+                expect(resultWithFocus[reportKey]).toBeDefined();
+            });
         });
 
         describe('getReportsToDisplayInLHN', () => {
diff --git a/tests/unit/useSidebarOrderedReportsTest.tsx b/tests/unit/useSidebarOrderedReportsTest.tsx
index 58783f8d8725..acfc726d553a 100644
--- a/tests/unit/useSidebarOrderedReportsTest.tsx
+++ b/tests/unit/useSidebarOrderedReportsTest.tsx
@@ -136,11 +136,11 @@ describe('useSidebarOrderedReports', () => {
         renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        expect(mockSidebarUtils.getReportsToDisplayInLHN).not.toHaveBeenCalled();
+        expect(mockSidebarUtils.updateReportsToDisplayInLHN).not.toHaveBeenCalled();
         expect(mockSidebarUtils.sortReportsToDisplayInLHN).not.toHaveBeenCalled();
     });
 
-    it('runs the SidebarUtils fallback when the current report is missing and the derived list is empty', async () => {
+    it('injects the current report via updateReportsToDisplayInLHN when missing from the derived list', async () => {
         currentReportIDForTest = '2';
         await act(async () => {
             await Onyx.multiSet({
@@ -149,13 +149,18 @@ describe('useSidebarOrderedReports', () => {
         });
         await waitForBatchedUpdatesWithAct();
 
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
         mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue(['2']);
 
-        renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
+        const {result} = renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        expect(mockSidebarUtils.getReportsToDisplayInLHN).toHaveBeenCalled();
+        expect(mockSidebarUtils.updateReportsToDisplayInLHN).toHaveBeenCalledWith(
+            expect.objectContaining({
+                currentReportId: '2',
+                updatedReportsKeys: [`${ONYXKEYS.COLLECTION.REPORT}2`],
+            }),
+        );
         expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalled();
+        expect(result.current.orderedReportIDs).toEqual(['2']);
     });
 });

From b581b7fc2fff9a3aa4726ca2c89c2ac022c9b62c Mon Sep 17 00:00:00 2001
From: Chuck Dries <chuck@expensify.com>
Date: Fri, 29 May 2026 14:51:19 -0700
Subject: [PATCH 3/5] Remove orderedReports from
 SidebarOrderedReportsStateContextValue

---
 .../LHNOptionsList/LHNOptionsList.tsx         | 19 ++++++++-------
 .../LHNTooltipContextProvider.tsx             |  8 +++----
 src/components/LHNOptionsList/types.ts        |  6 ++---
 src/hooks/useSidebarOrderedReports.tsx        | 19 +--------------
 src/pages/inbox/sidebar/SidebarLinks.tsx      |  2 +-
 src/pages/inbox/sidebar/SidebarLinksData.tsx  |  4 ++--
 tests/ui/components/LHNOptionsListTest.tsx    | 23 +++++++++++--------
 tests/unit/useSidebarOrderedReportsTest.tsx   |  3 +--
 8 files changed, 34 insertions(+), 50 deletions(-)

diff --git a/src/components/LHNOptionsList/LHNOptionsList.tsx b/src/components/LHNOptionsList/LHNOptionsList.tsx
index 40188b79d7d7..1fcba95f4ac6 100644
--- a/src/components/LHNOptionsList/LHNOptionsList.tsx
+++ b/src/components/LHNOptionsList/LHNOptionsList.tsx
@@ -15,20 +15,19 @@ import getPlatform from '@libs/getPlatform';
 import variables from '@styles/variables';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Report} from '@src/types/onyx';
 import LHNTooltipContextProvider from './LHNTooltipContextProvider';
 import OptionRowLHNData from './OptionRowLHN';
 import OptionRowRendererComponent from './OptionRowRendererComponent';
 import type {LHNOptionsListProps, RenderItemProps} from './types';
 
-const keyExtractor = (item: Report) => `report_${item.reportID}`;
+const keyExtractor = (item: string) => `report_${item}`;
 const platform = getPlatform();
 const isWeb = platform === CONST.PLATFORM.WEB;
 
 function LHNOptionsList({style, contentContainerStyles, data, onSelectRow, optionMode, shouldDisableFocusOptions = false, onFirstItemRendered = () => {}}: LHNOptionsListProps) {
     const {saveScrollOffset, getScrollOffset, saveScrollIndex, getScrollIndex} = useContext(ScrollOffsetContext);
     const {isOffline} = useNetwork();
-    const flashListRef = useRef<FlashListRef<Report>>(null);
+    const flashListRef = useRef<FlashListRef<string>>(null);
     const route = useRoute();
     const [reports] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
     const reportAttributes = useReportAttributes();
@@ -57,26 +56,26 @@ function LHNOptionsList({style, contentContainerStyles, data, onSelectRow, optio
      * Function which renders a row in the list
      */
     const renderItem = useCallback(
-        ({item, index}: RenderItemProps): ReactElement => {
-            const reportID = item.reportID;
+        ({item: reportID, index}: RenderItemProps): ReactElement => {
+            const fullReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
             const itemReportAttributes = reportAttributes?.[reportID];
-            const itemParentReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${item.parentReportID}`];
+            const itemParentReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${fullReport?.parentReportID}`];
             const itemOneTransactionThreadReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${itemReportAttributes?.oneTransactionThreadReportID}`];
 
             let invoiceReceiverPolicyID = '-1';
-            if (item?.invoiceReceiver && 'policyID' in item.invoiceReceiver) {
-                invoiceReceiverPolicyID = item.invoiceReceiver.policyID;
+            if (fullReport?.invoiceReceiver && 'policyID' in fullReport.invoiceReceiver) {
+                invoiceReceiverPolicyID = fullReport.invoiceReceiver.policyID;
             }
             if (itemParentReport?.invoiceReceiver && 'policyID' in itemParentReport.invoiceReceiver) {
                 invoiceReceiverPolicyID = itemParentReport.invoiceReceiver.policyID;
             }
             const itemInvoiceReceiverPolicy = policy?.[`${ONYXKEYS.COLLECTION.POLICY}${invoiceReceiverPolicyID}`];
-            const itemPolicy = policy?.[`${ONYXKEYS.COLLECTION.POLICY}${item?.policyID}`];
+            const itemPolicy = policy?.[`${ONYXKEYS.COLLECTION.POLICY}${fullReport?.policyID}`];
 
             return (
                 <OptionRowLHNData
                     reportID={reportID}
-                    fullReport={item}
+                    fullReport={fullReport}
                     reportAttributes={itemReportAttributes}
                     reportAttributesDerived={reportAttributes}
                     oneTransactionThreadReport={itemOneTransactionThreadReport}
diff --git a/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx b/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx
index b1fee52092d8..952ff514b14e 100644
--- a/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx
+++ b/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx
@@ -5,12 +5,11 @@ import useReportAttributes from '@hooks/useReportAttributes';
 import useRootNavigationState from '@hooks/useRootNavigationState';
 import NAVIGATORS from '@src/NAVIGATORS';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Report} from '@src/types/onyx';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
 import {LHNTooltipContext} from './LHNTooltipContext';
 
 type LHNTooltipContextProviderProps = {
-    data: Report[];
+    data: string[];
     children: React.ReactNode;
 };
 
@@ -20,14 +19,13 @@ function LHNTooltipContextProvider({data, children}: LHNTooltipContextProviderPr
     const [isFullscreenVisible] = useOnyx(ONYXKEYS.FULLSCREEN_VISIBILITY);
     const reportAttributes = useReportAttributes();
 
-    const firstReport = data.find((report) => {
-        const attrs = reportAttributes?.[report.reportID];
+    const firstReportIDWithGBRorRBR = data.find((reportID) => {
+        const attrs = reportAttributes?.[reportID];
         if (!isEmptyObject(attrs?.reportErrors)) {
             return true;
         }
         return attrs?.requiresAttention;
     });
-    const firstReportIDWithGBRorRBR = firstReport?.reportID;
 
     const isScreenFocused = useIsFocused();
     const isReportsSplitNavigatorLast = useRootNavigationState((state) => state?.routes?.at(-1)?.name === NAVIGATORS.REPORTS_SPLIT_NAVIGATOR);
diff --git a/src/components/LHNOptionsList/types.ts b/src/components/LHNOptionsList/types.ts
index 829de863508a..814079b72f0d 100644
--- a/src/components/LHNOptionsList/types.ts
+++ b/src/components/LHNOptionsList/types.ts
@@ -16,8 +16,8 @@ type CustomLHNOptionsListProps = {
     /** Extra styles for the section list container */
     contentContainerStyles?: StyleProp<ViewStyle>;
 
-    /** List of reports */
-    data: Report[];
+    /** List of report IDs to display, ordered for the LHN */
+    data: string[];
 
     /** Callback to fire when a row is selected */
     onSelectRow?: (optionItem: OptionData, popoverAnchor: RefObject<View | null>) => void;
@@ -97,6 +97,6 @@ type OptionRowLHNProps = {
     testID: number;
 };
 
-type RenderItemProps = {item: Report; index: number};
+type RenderItemProps = {item: string; index: number};
 
 export type {LHNOptionsListProps, OptionRowLHNDataProps, OptionRowLHNProps, RenderItemProps};
diff --git a/src/hooks/useSidebarOrderedReports.tsx b/src/hooks/useSidebarOrderedReports.tsx
index f838b14c7f34..02c07b576319 100644
--- a/src/hooks/useSidebarOrderedReports.tsx
+++ b/src/hooks/useSidebarOrderedReports.tsx
@@ -23,7 +23,6 @@ type SidebarOrderedReportsContextProviderProps = {
 };
 
 type SidebarOrderedReportsStateContextValue = {
-    orderedReports: OnyxTypes.Report[];
     orderedReportIDs: string[];
     currentReportID: string | undefined;
     chatTabBrickRoad: BrickRoad;
@@ -32,7 +31,6 @@ type SidebarOrderedReportsStateContextValue = {
 type ReportsToDisplayInLHN = Record<string, OnyxTypes.Report & {hasErrorsOtherThanFailedReceipt?: boolean; requiresAttention?: boolean}>;
 
 const SidebarOrderedReportsStateContext = createContext<SidebarOrderedReportsStateContextValue>({
-    orderedReports: [],
     orderedReportIDs: [],
     currentReportID: '',
     chatTabBrickRoad: undefined,
@@ -129,28 +127,13 @@ function SidebarOrderedReportsContextProvider({
         localeCompare,
     ]);
 
-    const orderedReports = useMemo(() => {
-        if (!chatReports) {
-            return [];
-        }
-        const result: OnyxTypes.Report[] = [];
-        for (const reportID of orderedReportIDs) {
-            const report = chatReports[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`] ?? baseReportsToDisplay?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
-            if (report) {
-                result.push(report);
-            }
-        }
-        return result;
-    }, [orderedReportIDs, chatReports, baseReportsToDisplay]);
-
     const stateValue: SidebarOrderedReportsStateContextValue = useMemo(
         () => ({
-            orderedReports,
             orderedReportIDs,
             currentReportID: derivedCurrentReportID,
             chatTabBrickRoad: getChatTabBrickRoad(orderedReportIDs, reportAttributes),
         }),
-        [orderedReports, orderedReportIDs, derivedCurrentReportID, reportAttributes],
+        [orderedReportIDs, derivedCurrentReportID, reportAttributes],
     );
 
     return <SidebarOrderedReportsStateContext.Provider value={stateValue}>{children}</SidebarOrderedReportsStateContext.Provider>;
diff --git a/src/pages/inbox/sidebar/SidebarLinks.tsx b/src/pages/inbox/sidebar/SidebarLinks.tsx
index a367a114ca02..6745f7f0b3ea 100644
--- a/src/pages/inbox/sidebar/SidebarLinks.tsx
+++ b/src/pages/inbox/sidebar/SidebarLinks.tsx
@@ -26,7 +26,7 @@ type SidebarLinksProps = {
     insets: EdgeInsets;
 
     /** List of options to display */
-    optionListItems: Report[];
+    optionListItems: string[];
 
     /** The chat priority mode */
     priorityMode?: OnyxEntry<ValueOf<typeof CONST.PRIORITY_MODE>>;
diff --git a/src/pages/inbox/sidebar/SidebarLinksData.tsx b/src/pages/inbox/sidebar/SidebarLinksData.tsx
index 1c4879c15884..592fb94494db 100644
--- a/src/pages/inbox/sidebar/SidebarLinksData.tsx
+++ b/src/pages/inbox/sidebar/SidebarLinksData.tsx
@@ -23,7 +23,7 @@ function SidebarLinksData({insets}: SidebarLinksDataProps) {
     const {translate} = useLocalize();
     const [priorityMode = CONST.PRIORITY_MODE.DEFAULT] = useOnyx(ONYXKEYS.NVP_PRIORITY_MODE);
 
-    const {orderedReports, currentReportID} = useSidebarOrderedReportsState('SidebarLinksData');
+    const {orderedReportIDs, currentReportID} = useSidebarOrderedReportsState('SidebarLinksData');
 
     const currentReportIDRef = useRef(currentReportID);
     currentReportIDRef.current = currentReportID;
@@ -80,7 +80,7 @@ function SidebarLinksData({insets}: SidebarLinksDataProps) {
                 priorityMode={priorityMode ?? CONST.PRIORITY_MODE.DEFAULT}
                 // Data props:
                 isActiveReport={isActiveReport}
-                optionListItems={orderedReports}
+                optionListItems={orderedReportIDs}
             />
         </View>
     );
diff --git a/tests/ui/components/LHNOptionsListTest.tsx b/tests/ui/components/LHNOptionsListTest.tsx
index ae1f424d8ce9..e68177be1171 100644
--- a/tests/ui/components/LHNOptionsListTest.tsx
+++ b/tests/ui/components/LHNOptionsListTest.tsx
@@ -80,7 +80,7 @@ describe('LHNOptionsList', () => {
     const mockReport = getFakeReport([1, 2], 0, false);
 
     const defaultProps: LHNOptionsListProps = {
-        data: [mockReport],
+        data: [mockReport.reportID],
         onSelectRow: jest.fn(),
         optionMode: CONST.OPTION_MODE.DEFAULT,
         onFirstItemRendered: jest.fn(),
@@ -108,7 +108,7 @@ describe('LHNOptionsList', () => {
         );
     };
 
-    beforeEach(() => {
+    beforeEach(async () => {
         act(() => {
             Onyx.init({
                 keys: ONYXKEYS,
@@ -116,6 +116,11 @@ describe('LHNOptionsList', () => {
         });
 
         jest.clearAllMocks();
+
+        // LHNOptionsList resolves each row's report from Onyx by ID, so the default report must be present.
+        await act(async () => {
+            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${mockReport.reportID}`, mockReport);
+        });
     });
 
     afterEach(() => {
@@ -255,7 +260,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList is rendered
-            render(getLHNOptionsListElement({data: [report]}));
+            render(getLHNOptionsListElement({data: [report.reportID]}));
 
             // Then the queued message should be displayed because DEW submissions are processed async and the user needs feedback
             const reportItem = await waitFor(() => getReportItem(reportID));
@@ -312,7 +317,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList is rendered
-            render(getLHNOptionsListElement({data: [report]}));
+            render(getLHNOptionsListElement({data: [report.reportID]}));
 
             // Then the queued message should NOT appear because the server processes DEW submissions immediately when online
             const reportItem = await waitFor(() => getReportItem(reportID));
@@ -379,7 +384,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the workspace thread
-            render(getLHNOptionsListElement({data: [threadReport]}));
+            render(getLHNOptionsListElement({data: [threadReport.reportID]}));
 
             // Then it should render a single avatar, not a diagonal (multiple) avatar
             await waitFor(() => {
@@ -455,7 +460,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the expense request thread
-            render(getLHNOptionsListElement({data: [threadReport]}));
+            render(getLHNOptionsListElement({data: [threadReport.reportID]}));
 
             // Then it should render a subscript avatar (workspace expense requests preserve subscript)
             await waitFor(() => {
@@ -520,7 +525,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the task report
-            render(getLHNOptionsListElement({data: [taskReport]}));
+            render(getLHNOptionsListElement({data: [taskReport.reportID]}));
 
             // Then it should render a subscript avatar (Large User + Small Workspace)
             await waitFor(() => {
@@ -584,7 +589,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the invoice report
-            render(getLHNOptionsListElement({data: [invoiceReport]}));
+            render(getLHNOptionsListElement({data: [invoiceReport.reportID]}));
 
             // Then it should render a subscript avatar (workspace icon + user avatar)
             await waitFor(() => {
@@ -633,7 +638,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the IOU report
-            render(getLHNOptionsListElement({data: [report]}));
+            render(getLHNOptionsListElement({data: [report.reportID]}));
 
             // Then it should render diagonal (multiple) avatars
             await waitFor(() => {
diff --git a/tests/unit/useSidebarOrderedReportsTest.tsx b/tests/unit/useSidebarOrderedReportsTest.tsx
index acfc726d553a..1d533a3f312d 100644
--- a/tests/unit/useSidebarOrderedReportsTest.tsx
+++ b/tests/unit/useSidebarOrderedReportsTest.tsx
@@ -95,7 +95,7 @@ describe('useSidebarOrderedReports', () => {
         );
     }
 
-    it('surfaces orderedReportIDs and orderedReports from the derived Onyx value', async () => {
+    it('surfaces orderedReportIDs from the derived Onyx value', async () => {
         currentReportIDForTest = '1';
         const report1 = makeReport('1');
         const report2 = makeReport('2');
@@ -115,7 +115,6 @@ describe('useSidebarOrderedReports', () => {
         await waitForBatchedUpdatesWithAct();
 
         expect(result.current.orderedReportIDs).toEqual(['2', '1']);
-        expect(result.current.orderedReports.map((r) => r.reportID)).toEqual(['2', '1']);
         expect(result.current.currentReportID).toBe('1');
     });
 

From ba920d05071c8a403169dee76fd02b45764423d8 Mon Sep 17 00:00:00 2001
From: Chuck Dries <chuck@expensify.com>
Date: Fri, 29 May 2026 14:57:31 -0700
Subject: [PATCH 4/5] Call initOnyxDerivedValues in sidebar perf test

---
 tests/perf-test/SidebarLinks.perf-test.tsx | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/tests/perf-test/SidebarLinks.perf-test.tsx b/tests/perf-test/SidebarLinks.perf-test.tsx
index 66f9493aa726..27ac27c5d14a 100644
--- a/tests/perf-test/SidebarLinks.perf-test.tsx
+++ b/tests/perf-test/SidebarLinks.perf-test.tsx
@@ -1,7 +1,9 @@
+import type * as reactNavigationNativeImport from '@react-navigation/native';
 import {fireEvent, screen, waitFor} from '@testing-library/react-native';
 import Onyx from 'react-native-onyx';
 import {measureRenders} from 'reassure';
 import {setHasRadio} from '@libs/NetworkState';
+import initOnyxDerivedValues from '@userActions/OnyxDerived';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import * as LHNTestUtils from '../utils/LHNTestUtils';
@@ -31,7 +33,14 @@ jest.mock('../../src/libs/Navigation/navigationRef', () => ({
     isReady: () => true,
 }));
 
-jest.mock('@react-navigation/native');
+jest.mock('@react-navigation/native', () => ({
+    ...jest.requireActual<typeof reactNavigationNativeImport>('@react-navigation/native'),
+    useNavigationState: () => undefined,
+    useIsFocused: () => true,
+    useRoute: () => ({name: 'Home'}),
+    useNavigation: () => undefined,
+    useFocusEffect: () => undefined,
+}));
 
 const getMockedReportsMap = (length = 100) => {
     const mockReports = Object.fromEntries(
@@ -56,6 +65,8 @@ describe('SidebarLinks', () => {
             keys: ONYXKEYS,
             evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
         });
+
+        initOnyxDerivedValues();
     });
 
     beforeEach(() => {

From 30065ca7ee0567714c768761145373881eaf837a Mon Sep 17 00:00:00 2001
From: Chuck Dries <chuck@expensify.com>
Date: Fri, 29 May 2026 17:18:35 -0700
Subject: [PATCH 5/5] Add CONST.COLLATOR_OPTIONS, cache collator in
 sidebarOrderedReports

---
 src/CONST/index.ts                               |  3 +++
 .../OnyxDerived/configs/sidebarOrderedReports.ts | 16 +++++++++++++---
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 202d637610f3..1e78f45be34c 100644
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -3723,6 +3723,9 @@ const CONST = {
 
     LOCALES,
 
+    // Shared Intl.Collator options for locale-aware sorting of display names.
+    COLLATOR_OPTIONS: {usage: 'sort', sensitivity: 'variant', numeric: true, caseFirst: 'upper'} as Intl.CollatorOptions,
+
     PRONOUNS_LIST: [
         'coCos',
         'eEyEmEir',
diff --git a/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts b/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
index b2102e2faa81..c18ca38498da 100644
--- a/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
+++ b/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
@@ -12,7 +12,18 @@ import type {SidebarOrderedReportsDerivedValue, SidebarReportForLHN} from '@src/
 
 const EMPTY_VALUE: SidebarOrderedReportsDerivedValue = {reportsToDisplay: {}, orderedReportIDs: []};
 
-const COLLATOR_OPTIONS: Intl.CollatorOptions = {usage: 'sort', sensitivity: 'variant', numeric: true, caseFirst: 'upper'};
+// Cache the collator across computes so we only rebuild it when the locale actually changes.
+let cachedCollator: Intl.Collator | undefined;
+let cachedCollatorLocale: string | undefined;
+
+function getLocaleCompare(locale: string): (a: string, b: string) => number {
+    if (!cachedCollator || cachedCollatorLocale !== locale) {
+        cachedCollator = new Intl.Collator(locale, CONST.COLLATOR_OPTIONS);
+        cachedCollatorLocale = locale;
+    }
+    const collator = cachedCollator;
+    return (a, b) => collator.compare(a, b);
+}
 
 const COLLECTION_DEP_KEYS = [
     ONYXKEYS.COLLECTION.REPORT,
@@ -179,8 +190,7 @@ export default createOnyxDerivedValueConfig({
             });
         }
 
-        const collator = new Intl.Collator(locale ?? IntlStore.getCurrentLocale() ?? undefined, COLLATOR_OPTIONS);
-        const localeCompare = (a: string, b: string) => collator.compare(a, b);
+        const localeCompare = getLocaleCompare(locale ?? IntlStore.getCurrentLocale() ?? CONST.LOCALES.DEFAULT);
         const hasDraftByReportID = buildHasDraftMap(reportsDrafts);
 
         const nextOrderedReportIDs = SidebarUtils.sortReportsToDisplayInLHN(