diff --git a/src/components/LazyModalSlot.tsx b/src/components/LazyModalSlot.tsx
index 7c60f6b8abc9..e9f33387ec95 100644
--- a/src/components/LazyModalSlot.tsx
+++ b/src/components/LazyModalSlot.tsx
@@ -1,10 +1,9 @@
 import * as Sentry from '@sentry/react-native';
 import React, {Suspense} from 'react';
 import {ErrorBoundary as ReactErrorBoundary} from 'react-error-boundary';
+import isChunkLoadError from '@libs/isChunkLoadError';
 import Log from '@libs/Log';
 
-const isChunkLoadError = (error: Error) => error.name === 'ChunkLoadError' || /Loading chunk \S+ failed/i.test(error.message);
-
 const logModalError = (error: Error, info: {componentStack?: string | null}) => {
     const componentStack = info.componentStack ?? undefined;
 
diff --git a/src/hooks/usePageRefresh/index.ts b/src/hooks/usePageRefresh/index.ts
index e8f4f9bc6877..76ed85576cb8 100644
--- a/src/hooks/usePageRefresh/index.ts
+++ b/src/hooks/usePageRefresh/index.ts
@@ -1,5 +1,6 @@
 import {differenceInMilliseconds} from 'date-fns/differenceInMilliseconds';
 import {useErrorBoundary} from 'react-error-boundary';
+import clearWorkboxRecoveryCaches from '@libs/clearWorkboxRecoveryCaches';
 import CONST from '@src/CONST';
 import type UsePageRefresh from './type';
 
@@ -16,8 +17,16 @@ const usePageRefresh: UsePageRefresh = () => {
             return;
         }
 
-        window.location.reload();
         sessionStorage.removeItem(CONST.SESSION_STORAGE_KEYS.LAST_REFRESH_TIMESTAMP);
+        if (isChunkLoadError && navigator.onLine) {
+            // The error page is shown after lazyRetry has already done a plain reload and it did
+            // not fix the problem. When online, clear the service worker cache so the next load
+            // fetches a fresh app shell from the CDN. When offline we must not clear it: the
+            // cached shell is the only thing keeping the PWA usable until connectivity returns.
+            clearWorkboxRecoveryCaches().then(() => window.location.reload());
+        } else {
+            window.location.reload();
+        }
     };
 };
 
diff --git a/src/libs/Navigation/AppNavigator/AppNavigator.tsx b/src/libs/Navigation/AppNavigator/AppNavigator.tsx
index 063fdd9e0a7c..a7d07c0ff1e3 100644
--- a/src/libs/Navigation/AppNavigator/AppNavigator.tsx
+++ b/src/libs/Navigation/AppNavigator/AppNavigator.tsx
@@ -1,8 +1,8 @@
 import React, {lazy, memo, Suspense} from 'react';
 import lazyRetry from '@src/utils/lazyRetry';
 
