vike 0.4.156 → 0.4.158

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

@@ -1,7 +1,6 @@
 export { getPageContextFromHooks_isHydration };
 export { getPageContextFromHooks_isNotHydration };
 export { getPageContextFromHooks_serialized };
-export { isServerSideRouted };
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
@@ -15,7 +14,7 @@ import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRende
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
-import { isRenderFailure } from '../../shared/misc/isRenderFailure.js';
+import { isServerSideError } from '../../shared/misc/isServerSideError.js';
 const globalObject = getGlobalObject('router/getPageContext.ts', {});
 function getPageContextFromHooks_serialized() {
     const pageContextSerialized = getPageContextSerializedInHtml();
@@ -54,23 +53,15 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     !isErrorPage &&
         // true if pageContextInit has some client data or at least one of the data() and onBeforeRender() hooks is server-side only:
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
-        const pageContextFromServer = await fetchPageContextFromServer(pageContext);
+        const res = await fetchPageContextFromServer(pageContext);
+        if ('is404ServerSideRouted' in res)
+            return { is404ServerSideRouted: true };
+        const { pageContextFromServer } = res;
         hasPageContextFromServer = true;
-        if (!pageContextFromServer[isRenderFailure] || isErrorPage) {
-            objectAssign(pageContextFromHooks, pageContextFromServer);
-        }
-        else {
-            // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
-            assert(!('serverSideError' in pageContextFromServer));
-            assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
-            assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
-            assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));
-            objectAssign(pageContextFromServer, {
-                _hasPageContextFromServer: true,
-                _hasPageContextFromClient: false
-            });
-            return pageContextFromServer;
-        }
+        // Already handled
+        assert(!(isServerSideError in pageContextFromServer));
+        assert(!('serverSideError' in pageContextFromServer));
+        objectAssign(pageContextFromHooks, pageContextFromServer);
     }
     // At this point, we need to call the client-side guard(), data() and onBeforeRender() hooks, if they exist on client
     // env. However if we have fetched pageContext from the server, some of them might have run already on the
@@ -107,7 +98,7 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     objectAssign(pageContextFromHooks, {
         _hasPageContextFromServer: hasPageContextFromServer
     });
-    return pageContextFromHooks;
+    return { pageContextFromHooks };
 }
 async function executeHookClientSide(hookName, pageContext) {
     const hook = getHook(pageContext, hookName);
@@ -217,32 +208,25 @@ async function fetchPageContextFromServer(pageContext) {
         // Static hosts + page doesn't exist
         if (!isCorrect && response.status === 404) {
             serverSideRouteTo(pageContext.urlOriginal);
-            throw ServerSideRouted();
+            return { is404ServerSideRouted: true };
         }
         assertUsage(isCorrect, `Wrong Content-Type for ${pageContextUrl}: it should be ${contentTypeCorrect} but it's ${contentType} instead. Make sure to properly use pageContext.httpResponse.headers, see https://vike.dev/renderPage`);
     }
     const responseText = await response.text();
     const pageContextFromServer = parse(responseText);
     assert(isObject(pageContextFromServer));
-    if ('serverSideError' in pageContextFromServer) {
-        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
-    }
     if (isAbortPageContext(pageContextFromServer)) {
         throw AbortRender(pageContextFromServer);
     }
+    // Is there a reason for having two different properties? Can't we use only one property? I guess/think the isServerSideError property was an attempt (a bad idea really) for rendering the error page even though an error occured on the server-side (which is a bad idea because the added complexity is non-negligible while the added value is minuscule since the error page usually doesn't have any (meaningful / server-side) hooks).
+    if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
+        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
+    }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);
-    return pageContextFromServer;
+    return { pageContextFromServer };
 }
 function processPageContextFromServer(pageContextFromServer) {
     setPageContextInitIsPassedToClient(pageContextFromServer);
     removeBuiltInOverrides(pageContextFromServer);
 }
-function isServerSideRouted(err) {
-    return isObject(err) && !!err._alreadyServerSideRouted;
-}
-function ServerSideRouted() {
-    const err = new Error("Page doesn't exist");
-    Object.assign(err, { _alreadyServerSideRouted: true });
-    return err;
-}

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

