vike 0.4.193 → 0.4.194

package/dist/cjs/node/runtime/renderPage.js

@@ -10,7 +10,7 @@ const utils_js_1 = require("./utils.js");
 const abort_js_1 = require("../../shared/route/abort.js");
 const globalContext_js_1 = require("./globalContext.js");
 const handlePageContextRequestUrl_js_1 = require("./renderPage/handlePageContextRequestUrl.js");
-const createHttpResponseObject_js_1 = require("./renderPage/createHttpResponseObject.js");
+const createHttpResponse_js_1 = require("./renderPage/createHttpResponse.js");
 const loggerRuntime_js_1 = require("./renderPage/loggerRuntime.js");
 const isNewError_js_1 = require("./renderPage/isNewError.js");
 const assertArguments_js_1 = require("./renderPage/assertArguments.js");
@@ -23,8 +23,7 @@ const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithou
 const loadUserFilesServerSide_js_1 = require("./renderPage/loadUserFilesServerSide.js");
 const resolveRedirects_js_1 = require("./renderPage/resolveRedirects.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
-    httpRequestsCount: 0,
-    pendingRequestsCount: 0
+    httpRequestsCount: 0
 });
 let renderPage_wrapper = async (_httpRequestId, ret) => ({
     pageContextReturn: await ret()
@@ -36,33 +35,35 @@ exports.renderPage_addWrapper = renderPage_addWrapper;
 // `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
 async function renderPage(pageContextInit) {
     (0, assertArguments_js_1.assertArguments)(...arguments);
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     (0, utils_js_1.assertEnv)();
-    if (isIgnoredUrl(pageContextInit.urlOriginal)) {
-        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
-        (0, utils_js_1.checkType)(pageContextHttpResponseNull);
-        return pageContextHttpResponseNull;
-    }
+    assertIsUrl(pageContextInit.urlOriginal);
+    const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
+    assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
+    if (urlPathnameWithBase.endsWith('/favicon.ico'))
+        return getPageContextHttpResponseFavicon404(pageContextInit);
     const httpRequestId = getRequestId();
-    const { urlOriginal } = pageContextInit;
-    logHttpRequest(urlOriginal, httpRequestId);
-    globalObject.pendingRequestsCount++;
+    const urlOriginalPretty = (0, utils_js_1.getUrlPretty)(pageContextInit.urlOriginal);
+    logHttpRequest(urlOriginalPretty, httpRequestId);
     const { pageContextReturn } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
-    logHttpResponse(urlOriginal, httpRequestId, pageContextReturn);
-    globalObject.pendingRequestsCount--;
+    logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn);
     (0, utils_js_1.checkType)(pageContextReturn);
+    (0, utils_js_1.assert)(pageContextReturn.httpResponse);
     return pageContextReturn;
 }
 exports.renderPage = renderPage;
 async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    const handleInvalidConfig = () => {
+    const handleInvalidConfig = (err) => {
         (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
-        return pageContextHttpResponseNull;
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        return pageContextWithError;
     };
     if (isConfigInvalid_js_1.isConfigInvalid) {
-        return handleInvalidConfig();
+        if (1 < 2 // Make TS happy
+        ) {
+            return handleInvalidConfig(isConfigInvalid_js_1.isConfigInvalid.err);
+        }
     }
     // Prepare context
     let renderContext;
@@ -75,21 +76,17 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
-        const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
-        return pageContextHttpResponseNull;
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        return pageContextWithError;
     }
     if (isConfigInvalid_js_1.isConfigInvalid) {
-        return handleInvalidConfig();
+        return handleInvalidConfig(isConfigInvalid_js_1.isConfigInvalid.err);
     }
     else {
         // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
     // Check Base URL
-    {
-        const pageContextHttpResponse = checkBaseUrl(pageContextInit, httpRequestId);
-        if (pageContextHttpResponse)
-            return pageContextHttpResponse;
-    }
+    assertBaseUrl(pageContextInit);
     // Normalize URL
     {
         const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId);
@@ -185,8 +182,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-                    return pageContextHttpResponseNull;
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit);
+                    return pageContextHttpWithError;
                 }
                 // `throw redirect()` / `throw render(url)`
                 return handled.pageContextReturn;
@@ -194,20 +191,19 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
                 (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
             }
-            const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-            return pageContextHttpResponseNull;
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit);
+            return pageContextWithError;
         }
         return pageContextErrorPage;
     }
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
-    const clearErrors = globalObject.pendingRequestsCount === 0;
-    (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
 }
 function getRequestInfoMessage(urlOriginal) {
     return `HTTP request: ${prettyUrl(urlOriginal)}`;
 }