-const AuthScreens = lazy(() => lazyRetry(() => import(/* webpackChunkName: "authScreens.prefetch" */ './AuthScreens')));
-const PublicScreens = lazy(() => lazyRetry(() => import(/* webpackMode: "eager" */ './PublicScreens')));
+const AuthScreens = lazy(() => lazyRetry(() => import(/* webpackChunkName: "authScreens.prefetch" */ './AuthScreens'), 'authScreens'));
+const PublicScreens = lazy(() => lazyRetry(() => import(/* webpackMode: "eager" */ './PublicScreens'), 'publicScreens'));
 
 type AppNavigatorProps = {
     /** If we have an authToken this is true */
diff --git a/src/libs/Navigation/AppNavigator/index.tsx b/src/libs/Navigation/AppNavigator/index.tsx
index 834ba7f281fa..d1d570a78c35 100644
--- a/src/libs/Navigation/AppNavigator/index.tsx
+++ b/src/libs/Navigation/AppNavigator/index.tsx
@@ -2,7 +2,7 @@ import React, {lazy, Suspense} from 'react';
 import type {ComponentProps} from 'react';
 import lazyRetry from '@src/utils/lazyRetry';
 
-const AppNavigator = lazy(() => lazyRetry(() => import(/* webpackChunkName: "appNavigator.prefetch" */ './AppNavigator')));
+const AppNavigator = lazy(() => lazyRetry(() => import(/* webpackChunkName: "appNavigator.prefetch" */ './AppNavigator'), 'appNavigator'));
 
 function AppNavigatorLoader({authenticated}: ComponentProps<typeof AppNavigator>) {
     return (
diff --git a/src/libs/clearWorkboxRecoveryCaches/index.ts b/src/libs/clearWorkboxRecoveryCaches/index.ts
index 003c23cad188..2bc9c5bad44d 100644
--- a/src/libs/clearWorkboxRecoveryCaches/index.ts
+++ b/src/libs/clearWorkboxRecoveryCaches/index.ts
@@ -4,8 +4,8 @@ import Log from '@libs/Log';
 /**
  * Clears all Cache Storage entries for this origin and unregisters every
  * service worker. Used when the user runs Troubleshoot > Clear cache and
- * restart so Workbox precache/runtime caches do not survive that recovery
- * path (stale app shell / chunks would otherwise keep serving from SW).
+ * restart, and during ChunkLoadError recovery, so stale cached assets do
+ * not survive those recovery paths and keep re-serving broken chunks.
  */
 async function clearWorkboxRecoveryCaches(): Promise<void> {
     // Normally platform-specific behaviour is achieved with .native.ts / .ts file pairs.
diff --git a/src/libs/isChunkLoadError.ts b/src/libs/isChunkLoadError.ts
new file mode 100644
index 000000000000..174a291e3946
--- /dev/null
+++ b/src/libs/isChunkLoadError.ts
@@ -0,0 +1,14 @@
+import CONST from '@src/CONST';
+
+/**
+ * Returns true if the given error is a webpack ChunkLoadError — the error thrown when a
+ * dynamically-imported script cannot be fetched (e.g. after a deploy removes old chunk hashes).
+ */
+function isChunkLoadError(error: unknown): boolean {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.name === CONST.CHUNK_LOAD_ERROR || /Loading chunk \S+ failed/i.test(error.message);
+}
+
+export default isChunkLoadError;
diff --git a/src/pages/ErrorPage/GenericErrorPage.tsx b/src/pages/ErrorPage/GenericErrorPage.tsx
index d11397d13b52..5a15d766a833 100644
--- a/src/pages/ErrorPage/GenericErrorPage.tsx
+++ b/src/pages/ErrorPage/GenericErrorPage.tsx
@@ -13,6 +13,7 @@ import usePageRefresh from '@hooks/usePageRefresh';
 import useStyleUtils from '@hooks/useStyleUtils';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
+import isChunkLoadError from '@libs/isChunkLoadError';
 import variables from '@styles/variables';
 import {signOutAndRedirectToSignIn} from '@userActions/Session';
 import CONST from '@src/CONST';
@@ -24,7 +25,7 @@ function GenericErrorPage({error}: {error?: Error}) {
     const StyleUtils = useStyleUtils();
     const isAuthenticated = useIsAuthenticated();
     const {translate} = useLocalize();
-    const isChunkLoadError = error?.name === CONST.CHUNK_LOAD_ERROR || /Loading chunk [\d]+ failed/.test(error?.message ?? '');
+    const chunkLoadError = isChunkLoadError(error);
     const refreshPage = usePageRefresh();
     const icons = useMemoizedLazyExpensifyIcons(['ExpensifyWordmark', 'Bug']);
 
@@ -63,7 +64,7 @@ function GenericErrorPage({error}: {error?: Error}) {
                                         success
                                         text={translate('genericErrorPage.refresh')}
                                         style={styles.mr3}
-                                        onPress={() => refreshPage(isChunkLoadError)}
+                                        onPress={() => refreshPage(chunkLoadError)}
                                     />
                                     {isAuthenticated && (
                                         <Button
diff --git a/src/utils/lazyRetry.ts b/src/utils/lazyRetry.ts
index 35c6b444e612..0113f17ff35d 100644
--- a/src/utils/lazyRetry.ts
+++ b/src/utils/lazyRetry.ts
@@ -1,39 +1,83 @@
 import type {ComponentType} from 'react';
+import clearWorkboxRecoveryCaches from '@libs/clearWorkboxRecoveryCaches';
+import isChunkLoadError from '@libs/isChunkLoadError';
 import CONST from '@src/CONST';
 
 type Import<T> = Promise<{default: T}>;
 type ComponentImport<T> = () => Import<T>;
 
+// Three-state retry machine stored in sessionStorage:
+//   'false'        — no reload attempted yet (default)
+//   'true'         — one plain reload has been attempted
+//   'cache-cleared'— SW caches were cleared and a second reload was attempted
+const RETRY_STATE = {
+    INITIAL: 'false',
+    RELOADED: 'true',
+    CACHE_CLEARED: 'cache-cleared',
+} as const;
+
 /**
- * Attempts to lazily import a React component with a retry mechanism on failure.
- * If the initial import fails the function will refresh the page once and retry the import.
- * If the import fails again after the refresh, the error is propagated.
+ * The retry state must be scoped per import. Multiple chunks are lazy-loaded in sequence
+ * (e.g. AppNavigator, then AuthScreens), so a global flag could be reset to INITIAL by one
+ * chunk's success while another chunk is still failing, restarting that chunk's retry cycle
+ * forever instead of advancing to the cache-clearing branch.
+ */
+function getRetryStateKey(retryKey: string): string {
+    return `${CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED}:${retryKey}`;
+}
+
+/**
+ * Attempts to lazily import a React component with a graduated retry strategy.
+ *
+ * - First failure: plain reload — handles transient network blips without touching caches.
+ * - Second failure that is a ChunkLoadError AND the device is online: clear the service worker
+ *   cache and reload — handles the post-deploy stale-shell scenario where the SW is serving an
+ *   old index.html that references chunk hashes no longer on the CDN.
+ *   The online guard is critical: a chunk fetch that fails while offline also produces a
+ *   ChunkLoadError, and clearing the service worker cache in that case would destroy the cached
+ *   app shell that is the only thing keeping the PWA usable until connectivity returns.
+ * - Any subsequent failure, a second failure that is not a ChunkLoadError, or a second failure
+ *   while offline: propagate to the React error boundary so the user sees the error page.
  *
  * @param componentImport - A function that returns a promise resolving to a lazily imported React component.
- * @returns A promise that resolves to the imported component or rejects with an error after a retry attempt.
+ * @param retryKey - A stable identifier unique to this import, used to scope the retry state so
+ *                    sibling imports do not interfere with each other's recovery cycle.
+ * @returns A promise that resolves to the imported component or rejects after all recovery attempts.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const lazyRetry = function <T extends ComponentType<any>>(componentImport: ComponentImport<T>): Import<T> {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ComponentType requires any for the generic constraint to accept all component shapes
+const lazyRetry = function <T extends ComponentType<any>>(componentImport: ComponentImport<T>, retryKey: string): Import<T> {
     return new Promise((resolve, reject) => {
-        // Retrieve the retry status from sessionStorage, defaulting to 'false' if not set
-        const hasRefreshed = JSON.parse(sessionStorage.getItem(CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED) ?? 'false') as boolean;
+        const stateKey = getRetryStateKey(retryKey);
+        const retryState = sessionStorage.getItem(stateKey) ?? RETRY_STATE.INITIAL;
 
         componentImport()
             .then((component) => {
-                // Reset the retry status to 'false' on successful import
-                sessionStorage.setItem(CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED, 'false'); // success so reset the refresh
+                sessionStorage.setItem(stateKey, RETRY_STATE.INITIAL);
                 resolve(component);
             })
-            .catch((component: ComponentImport<T>) => {
-                if (!hasRefreshed) {
-                    console.error('Failed to lazily import a React component, refreshing the page in order to retry the operation.', component);
-                    // Set the retry status to 'true' and refresh the page
-                    sessionStorage.setItem(CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED, 'true');
-                    window.location.reload(); // Refresh the page to retry the import
+            .catch((error: unknown) => {
+                if (retryState === RETRY_STATE.INITIAL) {
+                    // First failure: plain reload to handle transient errors cheaply.
+                    console.error('Failed to lazily import a React component, refreshing the page in order to retry the operation.', error);
+                    sessionStorage.setItem(stateKey, RETRY_STATE.RELOADED);
+                    window.location.reload();
+                } else if (retryState === RETRY_STATE.RELOADED && isChunkLoadError(error) && navigator.onLine) {
+                    // Second failure, it is a ChunkLoadError, and the device is online: the plain
+                    // reload did not fix it — likely the SW is serving a stale shell after a deploy.
+                    // Clear the service worker cache and reload. Keep the flag at CACHE_CLEARED so
+                    // a third failure surfaces the error boundary instead of starting over.
+                    console.error('Failed to lazily import a React component after reload, clearing SW caches and reloading.', error);
+                    sessionStorage.setItem(stateKey, RETRY_STATE.CACHE_CLEARED);
+                    clearWorkboxRecoveryCaches().then(() => window.location.reload());
                 } else {
-                    console.error('Failed to lazily import a React component after the retry operation!', component);
-                    // If the import fails again reject with the error to trigger default error handling
-                    reject(component);
+                    // All recovery options exhausted, the device is offline, or the second failure is
+                    // not a ChunkLoadError: propagate to the error boundary. The flag is left at its
+                    // current advanced state (not reset), so a later failure of this same import does
+                    // not restart the full reload cycle — it either fails fast (already cache-cleared)
+                    // or retries the cache clear once the device is back online. A successful import
+                    // resets the flag to INITIAL.
+                    console.error('Failed to lazily import a React component after all recovery attempts.', error);
+                    reject(error instanceof Error ? error : new Error(String(error)));
                 }
             });
     });
diff --git a/tests/unit/chunkLoadErrorRecoveryTest.ts b/tests/unit/chunkLoadErrorRecoveryTest.ts
new file mode 100644
index 000000000000..130f86ebbde1
--- /dev/null
+++ b/tests/unit/chunkLoadErrorRecoveryTest.ts
@@ -0,0 +1,213 @@
+/**
+ * Regression tests for the Safari PWA ChunkLoadError crash loop.
+ *
+ * usePageRefresh: clears SW caches then reloads on any chunk-load error (the Refresh
+ * button is only shown after the automatic lazyRetry cycle has already run, so we are
+ * already on the second failure by the time the user taps it).
+ *
+ * lazyRetry uses a three-state strategy:
+ *   - First failure                        → plain reload.
+ *   - Second failure, ChunkLoadError, online → clear SW cache then reload.
+ *   - Second failure, ChunkLoadError, offline→ reject to error boundary (keep cached offline assets).
+ *   - Second failure, non-ChunkLoadError     → reject to error boundary.
+ *   - Third failure                          → reject to error boundary (loop prevention).
+ */
+import {renderHook} from '@testing-library/react-native';
+import type {ComponentType} from 'react';
+import usePageRefresh from '@hooks/usePageRefresh';
+import CONST from '@src/CONST';
+import lazyRetry from '@src/utils/lazyRetry';
+
+type ComponentImport<T> = () => Promise<{default: T}>;
+
+const mockClearWorkboxRecoveryCaches = jest.fn();
+jest.mock('@libs/clearWorkboxRecoveryCaches', () => ({
+    __esModule: true,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mock factory must return `any` to satisfy the dynamic module shape Jest expects
+    default: (...args: unknown[]): any => mockClearWorkboxRecoveryCaches(...args),
+}));
+
+// jest-expo resolves @hooks/usePageRefresh to the .native.ts variant (which does not use
+// clearWorkboxRecoveryCaches). Override the alias to load the web file so this test covers
+// the web-specific reload path that was changed. The web file's own imports (including
+// clearWorkboxRecoveryCaches) still go through the normal mock registry.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-return -- jest.requireActual returns an untyped module; the unsafe return is unavoidable here
+jest.mock('@hooks/usePageRefresh', () => jest.requireActual('../../src/hooks/usePageRefresh/index.ts'));
+
+jest.mock('react-error-boundary', () => ({
+    useErrorBoundary: () => ({resetBoundary: jest.fn()}),
+    ErrorBoundary: ({children}: {children: React.ReactNode}) => children,
+}));
+
+/**
+ * Flush enough microtask turns to let clearWorkboxRecoveryCaches().then(reload)
+ * run to completion. Two yields are sufficient: one for the rejection/resolution
+ * handler, one for the .then() chain off the resolved clearWorkboxRecoveryCaches promise.
+ */
+function flushMicrotasks(turns = 3): Promise<void> {
+    let chain = Promise.resolve();
+    for (let i = 0; i < turns; i++) {
+        chain = chain.then(() => Promise.resolve());
+    }
+    return chain;
+}
+
+describe('ChunkLoadError recovery', () => {
+    let reloadMock: jest.Mock;
+    // Records the order in which clear and reload are called within each test.
+    const callOrder: string[] = [];
+    // Preserve the original location so the override does not leak between test files.
+    const originalLocation = window.location;
+
+    beforeAll(() => {
+        reloadMock = jest.fn().mockImplementation(() => {
+            callOrder.push('reload');
+        });
+        Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: {reload: reloadMock},
+        });
+    });
+
+    afterAll(() => {
+        Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: originalLocation,
+        });
+    });
+
+    beforeEach(() => {
+        callOrder.length = 0;
+        mockClearWorkboxRecoveryCaches.mockImplementation(() => {
+            callOrder.push('clear');
+            return Promise.resolve();
+        });
+        reloadMock.mockClear();
+        mockClearWorkboxRecoveryCaches.mockClear();
+        sessionStorage.clear();
+    });
+
+    describe('usePageRefresh (web)', () => {
+        it('clears caches before reloading when isChunkLoadError is true', async () => {
+            const {result} = renderHook(() => usePageRefresh());
+
+            result.current(true);
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).toHaveBeenCalledTimes(1);
+            expect(reloadMock).toHaveBeenCalledTimes(1);
+            expect(callOrder).toEqual(['clear', 'reload']);
+        });
+
+        it('does not reload at all when isChunkLoadError is false and no prior refresh', async () => {
+            const {result} = renderHook(() => usePageRefresh());
+
+            result.current(false);
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(reloadMock).not.toHaveBeenCalled();
+        });
+
+        it('plain-reloads without clearing caches when the error is not a chunk error', async () => {
+            // Simulate a second Refresh tap within the timeout window for a non-chunk error.
+            sessionStorage.setItem(CONST.SESSION_STORAGE_KEYS.LAST_REFRESH_TIMESTAMP, (Date.now() - 1000).toString());
+            const {result} = renderHook(() => usePageRefresh());
+
+            result.current(false);
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(reloadMock).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('lazyRetry', () => {
+        const chunkError = Object.assign(new Error('Loading chunk 3851 failed.'), {name: 'ChunkLoadError'});
+        // Retry state is scoped per import, so the test reads/writes the chunk-specific key.
+        const RETRY_KEY = 'test';
+        const stateKey = `${CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED}:${RETRY_KEY}`;
+
+        it('plain-reloads on the first failure without clearing caches', async () => {
+            sessionStorage.removeItem(stateKey);
+            const failingImport = jest.fn().mockRejectedValue(chunkError) as unknown as ComponentImport<ComponentType>;
+
+            lazyRetry(failingImport, RETRY_KEY);
+            await flushMicrotasks();
+
+            expect(reloadMock).toHaveBeenCalledTimes(1);
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(callOrder).toEqual(['reload']);
+        });
+
+        it('clears SW caches before reloading on the second ChunkLoadError failure when online', async () => {
+            sessionStorage.setItem(stateKey, 'true');
+            jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(true);
+            const failingImport = jest.fn().mockRejectedValue(chunkError) as unknown as ComponentImport<ComponentType>;
+
+            lazyRetry(failingImport, RETRY_KEY);
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).toHaveBeenCalledTimes(1);
+            expect(reloadMock).toHaveBeenCalledTimes(1);
+            expect(callOrder).toEqual(['clear', 'reload']);
+        });
+
+        it('rejects to the error boundary on second ChunkLoadError failure when offline to preserve the offline cache', async () => {
+            sessionStorage.setItem(stateKey, 'true');
+            jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(false);
+            const failingImport = jest.fn().mockRejectedValue(chunkError) as unknown as ComponentImport<ComponentType>;
+
+            await expect(lazyRetry(failingImport, RETRY_KEY)).rejects.toBeDefined();
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(reloadMock).not.toHaveBeenCalled();
+        });
+
+        it('rejects to the error boundary on second failure when the error is not a ChunkLoadError', async () => {
+            sessionStorage.setItem(stateKey, 'true');
+            const networkError = new Error('Failed to fetch');
+            const failingImport = jest.fn().mockRejectedValue(networkError) as unknown as ComponentImport<ComponentType>;
+
+            await expect(lazyRetry(failingImport, RETRY_KEY)).rejects.toThrow('Failed to fetch');
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(reloadMock).not.toHaveBeenCalled();
+        });
+
+        it('rejects to the error boundary on the third failure to prevent an infinite reload loop', async () => {
+            sessionStorage.setItem(stateKey, 'cache-cleared');
+            const failingImport = jest.fn().mockRejectedValue(chunkError) as unknown as ComponentImport<ComponentType>;
+
+            await expect(lazyRetry(failingImport, RETRY_KEY)).rejects.toBeDefined();
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(reloadMock).not.toHaveBeenCalled();
+        });
+
+        it('keeps each import retry state isolated so a sibling success does not reset it', async () => {
+            // 'other' chunk already reloaded once; a successful 'test' chunk import must not reset it.
+            sessionStorage.setItem(`${CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED}:other`, 'true');
+            const successfulImport = jest.fn().mockResolvedValue({default: () => null}) as unknown as ComponentImport<ComponentType>;
+
+            await lazyRetry(successfulImport, RETRY_KEY);
+            await flushMicrotasks();
+
+            expect(sessionStorage.getItem(`${CONST.SESSION_STORAGE_KEYS.RETRY_LAZY_REFRESHED}:other`)).toBe('true');
+        });
+
+        it('does not reload on successful import', async () => {
+            sessionStorage.removeItem(stateKey);
+            const successfulImport = jest.fn().mockResolvedValue({default: () => null}) as unknown as ComponentImport<ComponentType>;
+
+            await lazyRetry(successfulImport, RETRY_KEY);
+            await flushMicrotasks();
+
+            expect(mockClearWorkboxRecoveryCaches).not.toHaveBeenCalled();
+            expect(reloadMock).not.toHaveBeenCalled();
+        });
+    });
+});