vike 0.4.193 → 0.4.195-commit-486b49a

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

@@ -11,7 +11,7 @@ const utils_js_1 = require("../utils.js");
 const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
 const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const globalContext_js_1 = require("../globalContext.js");
-const createHttpResponseObject_js_1 = require("./createHttpResponseObject.js");
+const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const loadUserFilesServerSide_js_1 = require("./loadUserFilesServerSide.js");
 const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
 const executeOnBeforeRenderAndDataHooks_js_1 = require("./executeOnBeforeRenderAndDataHooks.js");
@@ -52,21 +52,15 @@ async function renderPageAlreadyRouted(pageContext) {
             (0, utils_js_1.objectAssign)(pageContext, { [isServerSideError_js_1.isServerSideError]: true });
         }
         const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
-        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
+        const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }
     const renderHookResult = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
-    if (renderHookResult.htmlRender === null) {
-        (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
-        return pageContext;
-    }
-    else {
-        const { htmlRender, renderHook } = renderHookResult;
-        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponseObject)(htmlRender, renderHook, pageContext);
-        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
-        return pageContext;
-    }
+    const { htmlRender, renderHook } = renderHookResult;
+    const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePage)(htmlRender, renderHook, pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+    return pageContext;
 }
 exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 async function prerenderPage(pageContext) {

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, null);
+        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, null);
+        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, pageContextErrorPageInit);
+                    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, pageContextErrorPageInit);
+            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,33 @@ 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 prettyUrl(url) {
+    return picocolors_1.default.bold(decodeURI(url));
+}
+function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
+    const pageContextWithError = createPageContext(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
+    (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 = {
@@ -286,6 +287,7 @@ async function renderPageNominal(pageContext) {
         }
     }
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'));
+    (0, utils_js_1.assert)(pageContext.errorWhileRendering === null);
     // Render
     const pageContextAfterRender = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContext);
     (0, utils_js_1.assert)(pageContext === pageContextAfterRender);
@@ -331,10 +333,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 +352,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 +388,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 +417,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 +432,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 +445,10 @@ 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;
-}
-function prettyUrl(url) {
-    return picocolors_1.default.bold(decodeURI(url));
+    (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 ${picocolors_1.default.code(baseServer)} (https://vike.dev/base-url)`);
 }

package/dist/cjs/shared/getPageFiles/analyzeClientSide.js

@@ -7,14 +7,14 @@ function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
     if (pageConfig) {
         const isClientRouting = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-        const clientEntryLoaded = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'clientEntryLoaded', 'boolean')?.value ?? false;
-        return { clientEntryLoaded, isClientRouting };
+        const isClientRuntimeLoaded = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'isClientRuntimeLoaded', 'boolean')?.value ?? false;
+        return { isClientRuntimeLoaded, isClientRouting };
     }
     else {
         // TODO/v1-release: remove
         // V0.4 design
         const { isHtmlOnly, isClientRouting } = (0, analyzePageClientSide_js_1.analyzePageClientSide)(pageFilesAll, pageId);
-        return { clientEntryLoaded: !isHtmlOnly, isClientRouting };
+        return { isClientRuntimeLoaded: !isHtmlOnly, isClientRouting };
     }
 }
 exports.analyzeClientSide = analyzeClientSide;

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/shared/route/executeOnBeforeRouteHook.js