-function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
+function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
     let msg;
     let isNominal;
@@ -218,10 +214,10 @@ function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
             // - URL doesn't include Base URL
             //   - Can we abort earlier so that `logHttpResponse()` and `logHttpRequest()` aren't even called?
             // - Error loading a Vike config file
-            //   - We should show `HTTP response ${urlOriginal} ERR` instead.
+            //   - We should show `HTTP response ${urlOriginalPretty} ERR` instead.
             //   - Maybe we can/should make the error available at pageContext.errorWhileRendering
             (0, utils_js_1.assert)(errorWhileRendering === null || errorWhileRendering === undefined);
-            msg = `HTTP response ${prettyUrl(urlOriginal)} ${picocolors_1.default.dim('null')}`;
+            msg = `HTTP response ${prettyUrl(urlOriginalPretty)} ${picocolors_1.default.dim('null')}`;
             // Erroneous value (it shoud sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
             isNominal = true;
         }
@@ -239,28 +235,30 @@ function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
                     .find((header) => header[0] === 'Location');
                 (0, utils_js_1.assert)(headerRedirect);
                 const urlRedirect = headerRedirect[1];
-                urlOriginal = urlRedirect;
+                urlOriginalPretty = urlRedirect;
             }
-            msg = `HTTP ${type} ${prettyUrl(urlOriginal)} ${color(statusCode ?? 'ERR')}`;
+            msg = `HTTP ${type} ${prettyUrl(urlOriginalPretty)} ${color(statusCode ?? 'ERR')}`;
         }
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
-function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpResponseNull = createPageContext(pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
-        httpResponse: null,
+function getPageContextHttpResponseError(err, pageContextInit) {
+    const pageContextWithError = createPageContext(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)();
+    (0, utils_js_1.objectAssign)(pageContextWithError, {
+        httpResponse,
         errorWhileRendering: err
     });
-    return pageContextHttpResponseNull;
+    return pageContextWithError;
 }
-function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpResponseNull = createPageContext(pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
-        httpResponse: null,
-        errorWhileRendering: null
+function getPageContextHttpResponseFavicon404(pageContextInit) {
+    const pageContext = createPageContext(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
+    (0, utils_js_1.objectAssign)(pageContext, {
+        httpResponse
     });
-    return pageContextHttpResponseNull;
+    (0, utils_js_1.checkType)(pageContext);
+    return pageContext;
 }
 function createPageContext(pageContextInit) {
     const pageContext = {
@@ -331,10 +329,12 @@ function getRequestId() {
     (0, utils_js_1.assert)(httpRequestId >= 1);
     return httpRequestId;
 }
-function isIgnoredUrl(urlOriginal) {
-    const isViteRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    (0, utils_js_1.assertWarning)(!isViteRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
-    return (urlOriginal.endsWith('/__vite_ping') || urlOriginal.endsWith('/favicon.ico') || !(0, utils_js_1.isUrl)(urlOriginal) || isViteRequest);
+function assertIsUrl(urlOriginal) {
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isUrl)(urlOriginal), `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which isn't a valid URL.`);
+}
+function assertIsNotViteRequest(urlPathname, urlOriginal) {
+    const isViteRequest = urlPathname.startsWith('/@vite/client') || urlPathname.startsWith('/@fs/') || urlPathname.startsWith('/__vite_ping');
+    (0, utils_js_1.assertUsage)(!isViteRequest, `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because this URL should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
     const { trailingSlash, disableUrlNormalization, baseServer } = (0, globalContext_js_1.getGlobalContext)();
@@ -348,7 +348,7 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     if (!urlNormalized)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -384,7 +384,7 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -413,7 +413,7 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
         else {
             pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextAbort)(pageContextAbort);
         }
-        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
+        const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         const pageContextReturn = { httpResponse };
         return { pageContextReturn };
     }
@@ -428,7 +428,7 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
     if (pageContextAbort._urlRedirect) {
         const pageContextReturn = createPageContext(pageContextInit);
         (0, utils_js_1.objectAssign)(pageContextReturn, pageContextAbort);
-        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, (() => {
+        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, (() => {
             const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
             const urlLogical = (0, utils_js_1.createUrlFromComponents)(null, pathname, searchOriginal, 
             // The server-side doesn't have access to the hash
@@ -441,18 +441,13 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
     (0, utils_js_1.assert)(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-function checkBaseUrl(pageContextInit, httpRequestId) {
+function assertBaseUrl(pageContextInit) {
     const { baseServer } = (0, globalContext_js_1.getGlobalContext)();
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     const { hasBaseServer } = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, baseServer);
-    if (!hasBaseServer) {
-        (0, loggerRuntime_js_1.logRuntimeInfo)?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${prettyUrl(urlOriginal)} doesn't start with Base URL ${prettyUrl(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
-        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
-        return pageContextHttpResponseNull;
-    }
-    return null;
+    (0, utils_js_1.assertUsage)(hasBaseServer, `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which doesn't start with Base URL ${prettyUrl(baseServer)} (https://vike.dev/base-url)`);
 }
 function prettyUrl(url) {
-    return picocolors_1.default.bold(decodeURI(url));
+    return picocolors_1.default.code(decodeURI(url));
 }

package/dist/cjs/shared/page-configs/assertPlusFileExport.js

@@ -24,6 +24,7 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
     }
     const exportDefault = picocolors_1.default.code('export default');
     const exportNamed = picocolors_1.default.code(`export { ${configName} }`);
+    (0, utils_js_1.assert)(exportNamesValid.length <= 2);
     if (exportNamesValid.length === 0) {
         (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} should have a ${exportNamed} or ${exportDefault}`);
     }
@@ -32,8 +33,6 @@ function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
             onlyOnce: true
         });
     }
-    (0, utils_js_1.assert)(exportNamesValid.length === 1);
-    (0, utils_js_1.assert)(exportNamesInvalid.length > 0);
     if (!TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext))) {
         exportNamesInvalid.forEach((exportInvalid) => {
             (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} unexpected ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)}`, {

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.193';
+exports.PROJECT_VERSION = '0.4.194';

package/dist/cjs/utils/isArray.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isArray = void 0;
-// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+// Same as Array.isArray() but typesafe: asserts unknown[] instead of any[]
 function isArray(value) {
     return Array.isArray(value);
 }

package/dist/cjs/utils/parseUrl-extras.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addUrlOrigin = exports.removeUrlOrigin = exports.modifyUrlPathname = exports.removeBaseServer = exports.normalizeUrlPathname = exports.isBaseAssets = exports.prependBase = void 0;
+exports.getUrlPretty = exports.addUrlOrigin = exports.removeUrlOrigin = exports.modifyUrlPathname = exports.removeBaseServer = exports.normalizeUrlPathname = exports.isBaseAssets = exports.prependBase = void 0;
 const parseUrl_js_1 = require("./parseUrl.js");
 const assert_js_1 = require("./assert.js");
 const slice_js_1 = require("./slice.js");
@@ -103,3 +103,8 @@ function addUrlOrigin(url, origin) {
     return urlModified;
 }
 exports.addUrlOrigin = addUrlOrigin;
+function getUrlPretty(url) {
+    const { urlModified } = removeUrlOrigin(url);
+    return urlModified;
+}
+exports.getUrlPretty = getUrlPretty;

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

@@ -170,7 +170,8 @@ async function renderPageClientSide(renderArgs) {
         const pageContext = await createPageContext(urlOriginal);
         objectAssign(pageContext, {
             isBackwardNavigation,
-            isClientSideNavigation
+            isClientSideNavigation,
+            _previousPageContext: globalObject.previousPageContext
         });
         {
             const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);

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

@@ -1,6 +1,6 @@
 export { importBuild };
 export { set_ASSETS_MAP };
-import { serverEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin.js';
+import { serverEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';

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

@@ -8,7 +8,7 @@ import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-file
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
-import { logConfigInfo, clearLogs } from '../../shared/loggerNotProd.js';
+import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
 function importUserCode() {
     let config;
@@ -93,17 +93,13 @@ function handleHotUpdate(ctx, config) {
         `${msg} — ${pc.cyan('no HMR')}, see https://vike.dev/on-demand-compiler`,
         'info',
         null,
-        true,
-        clear,
-        config
+        true
       )
       return
     }
     //*/
-    // HMR can resolve errors => we clear previously shown errors.
     // It can hide an error it shouldn't hide (because the error isn't shown again), but it's ok since users can reload the page and the error will be shown again (Vite transpilation errors are shown again upon a page reload).
     if (!isVikeConfig && isViteModule) {
-        clearLogs({ clearErrors: true });
         return;
     }
     if (isVikeConfig) {

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

@@ -35,7 +35,7 @@ function reloadVikeConfig(userRootDir, outDirRoot) {
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
-    wasConfigInvalid = isConfigInvalid;
+    wasConfigInvalid = !!isConfigInvalid;
     const vikeConfigPromisePrevious = vikeConfigPromise;
     try {
         await vikeConfigPromise;
@@ -210,7 +210,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
     else {
         assert(ret === undefined);
         assert(err);
-        isConfigInvalid_set(true);
+        isConfigInvalid_set({ err });
         if (!isDev) {
             assert(getViteDevServer() === null);
             throw err;

package/dist/esm/node/plugin/shared/addSsrMiddleware.js

@@ -43,14 +43,9 @@ function addSsrMiddleware(middlewares, config, isPreview) {
                 if (value)
                     res.setHeader(name, value);
         }
-        if (!pageContext.httpResponse) {
-            return next();
-        }
-        else {
-            const { statusCode, headers } = pageContext.httpResponse;
-            headers.forEach(([name, value]) => res.setHeader(name, value));
-            res.statusCode = statusCode;
-            pageContext.httpResponse.pipe(res);
-        }
+        const { httpResponse } = pageContext;
+        httpResponse.headers.forEach(([name, value]) => res.setHeader(name, value));
+        res.statusCode = httpResponse.statusCode;
+        httpResponse.pipe(res);
     });
 }

package/dist/esm/node/plugin/shared/loggerNotProd/log.d.ts

@@ -1,16 +1,9 @@
 export { logWithViteTag };
 export { logWithVikeTag };
 export { logDirectly };
-export { isFirstLog };
-export { clearScreen };
-export { screenHasErrors };
 export { applyViteSourceMapToStackTrace };
 import type { LogCategory, LogType } from '../loggerNotProd.js';
-import type { ResolvedConfig } from 'vite';
-declare let isFirstLog: boolean;
-declare let screenHasErrors: boolean;
 declare function logWithVikeTag(msg: string, logType: LogType, category: LogCategory | null, showVikeVersion?: boolean): void;
 declare function logWithViteTag(msg: string, logType: LogType, category: LogCategory | null): void;
 declare function logDirectly(thing: unknown, logType: LogType): void;
-declare function clearScreen(viteConfig: ResolvedConfig): void;
 declare function applyViteSourceMapToStackTrace(thing: unknown): void;

package/dist/esm/node/plugin/shared/loggerNotProd/log.js

@@ -1,17 +1,12 @@
 export { logWithViteTag };
 export { logWithVikeTag };
 export { logDirectly };
-export { isFirstLog };
-export { clearScreen };
-export { screenHasErrors };
 export { applyViteSourceMapToStackTrace };
 import { assert, projectInfo, stripAnsi, hasProp, assertIsNotProductionRuntime } from '../../utils.js';
 import pc from '@brillout/picocolors';
 import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { getViteDevServer } from '../../../runtime/globalContext.js';
 assertIsNotProductionRuntime();
-let isFirstLog = true;
-let screenHasErrors = false;
 function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
     const projectTag = getProjectTag(showVikeVersion);
     msg = prependTags(msg, projectTag, category, logType);
@@ -36,7 +31,6 @@ function logWithViteTag(msg, logType, category) {
 //  - Production => logs aren't managed by loggerNotProd.ts => logDirectly() is never called (not even loaded as asserted by assertIsVitePluginCode())
 function logDirectly(thing, logType) {
     applyViteSourceMapToStackTrace(thing);
-    isFirstLog = false;
     if (logType === 'info') {
         console.log(thing);
         return;
@@ -46,7 +40,6 @@ function logDirectly(thing, logType) {
         return;
     }
     if (logType === 'error') {
-        screenHasErrors = true;
         console.error(thing);
         return;
     }
@@ -57,11 +50,6 @@ function logDirectly(thing, logType) {
     }
     assert(false);
 }
-function clearScreen(viteConfig) {
-    // We use Vite's logger in order to respect the user's `clearScreen: false` setting
-    viteConfig.logger.clearScreen('error');
-    screenHasErrors = false;
-}
 function applyViteSourceMapToStackTrace(thing) {
     if (isErrorDebug())
         return;

package/dist/esm/node/plugin/shared/loggerNotProd.d.ts

@@ -4,7 +4,6 @@ export { logConfigInfo };
 export { logConfigError };
 export { logConfigErrorRecover };
 export { logErrorDebugNote };
-export { clearLogs };
 export type { LogInfo };
 export type { LogInfoArgs };
 export type { LogError };
@@ -17,18 +16,13 @@ type LogInfo = (...args: LogInfoArgs) => void;
 type LogInfoArgs = Parameters<typeof logRuntimeInfo>;
 type LogError = (...args: LogErrorArgs) => void;
 type LogErrorArgs = Parameters<typeof logRuntimeError>;
-declare function logRuntimeInfo(msg: string, httpRequestId: number, logType: LogType, clearErrors?: boolean): void;
+declare function logRuntimeInfo(msg: string, httpRequestId: number, logType: LogType): void;
 declare function logViteAny(msg: string, logType: LogType, httpRequestId: number | null, prependViteTag: boolean): void;
 declare function logConfigInfo(msg: string, logType: LogType): void;
 declare function logConfigErrorRecover(): void;
 declare function logRuntimeError(err: unknown, httpRequestId: number | null): void;
 declare function logViteError(err: unknown, httpRequestId: number | undefined): void;
 declare function logConfigError(err: unknown): void;
-declare function clearLogs(conditions?: {
-    clearErrors?: boolean;
-    clearIfFirstLog?: boolean;
-    clearAlsoIfConfigIsInvalid?: boolean;
-}): void;
 /** Note shown to user when vike does something risky:
  *  - When vike dedupes (i.e. swallows) an error with getHttpRequestAsyncStore().shouldErrorBeSwallowed(err)
  *  - When vike modifies the error with getPrettyErrorWithCodeSnippet(err)

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -10,7 +10,6 @@ export { logConfigInfo };
 export { logConfigError };
 export { logConfigErrorRecover };
 export { logErrorDebugNote };
-export { clearLogs };
 import { isAbortError } from '../../../shared/route/abort.js';
 import { getViteConfig } from '../../runtime/globalContext.js';
 import { overwriteRuntimeProductionLogger } from '../../runtime/renderPage/loggerRuntime.js';
@@ -19,18 +18,15 @@ import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from '../../shared/isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
-import { logWithVikeTag, logWithViteTag, logDirectly, isFirstLog, screenHasErrors, clearScreen, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';
+import { logWithVikeTag, logWithViteTag, logDirectly, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';
 import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
-import { isConfigInvalid } from '../../runtime/renderPage/isConfigInvalid.js';
 import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
 import { isUserHookError } from '../../../shared/hooks/executeHook.js';
 assertIsNotProductionRuntime();
 overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
 overwriteAssertProductionLogger(assertLogger);
-function logRuntimeInfo(msg, httpRequestId, logType, clearErrors) {
-    if (clearErrors)
-        clearLogs({ clearErrors: true });
+function logRuntimeInfo(msg, httpRequestId, logType) {
     const category = getCategory(httpRequestId);
     assert(category);
     logWithVikeTag(msg, logType, category);
@@ -50,7 +46,6 @@ function logConfigInfo(msg, logType) {
 }
 function logConfigErrorRecover() {
     const msg = pc.bold(pc.green('Configuration successfully loaded'));
-    clearLogs({ clearAlsoIfConfigIsInvalid: true });
     const category = getConfigCategory();
     logWithVikeTag(msg, 'error-recover', category);
 }
@@ -110,7 +105,6 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
     onRuntimeError(err);
 }
 function logConfigError(err) {
-    clearLogs({ clearAlsoIfConfigIsInvalid: true });
     warnIfErrorIsNotObject(err);
     const category = getConfigCategory();
     {
@@ -173,22 +167,6 @@ function assertLogger(thing, logType) {
     const { assertMsg, showVikeVersion } = res;
     logWithVikeTag(assertMsg, logType, category, showVikeVersion);
 }
-function clearLogs(conditions = {}) {
-    if (!conditions.clearAlsoIfConfigIsInvalid && isConfigInvalid) {
-        // Avoid hiding the config error: the config error is printed only once
-        return;
-    }
-    if (conditions.clearErrors && !screenHasErrors) {
-        return;
-    }
-    if (conditions.clearIfFirstLog && !isFirstLog) {
-        return;
-    }
-    const viteConfig = getViteConfig();
-    if (viteConfig) {
-        clearScreen(viteConfig);
-    }
-}
 /** Note shown to user when vike does something risky:
  *  - When vike dedupes (i.e. swallows) an error with getHttpRequestAsyncStore().shouldErrorBeSwallowed(err)
  *  - When vike modifies the error with getPrettyErrorWithCodeSnippet(err)

package/dist/esm/node/plugin/shared/loggerVite.js

@@ -1,6 +1,6 @@
 export { improveViteLogs };
 import { assert, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '../utils.js';
-import { logViteError, logViteAny, clearLogs } from './loggerNotProd.js';
+import { logViteError, logViteAny } from './loggerNotProd.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
 import { isErrorDebug } from '../../shared/isErrorDebug.js';
@@ -36,9 +36,6 @@ function intercept(logType, config) {
             assert(!isErrorDebug());
             return;
         }
-        // Only allow Vite to clear for its first log. All other clearing is controlled by vike.
-        if (options.clear)
-            clearLogs({ clearIfFirstLog: true });
         // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
         const prependViteTag = options.timestamp || !!store?.httpRequestId;
         logViteAny(msg, logType, store?.httpRequestId ?? null, prependViteTag);

package/dist/esm/node/runtime/globalContext/loadImportBuild.js

@@ -1,6 +1,6 @@
 export { loadImportBuild };
 export { setImportBuildGetters };
-import { importServerEntry } from '@brillout/vite-plugin-server-entry/importServerEntry.js';
+import { importServerEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { assert } from '../utils.js';
 const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
     getters: null

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

@@ -2,14 +2,14 @@ export { assertArguments };
 import { assert, assertUsage, assertWarning, hasProp, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 function assertArguments(...args) {
-    const prefix = `[renderPage(${pc.cyan('pageContextInit')})]`;
+    const prefix = `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage)`;
     const pageContextInit = args[0];
     assertUsage(pageContextInit !== undefined && pageContextInit !== null, prefix + ` argument ${pc.cyan('pageContextInit')} is missing`, { showStackTrace: true });
     const len = args.length;
-    assertUsage(len === 1, `${prefix} You passed ${len} arguments but renderPage() accepts only one argument.'`, {
+    assertUsage(len === 1, `${prefix} called with ${len} arguments but renderPage() accepts only one argument.'`, {
         showStackTrace: true
     });
-    assertUsage(isObject(pageContextInit), `${prefix} ${pc.cyan('pageContextInit')} should be an object, but ${pc.cyan(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)}`, { showStackTrace: true });
+    assertUsage(isObject(pageContextInit), `${prefix} called with ${pc.code(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)} but ${pc.code('pageContextInit')} should be an object.`, { showStackTrace: true });
     // TODO/v1-release: remove
     if ('url' in pageContextInit) {
         assertWarning(false, '`pageContextInit.url` has been renamed to `pageContextInit.urlOriginal`: replace `renderPage({ url })` with `renderPage({ urlOriginal })`. (See https://vike.dev/migration/0.4.23 for more information.)', { showStackTrace: true, onlyOnce: true });