@@ -11,7 +11,7 @@ import { createPageContext } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 assertClientRouting();
-const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new Map() });
+const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new WeakMap() });
 async function prefetchAssets(pageId, pageContext) {
     try {
         await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs);

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

@@ -2,7 +2,7 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
-import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized, isServerSideRouted } from './getPageContextFromHooks.js';
+import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
@@ -17,7 +17,6 @@ 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;
@@ -32,6 +31,9 @@ async function renderPageClientSide(renderArgs) {
     await renderPageNominal();
     return;
     async function renderPageNominal() {
+        const onError = async (err) => {
+            await renderErrorPage({ err });
+        };
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
@@ -47,7 +49,7 @@ async function renderPageClientSide(renderArgs) {
                 pageContextFromRoute = await route(pageContext);
             }
             catch (err) {
-                await renderErrorPage({ err });
+                await onError(err);
                 return;
             }
             if (isRenderOutdated())
@@ -85,7 +87,9 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
             else {
-                throw err;
+                // A user file has a syntax error
+                await onError(err);
+                return;
             }
         }
         if (isRenderOutdated())
@@ -113,7 +117,7 @@ async function renderPageClientSide(renderArgs) {
                         await executeHook(() => hookFn(pageContext), hook);
                     }
                     catch (err) {
-                        await renderErrorPage({ err });
+                        await onError(err);
                         return;
                     }
                     if (isRenderOutdated())
@@ -129,7 +133,7 @@ async function renderPageClientSide(renderArgs) {
                 pageContextFromHooks = await getPageContextFromHooks_isHydration(pageContext);
             }
             catch (err) {
-                await renderErrorPage({ err });
+                await onError(err);
                 return;
             }
             if (isRenderOutdated())
@@ -140,20 +144,19 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
         else {
-            let pageContextFromHooks;
+            let res;
             try {
-                pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, false);
+                res = await getPageContextFromHooks_isNotHydration(pageContext, false);
             }
             catch (err) {
-                await renderErrorPage({ err });
+                await onError(err);
                 return;
             }
             if (isRenderOutdated())
                 return;
-            if (isRenderFailure in pageContextFromHooks) {
-                await renderErrorPage({ pageContextError: pageContextFromHooks });
+            if ('is404ServerSideRouted' in res)
                 return;
-            }
+            const pageContextFromHooks = res.pageContextFromHooks;
             assert(!('urlOriginal' in pageContextFromHooks));
             objectAssign(pageContext, pageContextFromHooks);
             // Render page view
@@ -174,19 +177,19 @@ async function renderPageClientSide(renderArgs) {
         return pageContext;
     }
     async function renderErrorPage(args) {
-        const pageContext = await getPageContextBegin();
-        if (isRenderOutdated())
-            return;
-        if (args.pageContextError) {
-            objectAssign(pageContext, args.pageContextError);
-        }
+        const onError = (err) => {
+            if (!isSameErrorMessage(err, args.err)) {
+                /* 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(err);
+            }
+        };
         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.)
@@ -197,6 +200,17 @@ async function renderPageClientSide(renderArgs) {
                 // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
                 // We handle the abort error down below.
             }
+        }
+        const pageContext = await getPageContextBegin();
+        if (isRenderOutdated())
+            return;
+        if (args.pageContextError) {
+            objectAssign(pageContext, args.pageContextError);
+        }
+        if ('err' in args) {
+            const { err } = args;
+            assert(!('errorWhileRendering' in pageContext));
+            pageContext.errorWhileRendering = err;
             if (isAbortError(err)) {
                 const errAbort = err;
                 logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
@@ -256,38 +270,44 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
             else {
-                throw err;
+                // A user file has a syntax error
+                onError(err);
+                return;
             }
         }
         if (isRenderOutdated())
             return;
-        let pageContextFromHooks;
+        let res;
         try {
-            pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, true);
+            res = await getPageContextFromHooks_isNotHydration(pageContext, true);
         }
-        catch (errErrorPage) {
+        catch (err) {
             // - 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);
-            }
+            onError(err);
             return;
         }
         if (isRenderOutdated())
             return;
+        if ('is404ServerSideRouted' in res)
+            return;
+        const pageContextFromHooks = res.pageContextFromHooks;
         assert(pageContextFromHooks);
         assert(!('urlOriginal' in pageContextFromHooks));
         objectAssign(pageContext, pageContextFromHooks);
-        await renderPageView(pageContext, true);
+        await renderPageView(pageContext, args);
     }
     async function renderPageView(pageContext, isErrorPage) {
+        const onError = async (err) => {
+            if (!isErrorPage) {
+                await renderErrorPage({ err });
+            }
+            else {
+                if (!isSameErrorMessage(err, isErrorPage.err)) {
+                    console.error(err);
+                }
+            }
+        };
         // 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
@@ -304,12 +324,8 @@ async function renderPageClientSide(renderArgs) {
                 await executeOnRenderClientHook(pageContext, true);
             }
             catch (err) {
-                if (!isErrorPage) {
-                    renderErrorPage({ err });
-                }
-                else {
-                    throw err;
-                }
+                await onError(err);
+                return;
             }
             addLinkPrefetchHandlers(pageContext);
             globalObject.renderPromise = undefined;
@@ -329,12 +345,9 @@ async function renderPageClientSide(renderArgs) {
                     await executeHook(() => hookFn(pageContext), hook);
                 }
                 catch (err) {
-                    if (!isErrorPage) {
-                        renderErrorPage({ err });
-                    }
-                    else {
-                        throw err;
-                    }
+                    await onError(err);
+                    if (!isErrorPage)
+                        return;
                 }
                 if (isRenderOutdated(true))
                     return;
@@ -354,12 +367,9 @@ async function renderPageClientSide(renderArgs) {
                     await executeHook(() => hookFn(pageContext), hook);
                 }
                 catch (err) {
-                    if (!isErrorPage) {
-                        renderErrorPage({ err });
-                    }
-                    else {
-                        throw err;
-                    }
+                    await onError(err);
+                    if (!isErrorPage)
+                        return;
                 }
                 if (isRenderOutdated(true))
                     return;
@@ -378,11 +388,6 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistory(url, overwriteLastHistoryEntry);
     updateState();
 }
-function shouldSwallowAndInterrupt(err) {
-    if (isServerSideRouted(err))
-        return true;
-    return false;
-}
 function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
     if (!isErrorFetchingStaticAssets(err)) {
         return false;

package/dist/esm/client/shared/loadUserFilesClientSide.js

@@ -19,10 +19,12 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         pageConfigLoaded = result[0];
     }
     catch (err) {
-        // To trigger this catch: add `throw new Error()` in the global scope of +onRenderClient.js
         if (isFetchError(err)) {
             Object.assign(err, { [stamp]: true });
         }
+        else {
+            // A user file has a syntax error
+        }
         throw err;
     }
     const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesClientSide, pageConfigLoaded);

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -23,7 +23,10 @@ function commonConfig() {
             configResolved: {
                 order: 'post',
                 handler(config) {
-                    setDefaultPort(config);
+                    overrideViteDefaultPort(config);
+                    /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
+                    overrideViteDefaultSsrExternal(config)
+                    */
                     workaroundCI(config);
                     assertRollupInput(config);
                     assertResolveAlias(config);
@@ -33,7 +36,7 @@ function commonConfig() {
         }
     ];
 }
-function setDefaultPort(config) {
+function overrideViteDefaultPort(config) {
     var _a, _b;
     // @ts-ignore
     config.server ?? (config.server = {});
@@ -42,6 +45,22 @@ function setDefaultPort(config) {
     config.preview ?? (config.preview = {});
     (_b = config.preview).port ?? (_b.port = 3000);
 }
+/*
+function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
+  if (!isViteVersionWithSsrExternalTrue()) return
+  // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
+  config.ssr.external ??= true
+}
+import { version } from 'vite'
+function isViteVersionWithSsrExternalTrue(): boolean {
+  const versionParts = version.split('.').map((s) => parseInt(s, 10)) as [number, number, number]
+  assert(versionParts.length === 3)
+  if (versionParts[0] > 5) return true
+  if (versionParts[1] > 0) return true
+  if (versionParts[2] >= 12) return true
+  return false
+}
+*/
 // Workaround GitHub Action failing to access the server
 function workaroundCI(config) {
     var _a, _b;

package/dist/esm/node/plugin/plugins/distFileNames.js

@@ -13,13 +13,13 @@ function distFileNames() {
             const rollupOutputs = getRollupOutputs(config);
             // We need to support multiple outputs: @vite/plugin-legacy adds an ouput, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
             rollupOutputs.forEach((rollupOutput) => {
-                if (!rollupOutput.entryFileNames) {
+                if (!('entryFileNames' in rollupOutput)) {
                     rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, true);
                 }
-                if (!rollupOutput.chunkFileNames) {
+                if (!('chunkFileNames' in rollupOutput)) {
                     rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
                 }
-                if (!rollupOutput.assetFileNames) {
+                if (!('assertUsage' in rollupOutput)) {
                     rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
                 }
             });

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -28,7 +28,7 @@ function importBuild() {
                 await replace_ASSETS_MAP(options, bundle);
             }
         },
-        serverEntryPlugin({
+        ...serverEntryPlugin({
             getImporterCode: () => {
                 return getEntryCode(config, configVike);
             },

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -139,6 +139,8 @@ async function isGitMissing(userRootDir) {
 }
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });
-    assert(res.stderr === '');
+    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
+    assert(res.stderr === '')
+    */
     return res.stdout.toString().split('\n').filter(Boolean);
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -836,6 +836,7 @@ function getConfigName(filePath) {
     }
     else {
         const configName = basename.slice(1);
+        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
         return configName;
     }
 }
@@ -1028,6 +1029,7 @@ function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
     // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
     const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -49,6 +49,8 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
             assert(configValueSource);
             if (!configValueSource.configEnv.eager)
                 return;
+            if (!isRuntimeEnvMatch(configValueSource.configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
             lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet/fixture-errors/errMdx.js

@@ -12,7 +12,7 @@ export const errMdx = {
     ruleId: 'unexpected-closing-slash',
     plugin: '@mdx-js/rollup',
     id: '/home/rom/code/vike/docs/pages/dynamic-import.page.server.mdx',
-    pluginCode: 'import { Link, Note } from \'@brillout/docpress\'\n\nPage moved to <Link href="/client-only-components" />.\n\n   </Note>\n\n\nexport const headings = [];\n',
+    pluginCode: 'import { Link, Note } from \'@brillout/docpress\'\n\nPage moved to <Link href="/ClientOnly" />.\n\n   </Note>\n\n\nexport const headings = [];\n',
     loc: {
         file: '/home/rom/code/vike/docs/pages/dynamic-import.page.server.mdx',
         start: { line: 5, column: 5, offset: 109, _index: 6, _bufferIndex: 4 },

package/dist/esm/node/prerender/runPrerender.js

@@ -29,6 +29,8 @@ import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVik
 import { logHintForCjsEsmError } from '../runtime/renderPage/logHintForCjsEsmError.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
+    // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
+    // - We don't use logHintForCjsEsmError() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 async function runPrerenderFromCLI(options) {
     try {

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -85,12 +85,12 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     // See https://github.com/vikejs/vike/pull/1271
     const positionJavaScriptEntry = (() => {
         if (pageContext._pageContextPromise) {
-            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time as partial hydration won't work", { onlyOnce: true });
+            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time as progressive hydration won't work", { onlyOnce: true });
             // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/stream#initial-data-after-stream-end
             return 'HTML_END';
         }
         if (injectToStream) {
-            // If there is a stream then, in order to support partial hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary
+            // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary
             return 'STREAM';
         }
         else {

package/dist/esm/node/runtime/html/injectAssets/inferHtmlTags.js

@@ -3,7 +3,7 @@ export { inferPreloadTag };
 export { inferEarlyHintLink };
 export { scriptAttrs };
 import { assert } from '../../utils.js';
-// We can't use `defer` here. With `defer`, the entry script won't start before `</body>` has been parsed, preventing partial hydration during SSR streaming, see https://github.com/vikejs/vike/pull/1271
+// We can't use `defer` here. With `defer`, the entry script won't start before `</body>` has been parsed, preventing progressive hydration during SSR streaming, see https://github.com/vikejs/vike/pull/1271
 const scriptAttrs = 'type="module" async';
 function inferPreloadTag(pageAsset) {
     const { src, assetType, mediaType } = pageAsset;

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -7,7 +7,7 @@ import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 import { notSerializable } from '../../../shared/notSerializable.js';
 import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
-import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
+import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 const PASS_TO_CLIENT = [
     'abortReason',
     '_urlRewrite',
@@ -21,7 +21,7 @@ const PASS_TO_CLIENT = [
     '_pageId',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isRenderFailure];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
     const pageContextClient = {};

package/dist/esm/node/runtime/renderPage/getHttpResponseBody.d.ts

@@ -24,6 +24,7 @@ declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender, rende
     getBody(): Promise<string>;
     getNodeStream(): Promise<import("stream").Readable>;
     getWebStream(): StreamReadableWeb;
+    getReadableNodeStream(): Promise<import("stream").Readable>;
     getReadableWebStream(): StreamReadableWeb;
     pipeToWebWritable(writable: StreamWritableWeb): void;
     pipeToNodeWritable(writable: StreamWritableNode): void;

package/dist/esm/node/runtime/renderPage/getHttpResponseBody.js

@@ -20,7 +20,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
         },
         // TODO/v1-release: remove
         async getNodeStream() {
-            assertWarning(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.pipe()` instead. ' +
+            assertWarning(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.getReadableNodeStream()` instead. ' +
                 streamDocs, { onlyOnce: true, showStackTrace: true });
             const nodeStream = await getStreamReadableNode(htmlRender);
             if (nodeStream === null) {
@@ -38,6 +38,13 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
             return webStream;
         },
+        async getReadableNodeStream() {
+            const nodeStream = await getStreamReadableNode(htmlRender);
+            if (nodeStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableNodeStream()', getFixMsg('readable', 'node')));
+            }
+            return nodeStream;
+        },
         getReadableWebStream() {
             const webStream = getStreamReadableWeb(htmlRender);
             if (webStream === null) {

package/dist/esm/node/runtime/renderPage/isNewError.js

@@ -6,7 +6,9 @@ const globalObject = getGlobalObject('runtime/renderPage/isNewError.ts', {
 });
 function isNewError(errErrorPage, errNominalPage) {
     warnIfErrorIsNotObject(errErrorPage);
-    return !isSameErrorMessage(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+    return (!isSameErrorMessage(errNominalPage, errErrorPage) ||
+        // Isn't this redudant/superfluous? I think we can remove this entire file and only use isSameErrorMessage() instead.
+        !hasAlreadyLogged(errNominalPage));
 }
 function hasAlreadyLogged(err) {
     if (!isObject(err))

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -21,7 +21,7 @@ import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
 import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
-import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
+import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -48,7 +48,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     if (pageContext.isClientSideNavigation) {
         if (isError) {
-            objectAssign(pageContext, { [isRenderFailure]: true });
+            objectAssign(pageContext, { [isServerSideError]: true });
         }
         const pageContextSerialized = serializePageContextClientSide(pageContext);
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
@@ -181,5 +181,5 @@ function assertV1Design(pageFilesAll, pageConfigs) {
             ...pageFilesAll.map((p) => indent + p.filePath)
         ].join('\n'));
     }
-    assertWarning(!isDesignOld, 'You are using the old deprecated design, update to the new V1 design, see https://vike.dev/migration/v1-design', { onlyOnce: true });
+    assertWarning(!isDesignOld, "You are using Vike's deprecated design. Update to the new V1 design, see https://vike.dev/migration/v1-design for how to migrate.", { onlyOnce: true });
 }