vike 0.4.152 → 0.4.153-commit-01ab602

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -1,14 +1,14 @@
 export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
-import { assert, getCurrentUrl, isEquivalentError, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
-import { getPageContextFromHooks_errorPage, getPageContextFromHooks_firstRender, getPageContextFromHooks_uponNavigation, isAlreadyServerSideRouted } from './getPageContextFromHooks.js';
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
+import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized, isServerSideRouted } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook, getHook } from '../../shared/hooks/getHook.js';
-import { isErrorFetchingStaticAssets } from '../shared/loadPageFilesClientSide.js';
+import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { pushHistory } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
@@ -16,62 +16,56 @@ import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
+import { getErrorPageId } from '../../shared/error-page.js';
+import { isRenderFailure } from '../../shared/misc/isRenderFailure.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', { renderCounter: 0 });
 async function renderPageClientSide(renderArgs) {
     const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
-    const { abortRender, setHydrationCanBeAborted, isFirstRender } = getAbortRender();
-    assert(isClientSideNavigation === !isFirstRender);
+    // isHydrationRender <=> the first render attempt
+    const { isRenderOutdated, setHydrationCanBeAborted, isHydrationRender } = getIsRenderOutdated();
+    assert(isClientSideNavigation === !isHydrationRender);
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
     if (globalObject.clientRoutingIsDisabled) {
         serverSideRouteTo(urlOriginal);
         return;
     }
-    const pageContext = await createPageContext(urlOriginal);
-    if (abortRender())
-        return;
-    objectAssign(pageContext, {
-        isBackwardNavigation,
-        isClientSideNavigation
-    });
-    {
-        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
-        objectAssign(pageContext, pageContextFromAllRewrites);
-    }
-    let renderState = {};
-    const onError = (err) => {
-        assert(err);
-        assert(!('err' in renderState));
-        assert(!('errorWhileRendering' in pageContext));
-        renderState.err = err;
-        pageContext.errorWhileRendering = err;
-    };
-    if (!isFirstRender) {
+    await renderPageNominal();
+    return;
+    async function renderPageNominal() {
+        const pageContext = await getPageContextBegin();
+        if (isRenderOutdated())
+            return;
         // Route
-        try {
-            renderState = { pageContextFromRoute: await route(pageContext) };
-        }
-        catch (err) {
-            onError(err);
+        let pageContextRouted;
+        if (isHydrationRender) {
+            const pageContextSerialized = getPageContextFromHooks_serialized();
+            pageContextRouted = pageContextSerialized;
         }
-        if (abortRender())
-            return;
-        // Check whether rendering should be skipped
-        if (renderState.pageContextFromRoute) {
-            const { pageContextFromRoute } = renderState;
-            objectAssign(pageContext, pageContextFromRoute);
+        else {
+            let pageContextFromRoute;
+            try {
+                pageContextFromRoute = await route(pageContext);
+            }
+            catch (err) {
+                await renderErrorPage({ err });
+                return;
+            }
+            if (isRenderOutdated())
+                return;
             let isClientRoutable;
             if (!pageContextFromRoute._pageId) {
                 isClientRoutable = false;
             }
             else {
                 isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
-                if (abortRender())
+                if (isRenderOutdated())
                     return;
             }
             if (!isClientRoutable) {
                 serverSideRouteTo(urlOriginal);
                 return;
             }
+            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
             const isSamePage = pageContextFromRoute._pageId &&
                 globalObject.previousPageContext?._pageId &&
                 pageContextFromRoute._pageId === globalObject.previousPageContext._pageId;
@@ -79,201 +73,303 @@ async function renderPageClientSide(renderArgs) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
             }
+            pageContextRouted = pageContextFromRoute;
         }
-    }
-    // onPageTransitionStart()
-    const callTransitionHooks = !isFirstRender;
-    if (callTransitionHooks) {
-        if (!globalObject.isTransitioning) {
-            if (globalObject.onPageTransitionStart) {
-                const hook = globalObject.onPageTransitionStart;
-                const { hookFn } = hook;
-                await executeHook(() => hookFn(pageContext), hook);
-            }
-            globalObject.isTransitioning = true;
-            if (abortRender())
-                return;
-        }
-    }
-    if (isFirstRender) {
-        assert(!renderState.pageContextFromRoute);
-        assert(!renderState.err);
+        assert(!('urlOriginal' in pageContextRouted));
+        objectAssign(pageContext, pageContextRouted);
         try {
-            renderState.pageContextFromHooks = await getPageContextFromHooks_firstRender(pageContext);
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
-            onError(err);
+            if (handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender)) {
+                return;
+            }
+            else {
+                throw err;
+            }
         }
-        if (abortRender())
+        if (isRenderOutdated())
             return;
-    }
-    else {
-        if (!renderState.err) {
-            const { pageContextFromRoute } = renderState;
-            assert(pageContextFromRoute);
-            assert(pageContextFromRoute._pageId);
-            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
-            objectAssign(pageContext, pageContextFromRoute);
+        // Set global hydrationCanBeAborted
+        if (pageContext.exports.hydrationCanBeAborted) {
+            setHydrationCanBeAborted();
+        }
+        else {
+            assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
+        }
+        // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
+        if (isRenderOutdated())
+            return;
+        // onPageTransitionStart()
+        if (!isHydrationRender) {
+            assertHook(pageContext, 'onPageTransitionStart');
+            if (!globalObject.isTransitioning) {
+                globalObject.isTransitioning = true;
+                const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
+                if (onPageTransitionStartHook) {
+                    const hook = onPageTransitionStartHook;
+                    const { hookFn } = hook;
+                    try {
+                        await executeHook(() => hookFn(pageContext), hook);
+                    }
+                    catch (err) {
+                        await renderErrorPage({ err });
+                        return;
+                    }
+                    if (isRenderOutdated())
+                        return;
+                }
+            }
+        }
+        // Get pageContext from hooks (fetched from server, and/or directly called on the client-side)
+        if (isHydrationRender) {
+            assert(hasProp(pageContext, '_hasPageContextFromServer', 'true'));
+            let pageContextFromHooks;
             try {
-                renderState.pageContextFromHooks = await getPageContextFromHooks_uponNavigation(pageContext);
+                pageContextFromHooks = await getPageContextFromHooks_isHydration(pageContext);
             }
             catch (err) {
-                onError(err);
+                await renderErrorPage({ err });
+                return;
             }
-            if (abortRender())
+            if (isRenderOutdated())
                 return;
-        }
-    }
-    if ('err' in renderState) {
-        const { err } = renderState;
-        if (!isAbortError(err)) {
-            // We don't swallow 404 errors:
-            //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
-            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
-            console.error(err);
+            assert(!('urlOriginal' in pageContextFromHooks));
+            objectAssign(pageContext, pageContextFromHooks);
+            // Render page view
+            await renderPageView(pageContext);
         }
         else {
-            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender(), data() and guard()
-            // We handle the abort error down below.
+            let pageContextFromHooks;
+            try {
+                pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, false);
+            }
+            catch (err) {
+                await renderErrorPage({ err });
+                return;
+            }
+            if (isRenderOutdated())
+                return;
+            if (isRenderFailure in pageContextFromHooks) {
+                await renderErrorPage({ pageContextError: pageContextFromHooks });
+                return;
+            }
+            assert(!('urlOriginal' in pageContextFromHooks));
+            objectAssign(pageContext, pageContextFromHooks);
+            // Render page view
+            await renderPageView(pageContext);
         }
-        if (shouldSwallowAndInterrupt(err, pageContext, isFirstRender))
+    }
+    async function getPageContextBegin() {
+        const pageContext = await createPageContext(urlOriginal);
+        objectAssign(pageContext, {
+            isBackwardNavigation,
+            isClientSideNavigation
+        });
+        {
+            const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+            assert(!('urlOriginal' in pageContextFromAllRewrites));
+            objectAssign(pageContext, pageContextFromAllRewrites);
+        }
+        return pageContext;
+    }
+    async function renderErrorPage(args) {
+        const pageContext = await getPageContextBegin();
+        if (isRenderOutdated())
             return;
-        if (isAbortError(err)) {
-            const errAbort = err;
-            logAbortErrorHandled(err, pageContext._isProduction, pageContext);
-            const pageContextAbort = errAbort._pageContextAbort;
-            // throw render('/some-url')
-            if (pageContextAbort._urlRewrite) {
-                await renderPageClientSide({
-                    ...renderArgs,
-                    scrollTarget: 'scroll-to-top-or-hash',
-                    pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort]
-                });
+        if (args.pageContextError) {
+            objectAssign(pageContext, args.pageContextError);
+        }
+        if ('err' in args) {
+            const { err } = args;
+            assert(err);
+            assert(!('errorWhileRendering' in pageContext));
+            pageContext.errorWhileRendering = err;
+            if (shouldSwallowAndInterrupt(err))
                 return;
+            if (!isAbortError(err)) {
+                // We don't swallow 404 errors:
+                //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+                //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+                console.error(err);
             }
-            // throw redirect('/some-url')
-            if (pageContextAbort._urlRedirect) {
-                const urlRedirect = pageContextAbort._urlRedirect.url;
-                if (urlRedirect.startsWith('http')) {
-                    // External redirection
-                    window.location.href = urlRedirect;
-                    return;
-                }
-                else {
+            else {
+                // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
+                // We handle the abort error down below.
+            }
+            if (isAbortError(err)) {
+                const errAbort = err;
+                logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
+                const pageContextAbort = errAbort._pageContextAbort;
+                // throw render('/some-url')
+                if (pageContextAbort._urlRewrite) {
                     await renderPageClientSide({
                         ...renderArgs,
                         scrollTarget: 'scroll-to-top-or-hash',
-                        urlOriginal: urlRedirect,
-                        overwriteLastHistoryEntry: false,
-                        isBackwardNavigation: false,
-                        redirectCount: redirectCount + 1
+                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort]
                     });
+                    return;
+                }
+                // throw redirect('/some-url')
+                if (pageContextAbort._urlRedirect) {
+                    const urlRedirect = pageContextAbort._urlRedirect.url;
+                    if (urlRedirect.startsWith('http')) {
+                        // External redirection
+                        window.location.href = urlRedirect;
+                        return;
+                    }
+                    else {
+                        await renderPageClientSide({
+                            ...renderArgs,
+                            scrollTarget: 'scroll-to-top-or-hash',
+                            urlOriginal: urlRedirect,
+                            overwriteLastHistoryEntry: false,
+                            isBackwardNavigation: false,
+                            redirectCount: redirectCount + 1
+                        });
+                    }
+                    return;
+                }
+                // throw render(statusCode)
+                assert(pageContextAbort.abortStatusCode);
+                assert(!('urlOriginal' in pageContextAbort));
+                objectAssign(pageContext, pageContextAbort);
+                if (pageContextAbort.abortStatusCode === 404) {
+                    objectAssign(pageContext, { is404: true });
                 }
-                return;
             }
-            // throw render(statusCode)
-            assert(pageContextAbort.abortStatusCode);
-            objectAssign(pageContext, pageContextAbort);
-            if (pageContextAbort.abortStatusCode === 404) {
-                objectAssign(pageContext, { is404: true });
+            else {
+                objectAssign(pageContext, { is404: false });
             }
         }
-        else {
-            objectAssign(pageContext, { is404: false });
-        }
+        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+        if (!errorPageId)
+            throw new Error('No error page defined.');
+        objectAssign(pageContext, {
+            _pageId: errorPageId
+        });
         try {
-            renderState.pageContextFromHooks = await getPageContextFromHooks_errorPage(pageContext);
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
-        catch (err2) {
-            // - When user hasn't defined a `_error.page.js` file
-            // - Some unpexected vike internal error
-            if (shouldSwallowAndInterrupt(err2, pageContext, isFirstRender))
+        catch (err) {
+            if (handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender)) {
                 return;
-            if (!isFirstRender) {
-                setTimeout(() => {
-                    // We let the server show the 404 page
-                    window.location.pathname = urlOriginal;
-                }, 0);
-            }
-            if (!isEquivalentError(err, err2)) {
-                throw err2;
             }
             else {
-                // Abort
+                throw err;
+            }
+        }
+        if (isRenderOutdated())
+            return;
+        let pageContextFromHooks;
+        try {
+            pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, true);
+        }
+        catch (errErrorPage) {
+            // - When user hasn't defined a `_error.page.js` file
+            // - Some Vike unpexected internal error
+            if (shouldSwallowAndInterrupt(errErrorPage))
                 return;
+            if (!isSameErrorMessage(args.err, errErrorPage)) {
+                /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
+                   - We risk running into an infinite loop of reloads which would overload the server.
+                   - An infinite reloading page is a even worse UX than a blank page.
+                serverSideRouteTo(urlOriginal)
+                */
+                console.error(errErrorPage);
             }
+            return;
         }
-        if (abortRender())
+        if (isRenderOutdated())
             return;
+        assert(pageContextFromHooks);
+        assert(!('urlOriginal' in pageContextFromHooks));
+        objectAssign(pageContext, pageContextFromHooks);
+        await renderPageView(pageContext, true);
     }
-    const { pageContextFromHooks } = renderState;
-    assert(pageContextFromHooks);
-    objectAssign(pageContext, pageContextFromHooks);
-    // Set global onPageTransitionStart()
-    assertHook(pageContext, 'onPageTransitionStart');
-    const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
-    globalObject.onPageTransitionStart = onPageTransitionStartHook;
-    // Set global hydrationCanBeAborted
-    if (pageContext.exports.hydrationCanBeAborted) {
-        setHydrationCanBeAborted();
-    }
-    else {
-        assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
-    }
-    // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
-    if (abortRender())
-        return;
-    // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
-    if (globalObject.renderPromise) {
-        // Make sure that the previous render has finished
+    async function renderPageView(pageContext, isErrorPage) {
+        // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
+        if (globalObject.renderPromise) {
+            // Make sure that the previous render has finished
+            await globalObject.renderPromise;
+            assert(globalObject.renderPromise === undefined);
+            if (isRenderOutdated())
+                return;
+        }
+        changeUrl(urlOriginal, overwriteLastHistoryEntry);
+        globalObject.previousPageContext = pageContext;
+        assert(globalObject.renderPromise === undefined);
+        globalObject.renderPromise = (async () => {
+            try {
+                await executeOnRenderClientHook(pageContext, true);
+            }
+            catch (err) {
+                if (!isErrorPage) {
+                    renderErrorPage({ err });
+                }
+                else {
+                    throw err;
+                }
+            }
+            addLinkPrefetchHandlers(pageContext);
+            globalObject.renderPromise = undefined;
+        })();
         await globalObject.renderPromise;
         assert(globalObject.renderPromise === undefined);
-        if (abortRender())
-            return;
-    }
-    changeUrl(urlOriginal, overwriteLastHistoryEntry);
-    globalObject.previousPageContext = pageContext;
-    assert(globalObject.renderPromise === undefined);
-    globalObject.renderPromise = (async () => {
-        await executeOnRenderClientHook(pageContext, true);
-        addLinkPrefetchHandlers(pageContext);
-        globalObject.renderPromise = undefined;
-    })();
-    await globalObject.renderPromise;
-    assert(globalObject.renderPromise === undefined);
-    /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
-    if (abortRender(true)) return
-    */
-    // onHydrationEnd()
-    if (isFirstRender) {
-        assertHook(pageContext, 'onHydrationEnd');
-        const hook = getHook(pageContext, 'onHydrationEnd');
-        if (hook) {
-            const { hookFn } = hook;
-            await executeHook(() => hookFn(pageContext), hook);
-            if (abortRender(true))
-                return;
+        /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
+        if (isRenderOutdated(true)) return
+        */
+        // onHydrationEnd()
+        if (isHydrationRender) {
+            assertHook(pageContext, 'onHydrationEnd');
+            const hook = getHook(pageContext, 'onHydrationEnd');
+            if (hook) {
+                const { hookFn } = hook;
+                try {
+                    await executeHook(() => hookFn(pageContext), hook);
+                }
+                catch (err) {
+                    if (!isErrorPage) {
+                        renderErrorPage({ err });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                if (isRenderOutdated(true))
+                    return;
+            }
         }
-    }
-    // We abort only after onHydrationEnd() is called
-    if (abortRender(true))
-        return;
-    // onPageTransitionEnd()
-    if (callTransitionHooks) {
-        assertHook(pageContext, 'onPageTransitionEnd');
-        const hook = getHook(pageContext, 'onPageTransitionEnd');
-        if (hook) {
-            const { hookFn } = hook;
-            await executeHook(() => hookFn(pageContext), hook);
-            if (abortRender(true))
-                return;
+        // We abort *after* onHydrationEnd() is called
+        if (isRenderOutdated(true))
+            return;
+        // onPageTransitionEnd()
+        if (globalObject.isTransitioning) {
+            globalObject.isTransitioning = undefined;
+            assertHook(pageContext, 'onPageTransitionEnd');
+            const hook = getHook(pageContext, 'onPageTransitionEnd');
+            if (hook) {
+                const { hookFn } = hook;
+                try {
+                    await executeHook(() => hookFn(pageContext), hook);
+                }
+                catch (err) {
+                    if (!isErrorPage) {
+                        renderErrorPage({ err });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                if (isRenderOutdated(true))
+                    return;
+            }
         }
-        globalObject.isTransitioning = undefined;
+        // Page scrolling
+        setScrollPosition(scrollTarget);
+        browserNativeScrollRestoration_disable();
+        setInitialRenderIsDone();
     }
-    // Page scrolling
-    setScrollPosition(scrollTarget);
-    browserNativeScrollRestoration_disable();
-    setInitialRenderIsDone();
 }
 function changeUrl(url, overwriteLastHistoryEntry) {
     if (getCurrentUrl() === url)
@@ -282,18 +378,16 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistory(url, overwriteLastHistoryEntry);
     updateState();
 }
-function shouldSwallowAndInterrupt(err, pageContext, isFirstRender) {
-    if (isAlreadyServerSideRouted(err))
-        return true;
-    if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
+function shouldSwallowAndInterrupt(err) {
+    if (isServerSideRouted(err))
         return true;
     return false;
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
     if (!isErrorFetchingStaticAssets(err)) {
         return false;
     }
-    if (isFirstRender) {
+    if (isHydrationRender) {
         disableClientRouting(err, false);
         // This may happen if the frontend was newly deployed during hydration.
         // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
@@ -323,7 +417,7 @@ function disableClientRouting(err, log) {
         .filter(Boolean)
         .join(' '), { onlyOnce: true });
 }
-function getAbortRender() {
+function getIsRenderOutdated() {
     const renderNumber = ++globalObject.renderCounter;
     assert(renderNumber >= 1);
     let hydrationCanBeAborted = false;
@@ -331,11 +425,11 @@ function getAbortRender() {
         hydrationCanBeAborted = true;
     };
     /** Whether the rendering should be aborted because a new rendering has started. We should call this after each `await`. */
-    const abortRender = (isRenderCleanup) => {
+    const isRenderOutdated = (isRenderCleanup) => {
         // Never abort hydration if `hydrationCanBeAborted` isn't `true`
-        if (!isRenderCleanup) {
+        {
             const isHydration = renderNumber === 1;
-            if (isHydration && !hydrationCanBeAborted) {
+            if (isHydration && !hydrationCanBeAborted && !isRenderCleanup) {
                 return false;
             }
         }
@@ -343,9 +437,9 @@ function getAbortRender() {
         return renderNumber !== globalObject.renderCounter;
     };
     return {
-        abortRender,
+        isRenderOutdated,
         setHydrationCanBeAborted,
-        isFirstRender: renderNumber === 1
+        isHydrationRender: renderNumber === 1
     };
 }
 function getRenderCount() {

package/dist/esm/client/client-routing-runtime/utils.d.ts

@@ -10,7 +10,7 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';

package/dist/esm/client/client-routing-runtime/utils.js

@@ -16,7 +16,7 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';