@@ -72,7 +72,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     }
     if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'urlLogical')) {
         (0, utils_js_1.assertUsageUrlPathnameAbsolute)(
-        // We type-cast to string instead of assertUsage() in order to save client-side KBs
+        // We skip validation and type-cast instead of assertUsage() in order to save client-side KBs
         hookReturn.pageContext.urlLogical, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} but ${picocolors_1.default.cyan('urlLogical')}`);
     }
     (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(hookReturn.pageContext, {

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.195-commit-486b49a';

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/isClientSideRoutable.js

@@ -7,6 +7,6 @@ async function isClientSideRoutable(pageId, pageContext) {
         sharedPageFilesAlreadyLoaded: false
     });
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
-    const { clientEntryLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageContext._pageFilesAll, pageId);
-    return clientEntryLoaded && isClientRouting;
+    const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageContext._pageFilesAll, pageId);
+    return isClientRuntimeLoaded && isClientRouting;
 }

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

@@ -20,6 +20,7 @@ import { getErrorPageId } from '../../shared/error-page.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 { previousPageContext } = globalObject;
     const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
     // Note that pageContext.isHydration isn't equivalent to isFirstRender
     // - Thus pageContext.isHydration isn't equivalent to !pageContext.isClientSideNavigation
@@ -41,7 +42,6 @@ async function renderPageClientSide(renderArgs) {
             return;
         // onPageTransitionStart()
         if (globalObject.isFirstRenderDone) {
-            const { previousPageContext } = globalObject;
             assert(previousPageContext);
             // We use the hook of the previous page in order to be able to call onPageTransitionStart() before fetching the files of the next page.
             // https://github.com/vikejs/vike/issues/1560
@@ -81,23 +81,30 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            let isClientRoutable;
             if (!pageContextFromRoute._pageId) {
-                isClientRoutable = false;
-            }
-            else {
-                isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
-                if (isRenderOutdated())
-                    return;
+                /*
+                // We don't use the client router to render the 404 page:
+                //  - So that the +redirects setting (https://vike.dev/redirects) can be applied.
+                //    - This is the main argument.
+                //    - See also failed CI: https://github.com/vikejs/vike/pull/1871
+                //  - So that server-side error tracking can track 404 links?
+                //    - We do use the client router for rendering the error page, so I don't think this is much of an argument.
+                await renderErrorPage({ is404: true })
+                */
+                redirectHard(urlOriginal);
+                return;
             }
+            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
+            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
+            if (isRenderOutdated())
+                return;
             if (!isClientRoutable) {
                 redirectHard(urlOriginal);
                 return;
             }
-            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
             const isSamePage = pageContextFromRoute._pageId &&
-                globalObject.previousPageContext?._pageId &&
-                pageContextFromRoute._pageId === globalObject.previousPageContext._pageId;
+                previousPageContext?._pageId &&
+                pageContextFromRoute._pageId === previousPageContext._pageId;
             if (isUserLandPushStateNavigation && isSamePage) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
@@ -170,7 +177,8 @@ async function renderPageClientSide(renderArgs) {
         const pageContext = await createPageContext(urlOriginal);
         objectAssign(pageContext, {
             isBackwardNavigation,
-            isClientSideNavigation
+            isClientSideNavigation,
+            _previousPageContext: previousPageContext
         });
         {
             const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
@@ -207,9 +215,10 @@ async function renderPageClientSide(renderArgs) {
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
-        if (args.pageContextError) {
+        if (args.is404)
+            objectAssign(pageContext, { is404: true });
+        if (args.pageContextError)
             objectAssign(pageContext, args.pageContextError);
-        }
         if ('err' in args) {
             const { err } = args;
             assert(!('errorWhileRendering' in pageContext));
@@ -265,6 +274,13 @@ async function renderPageClientSide(renderArgs) {
         objectAssign(pageContext, {
             _pageId: errorPageId
         });
+        const isClientRoutable = await isClientSideRoutable(pageContext._pageId, pageContext);
+        if (isRenderOutdated())
+            return;
+        if (!isClientRoutable) {
+            redirectHard(urlOriginal);
+            return;
+        }
         try {
             objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
@@ -366,7 +382,6 @@ async function renderPageClientSide(renderArgs) {
         // onPageTransitionEnd()
         if (globalObject.isTransitioning) {
             globalObject.isTransitioning = undefined;
-            const { previousPageContext } = globalObject;
             assert(previousPageContext);
             assertHook(previousPageContext, 'onPageTransitionEnd');
             const hook = getHook(previousPageContext, 'onPageTransitionEnd');

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/configDefinitionsBuiltIn.js

@@ -76,7 +76,11 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true }
     },
-    clientEntryLoaded: {
+    // Whether the page loads:
+    //  - Vike's client runtime
+    //  - User's client hooks
+    // In other words, whether the page is "HTML-only" (https://vike.dev/render-modes). HTML-only pages shouldn't load the client runtime nor client hooks.
+    isClientRuntimeLoaded: {
         env: { server: true, client: true },
         eager: true,
         _computed: (configValueSources) => {

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;