vike 0.4.193-commit-c1d490a → 0.4.194

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

@@ -99,17 +99,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) {
-        (0, loggerNotProd_js_1.clearLogs)({ clearErrors: true });
         return;
     }
     if (isVikeConfig) {

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

@@ -37,7 +37,7 @@ function reloadVikeConfig(userRootDir, outDirRoot) {
 }
 exports.reloadVikeConfig = reloadVikeConfig;
 async function handleReloadSideEffects() {
-    wasConfigInvalid = isConfigInvalid_js_1.isConfigInvalid;
+    wasConfigInvalid = !!isConfigInvalid_js_1.isConfigInvalid;
     const vikeConfigPromisePrevious = vikeConfigPromise;
     try {
         await vikeConfigPromise;
@@ -214,7 +214,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
     else {
         (0, utils_js_1.assert)(ret === undefined);
         (0, utils_js_1.assert)(err);
-        (0, isConfigInvalid_js_1.isConfigInvalid_set)(true);
+        (0, isConfigInvalid_js_1.isConfigInvalid_set)({ err });
         if (!isDev) {
             (0, utils_js_1.assert)((0, globalContext_js_1.getViteDevServer)() === null);
             throw err;

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

@@ -48,15 +48,10 @@ 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);
     });
 }
 exports.addSsrMiddleware = addSsrMiddleware;

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

@@ -3,16 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyViteSourceMapToStackTrace = exports.screenHasErrors = exports.clearScreen = exports.isFirstLog = exports.logDirectly = exports.logWithVikeTag = exports.logWithViteTag = void 0;
+exports.applyViteSourceMapToStackTrace = exports.logDirectly = exports.logWithVikeTag = exports.logWithViteTag = void 0;
 const utils_js_1 = require("../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isErrorDebug_js_1 = require("../../../shared/isErrorDebug.js");
 const globalContext_js_1 = require("../../../runtime/globalContext.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
-let isFirstLog = true;
-exports.isFirstLog = isFirstLog;
-let screenHasErrors = false;
-exports.screenHasErrors = screenHasErrors;
 function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
     const projectTag = getProjectTag(showVikeVersion);
     msg = prependTags(msg, projectTag, category, logType);
@@ -39,7 +35,6 @@ exports.logWithViteTag = logWithViteTag;
 //  - 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);
-    exports.isFirstLog = isFirstLog = false;
     if (logType === 'info') {
         console.log(thing);
         return;
@@ -49,7 +44,6 @@ function logDirectly(thing, logType) {
         return;
     }
     if (logType === 'error') {
-        exports.screenHasErrors = screenHasErrors = true;
         console.error(thing);
         return;
     }
@@ -61,12 +55,6 @@ function logDirectly(thing, logType) {
     (0, utils_js_1.assert)(false);
 }
 exports.logDirectly = logDirectly;
-function clearScreen(viteConfig) {
-    // We use Vite's logger in order to respect the user's `clearScreen: false` setting
-    viteConfig.logger.clearScreen('error');
-    exports.screenHasErrors = screenHasErrors = false;
-}
-exports.clearScreen = clearScreen;
 function applyViteSourceMapToStackTrace(thing) {
     if ((0, isErrorDebug_js_1.isErrorDebug)())
         return;

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

@@ -9,7 +9,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearLogs = exports.logErrorDebugNote = exports.logConfigErrorRecover = exports.logConfigError = exports.logConfigInfo = exports.logViteError = exports.logViteAny = void 0;
+exports.logErrorDebugNote = exports.logConfigErrorRecover = exports.logConfigError = exports.logConfigInfo = exports.logViteError = exports.logViteAny = void 0;
 const abort_js_1 = require("../../../shared/route/abort.js");
 const globalContext_js_1 = require("../../runtime/globalContext.js");
 const loggerRuntime_js_1 = require("../../runtime/renderPage/loggerRuntime.js");
@@ -21,15 +21,12 @@ const transpileAndExecuteFile_js_1 = require("../plugins/importUserCode/v1-desig
 const log_js_1 = require("./loggerNotProd/log.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isNewError_js_1 = require("../../runtime/renderPage/isNewError.js");
-const isConfigInvalid_js_1 = require("../../runtime/renderPage/isConfigInvalid.js");
 const loggerProd_js_1 = require("../../runtime/renderPage/loggerProd.js");
 const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 (0, loggerRuntime_js_1.overwriteRuntimeProductionLogger)(logRuntimeError, logRuntimeInfo);
 (0, utils_js_1.overwriteAssertProductionLogger)(assertLogger);
-function logRuntimeInfo(msg, httpRequestId, logType, clearErrors) {
-    if (clearErrors)
-        clearLogs({ clearErrors: true });
+function logRuntimeInfo(msg, httpRequestId, logType) {
     const category = getCategory(httpRequestId);
     (0, utils_js_1.assert)(category);
     (0, log_js_1.logWithVikeTag)(msg, logType, category);
@@ -51,7 +48,6 @@ function logConfigInfo(msg, logType) {
 exports.logConfigInfo = logConfigInfo;
 function logConfigErrorRecover() {
     const msg = picocolors_1.default.bold(picocolors_1.default.green('Configuration successfully loaded'));
-    clearLogs({ clearAlsoIfConfigIsInvalid: true });
     const category = getConfigCategory();
     (0, log_js_1.logWithVikeTag)(msg, 'error-recover', category);
 }
@@ -113,7 +109,6 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
     (0, loggerProd_js_1.onRuntimeError)(err);
 }
 function logConfigError(err) {
-    clearLogs({ clearAlsoIfConfigIsInvalid: true });
     (0, utils_js_1.warnIfErrorIsNotObject)(err);
     const category = getConfigCategory();
     {
@@ -177,23 +172,6 @@ function assertLogger(thing, logType) {
     const { assertMsg, showVikeVersion } = res;
     (0, log_js_1.logWithVikeTag)(assertMsg, logType, category, showVikeVersion);
 }
-function clearLogs(conditions = {}) {
-    if (!conditions.clearAlsoIfConfigIsInvalid && isConfigInvalid_js_1.isConfigInvalid) {
-        // Avoid hiding the config error: the config error is printed only once
-        return;
-    }
-    if (conditions.clearErrors && !log_js_1.screenHasErrors) {
-        return;
-    }
-    if (conditions.clearIfFirstLog && !log_js_1.isFirstLog) {
-        return;
-    }
-    const viteConfig = (0, globalContext_js_1.getViteConfig)();
-    if (viteConfig) {
-        (0, log_js_1.clearScreen)(viteConfig);
-    }
-}
-exports.clearLogs = clearLogs;
 /** 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/cjs/node/plugin/shared/loggerVite.js

@@ -39,9 +39,6 @@ function intercept(logType, config) {
             (0, utils_js_1.assert)(!(0, isErrorDebug_js_1.isErrorDebug)());
             return;
         }
-        // Only allow Vite to clear for its first log. All other clearing is controlled by vike.
-        if (options.clear)
-            (0, loggerNotProd_js_1.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;
         (0, loggerNotProd_js_1.logViteAny)(msg, logType, store?.httpRequestId ?? null, prependViteTag);

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

@@ -7,14 +7,14 @@ exports.assertArguments = void 0;
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function assertArguments(...args) {
-    const prefix = `[renderPage(${picocolors_1.default.cyan('pageContextInit')})]`;
+    const prefix = `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage)`;
     const pageContextInit = args[0];
     (0, utils_js_1.assertUsage)(pageContextInit !== undefined && pageContextInit !== null, prefix + ` argument ${picocolors_1.default.cyan('pageContextInit')} is missing`, { showStackTrace: true });
     const len = args.length;
-    (0, utils_js_1.assertUsage)(len === 1, `${prefix} You passed ${len} arguments but renderPage() accepts only one argument.'`, {
+    (0, utils_js_1.assertUsage)(len === 1, `${prefix} called with ${len} arguments but renderPage() accepts only one argument.'`, {
         showStackTrace: true
     });
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(pageContextInit), `${prefix} ${picocolors_1.default.cyan('pageContextInit')} should be an object, but ${picocolors_1.default.cyan(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)}`, { showStackTrace: true });
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(pageContextInit), `${prefix} called with ${picocolors_1.default.code(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)} but ${picocolors_1.default.code('pageContextInit')} should be an object.`, { showStackTrace: true });
     // TODO/v1-release: remove
     if ('url' in pageContextInit) {
         (0, utils_js_1.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 });

package/dist/cjs/node/runtime/renderPage/{createHttpResponseObject.js → createHttpResponse.js}

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHttpResponseObjectRedirect = exports.createHttpResponsePageContextJson = exports.createHttpResponseObject = void 0;
+exports.createHttpResponseFavicon404 = exports.createHttpResponseRedirect = exports.createHttpResponseError = exports.createHttpResponsePageContextJson = exports.createHttpResponse = void 0;
 const utils_js_1 = require("../utils.js");
 const error_page_js_1 = require("../../../shared/error-page.js");
 const getHttpResponseBody_js_1 = require("./getHttpResponseBody.js");
 const getEarlyHints_js_1 = require("./getEarlyHints.js");
 const getCacheControl_js_1 = require("./createHttpResponseObject/getCacheControl.js");
 const assertNoInfiniteHttpRedirect_js_1 = require("./createHttpResponseObject/assertNoInfiniteHttpRedirect.js");
-async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
-    if (htmlRender === null) {
-        return null;
-    }
+async function createHttpResponse(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
         const isError = !pageContext._pageId || (0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs);
@@ -35,13 +32,23 @@ async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
     }
     return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
 }
-exports.createHttpResponseObject = createHttpResponseObject;
+exports.createHttpResponse = createHttpResponse;
+function createHttpResponseFavicon404() {
+    const httpResponse = getHttpResponse(404, 'text/html;charset=utf-8', [], "<p>No favicon.ico found.</p><script>console.log('This HTTP response was generated by Vike.')</script>");
+    return httpResponse;
+}
+exports.createHttpResponseFavicon404 = createHttpResponseFavicon404;
+function createHttpResponseError() {
+    const httpResponse = getHttpResponse(500, 'text/html;charset=utf-8', [], "<p>An error occurred.</p><script>console.log('This HTTP response was generated by Vike. This response is used instead of rendering the error page (https://vike.dev/error-page), either because there isn't error page or because an error occurred while rendering the error page.')</script>");
+    return httpResponse;
+}
+exports.createHttpResponseError = createHttpResponseError;
 async function createHttpResponsePageContextJson(pageContextSerialized) {
     const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
 exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
-function createHttpResponseObjectRedirect({ url, statusCode }, 
+function createHttpResponseRedirect({ url, statusCode }, 
 // The URL we assume the redirect to be logically based on
 urlLogical) {
     (0, assertNoInfiniteHttpRedirect_js_1.assertNoInfiniteHttpRedirect)(url, urlLogical);
@@ -52,9 +59,9 @@ urlLogical) {
     return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
     // For bots / programmatic crawlig: show what's going on.
     // For users: showing a blank page is probably better than a flickering text.
-    `<p style="display: none">Redirecting to ${url}</p>`);
+    `<p style="display: none">Redirecting to ${url}</p><script>console.log('This HTTP response was generated by Vike.')</script>`);
 }
-exports.createHttpResponseObjectRedirect = createHttpResponseObjectRedirect;
+exports.createHttpResponseRedirect = createHttpResponseRedirect;
 function getHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
     headers.push(['Content-Type', contentType]);
     (0, utils_js_1.assert)(renderHook || typeof htmlRender === 'string');

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

@@ -22,9 +22,6 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });
-    if (documentHtml === null || documentHtml === undefined) {
-        return { htmlRender: null, renderHook };
-    }
     const onErrorWhileStreaming = (err) => {
         // Should the stream inject the following?
         // ```
@@ -81,7 +78,7 @@ function getRenderHook(pageContext) {
     return hookFound;
 }
 function processHookReturnValue(hookReturnValue, renderHook) {
-    let documentHtml = null;
+    let documentHtml;
     let pageContextPromise = null;
     let pageContextProvidedByRenderHook = null;
     let injectFilter = null;
@@ -108,7 +105,8 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookReturnValue.injectFilter), 'injectFilter should be a function');
         injectFilter = hookReturnValue.injectFilter;
     }
-    if (hookReturnValue.documentHtml) {
+    (0, utils_js_1.assertUsage)(hookReturnValue.documentHtml, `${errPrefix} returned an object that is missing the ${picocolors_1.default.code('documentHtml')} property.`);
+    {
         let val = hookReturnValue.documentHtml;
         const errBegin = `${errPrefix} returned ${picocolors_1.default.cyan('{ documentHtml }')}, but ${picocolors_1.default.cyan('documentHtml')}`;
         if (typeof val === 'string') {

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

@@ -7,7 +7,7 @@ exports.handleErrorWithoutErrorPage = void 0;
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const globalContext_js_1 = require("../globalContext.js");
 const utils_js_1 = require("../utils.js");
-const createHttpResponseObject_js_1 = require("./createHttpResponseObject.js");
+const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 // When the user hasn't defined _error.page.js
 async function handleErrorWithoutErrorPage(pageContext) {
@@ -18,13 +18,14 @@ async function handleErrorWithoutErrorPage(pageContext) {
         warnMissingErrorPage(isV1);
     }
     if (!pageContext.isClientSideNavigation) {
-        (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
+        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)();
+        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }
     else {
         const __getPageAssets = async () => [];
         (0, utils_js_1.objectAssign)(pageContext, { __getPageAssets });
-        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponseObject)((0, stringify_1.stringify)({ serverSideError: true }), null, pageContext);
+        const httpResponse = await (0, createHttpResponse_js_1.createHttpResponse)((0, stringify_1.stringify)({ serverSideError: true }), null, pageContext);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isConfigInvalid_set = exports.isConfigInvalid = void 0;
-exports.isConfigInvalid = false;
+const utils_js_1 = require("../utils.js");
+let isConfigInvalid;
 const isConfigInvalid_set = (val) => {
-    exports.isConfigInvalid = val;
+    (0, utils_js_1.assert)(val === false || val.err);
+    exports.isConfigInvalid = isConfigInvalid = val;
 };
 exports.isConfigInvalid_set = isConfigInvalid_set;

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.createHttpResponse)(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);
+        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));
 }