vike 0.4.193 → 0.4.194

package/dist/esm/node/runtime/renderPage/{createHttpResponseObject.d.ts → createHttpResponse.d.ts}

@@ -1,6 +1,8 @@
-export { createHttpResponseObject };
+export { createHttpResponse };
 export { createHttpResponsePageContextJson };
-export { createHttpResponseObjectRedirect };
+export { createHttpResponseError };
+export { createHttpResponseRedirect };
+export { createHttpResponseFavicon404 };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
@@ -16,13 +18,15 @@ type HttpResponse = {
     /** **Deprecated**: use `headers` instead, see https://vike.dev/migration/0.4.134 */
     contentType: 'application/json' | 'text/html;charset=utf-8';
 } & HttpResponseBody;
-declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderHook: null | RenderHook, pageContext: {
+declare function createHttpResponse(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
     _pageId: null | string;
     is404: null | boolean;
     errorWhileRendering: null | Error;
     __getPageAssets: GetPageAssets;
     _pageConfigs: PageConfigRuntime[];
     abortStatusCode?: AbortStatusCode;
-}): Promise<HttpResponse | null>;
+}): Promise<HttpResponse>;
+declare function createHttpResponseFavicon404(): HttpResponse;
+declare function createHttpResponseError(): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;

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

@@ -1,16 +1,15 @@
-export { createHttpResponseObject };
+export { createHttpResponse };
 export { createHttpResponsePageContextJson };
-export { createHttpResponseObjectRedirect };
+export { createHttpResponseError };
+export { createHttpResponseRedirect };
+export { createHttpResponseFavicon404 };
 import { assert, assertWarning } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
 import { getEarlyHints } from './getEarlyHints.js';
 import { getCacheControl } from './createHttpResponseObject/getCacheControl.js';
 import { assertNoInfiniteHttpRedirect } from './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 || isErrorPage(pageContext._pageId, pageContext._pageConfigs);
@@ -35,11 +34,19 @@ async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
     }
     return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
 }
+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;
+}
+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;
+}
 async function createHttpResponsePageContextJson(pageContextSerialized) {
     const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
-function createHttpResponseObjectRedirect({ url, statusCode }, 
+function createHttpResponseRedirect({ url, statusCode }, 
 // The URL we assume the redirect to be logically based on
 urlLogical) {
     assertNoInfiniteHttpRedirect(url, urlLogical);
@@ -50,7 +57,7 @@ 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>`);
 }
 function getHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
     headers.push(['Content-Type', contentType]);

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

@@ -21,5 +21,5 @@ declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumpt
     _httpRequestId: number | null;
 }): Promise<{
     renderHook: RenderHook;
-    htmlRender: null | HtmlRender;
+    htmlRender: HtmlRender;
 }>;

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

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

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

@@ -2,7 +2,7 @@ export { handleErrorWithoutErrorPage };
 import { stringify } from '@brillout/json-serializer/stringify';
 import { getGlobalContext } from '../globalContext.js';
 import { assert, assertWarning, objectAssign } from '../utils.js';
-import { createHttpResponseObject } from './createHttpResponseObject.js';
+import { createHttpResponse, createHttpResponseError } from './createHttpResponse.js';
 import pc from '@brillout/picocolors';
 // When the user hasn't defined _error.page.js
 async function handleErrorWithoutErrorPage(pageContext) {
@@ -13,13 +13,14 @@ async function handleErrorWithoutErrorPage(pageContext) {
         warnMissingErrorPage(isV1);
     }
     if (!pageContext.isClientSideNavigation) {
-        objectAssign(pageContext, { httpResponse: null });
+        const httpResponse = createHttpResponseError();
+        objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponseObject(stringify({ serverSideError: true }), null, pageContext);
+        const httpResponse = await createHttpResponse(stringify({ serverSideError: true }), null, pageContext);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

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

@@ -2,6 +2,6 @@ export { inferMediaType };
 export type { MediaType };
 type MediaType = null | {
     assetType: 'image' | 'script' | 'font' | 'style' | 'audio' | 'video' | 'document' | 'fetch' | 'track' | 'worker' | 'embed' | 'object';
-    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
+    mediaType: 'text/javascript' | 'text/css' | 'image/avif' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
 };
 declare function inferMediaType(href: string): MediaType;

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

@@ -24,6 +24,9 @@ function inferMediaType(href) {
     if (href.endsWith('.svg')) {
         return { assetType: 'image', mediaType: 'image/svg+xml' };
     }
+    if (href.endsWith('.avif')) {
+        return { assetType: 'image', mediaType: 'image/avif' };
+    }
     // Fonts
     if (href.endsWith('.ttf')) {
         return { assetType: 'font', mediaType: 'font/ttf' };

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

@@ -1,2 +1,6 @@
-export declare let isConfigInvalid: boolean;
-export declare const isConfigInvalid_set: (val: boolean) => void;
+export { isConfigInvalid };
+export { isConfigInvalid_set };
+declare let isConfigInvalid: false | {
+    err: unknown;
+};
+declare const isConfigInvalid_set: (val: typeof isConfigInvalid) => void;

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

@@ -1,4 +1,8 @@
-export let isConfigInvalid = false;
-export const isConfigInvalid_set = (val) => {
+export { isConfigInvalid };
+export { isConfigInvalid_set };
+import { assert } from '../utils.js';
+let isConfigInvalid;
+const isConfigInvalid_set = (val) => {
+    assert(val === false || val.err);
     isConfigInvalid = val;
 };

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

@@ -8,13 +8,13 @@ export type { PageContextAfterRender };
 export type { PageContextInitEnhanced };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
-import { HttpResponse } from './createHttpResponseObject.js';
+import { HttpResponse } from './createHttpResponse.js';
 import { PageContext_loadUserFilesServerSide, type PageFiles } from './loadUserFilesServerSide.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import type { Hook } from '../../../shared/hooks/getHook.js';
 type PageContextAfterRender = {
-    httpResponse: null | HttpResponse;
+    httpResponse: HttpResponse;
     errorWhileRendering: null | Error;
 };
 declare function renderPageAlreadyRouted<PageContext extends {

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

@@ -10,7 +10,7 @@ import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAs
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { getGlobalContext } from '../globalContext.js';
-import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
+import { createHttpResponse, createHttpResponsePageContextJson } from './createHttpResponse.js';
 import { loadUserFilesServerSide } from './loadUserFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
 import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
@@ -56,16 +56,10 @@ async function renderPageAlreadyRouted(pageContext) {
         return pageContext;
     }
     const renderHookResult = await executeOnRenderHtmlHook(pageContext);
-    if (renderHookResult.htmlRender === null) {
-        objectAssign(pageContext, { httpResponse: null });
-        return pageContext;
-    }
-    else {
-        const { htmlRender, renderHook } = renderHookResult;
-        const httpResponse = await createHttpResponseObject(htmlRender, renderHook, pageContext);
-        objectAssign(pageContext, { httpResponse });
-        return pageContext;
-    }
+    const { htmlRender, renderHook } = renderHookResult;
+    const httpResponse = await createHttpResponse(htmlRender, renderHook, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
 async function prerenderPage(pageContext) {
     objectAssign(pageContext, {

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

@@ -1,6 +1,6 @@
 export { renderPage };
 export { renderPage_addWrapper };
-import { HttpResponse } from './renderPage/createHttpResponseObject.js';
+import { HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
 declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
     pageContextReturn: Awaited<PageContext>;
@@ -12,5 +12,5 @@ declare function renderPage<PageContextUserAdded extends {}, PageContextInit ext
     /** The URL of the HTTP request */
     urlOriginal: string;
 }>(pageContextInit: PageContextInit): Promise<PageContextInit & {
-    httpResponse: HttpResponse | null;
+    httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;

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

@@ -2,11 +2,11 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponseObjectRedirect, createHttpResponsePageContextJson } from './renderPage/createHttpResponseObject.js';
+import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
@@ -19,8 +19,7 @@ import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErro
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
-    httpRequestsCount: 0,
-    pendingRequestsCount: 0
+    httpRequestsCount: 0
 });
 let renderPage_wrapper = async (_httpRequestId, ret) => ({
     pageContextReturn: await ret()
@@ -31,32 +30,34 @@ const renderPage_addWrapper = (wrapper) => {
 // `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) {
     assertArguments(...arguments);
-    assert(hasProp(pageContextInit, 'urlOriginal', 'string'));
+    assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertEnv();
-    if (isIgnoredUrl(pageContextInit.urlOriginal)) {
-        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
-        checkType(pageContextHttpResponseNull);
-        return pageContextHttpResponseNull;
-    }
+    assertIsUrl(pageContextInit.urlOriginal);
+    const urlPathnameWithBase = 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 = 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);
     checkType(pageContextReturn);
+    assert(pageContextReturn.httpResponse);
     return pageContextReturn;
 }
 async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    const handleInvalidConfig = () => {
+    const handleInvalidConfig = (err) => {
         logRuntimeInfo?.(pc.bold(pc.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) {
-        return handleInvalidConfig();
+        if (1 < 2 // Make TS happy
+        ) {
+            return handleInvalidConfig(isConfigInvalid.err);
+        }
     }
     // Prepare context
     let renderContext;
@@ -69,21 +70,17 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
-        const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
-        return pageContextHttpResponseNull;
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        return pageContextWithError;
     }
     if (isConfigInvalid) {
-        return handleInvalidConfig();
+        return handleInvalidConfig(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);
@@ -179,8 +176,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.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;
@@ -188,20 +185,19 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if (isNewError(errErrorPage, errNominalPage)) {
                 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;
-    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
+    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;
@@ -212,10 +208,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
             assert(errorWhileRendering === null || errorWhileRendering === undefined);
-            msg = `HTTP response ${prettyUrl(urlOriginal)} ${pc.dim('null')}`;
+            msg = `HTTP response ${prettyUrl(urlOriginalPretty)} ${pc.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;
         }
@@ -233,28 +229,30 @@ function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
                     .find((header) => header[0] === 'Location');
                 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')}`;
         }
     }
     logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
-function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpResponseNull = createPageContext(pageContextInit);
-    objectAssign(pageContextHttpResponseNull, {
-        httpResponse: null,
+function getPageContextHttpResponseError(err, pageContextInit) {
+    const pageContextWithError = createPageContext(pageContextInit);
+    const httpResponse = createHttpResponseError();
+    objectAssign(pageContextWithError, {
+        httpResponse,
         errorWhileRendering: err
     });
-    return pageContextHttpResponseNull;
+    return pageContextWithError;
 }
-function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpResponseNull = createPageContext(pageContextInit);
-    objectAssign(pageContextHttpResponseNull, {
-        httpResponse: null,
-        errorWhileRendering: null
+function getPageContextHttpResponseFavicon404(pageContextInit) {
+    const pageContext = createPageContext(pageContextInit);
+    const httpResponse = createHttpResponseFavicon404();
+    objectAssign(pageContext, {
+        httpResponse
     });
-    return pageContextHttpResponseNull;
+    checkType(pageContext);
+    return pageContext;
 }
 function createPageContext(pageContextInit) {
     const pageContext = {
@@ -325,10 +323,12 @@ function getRequestId() {
     assert(httpRequestId >= 1);
     return httpRequestId;
 }
-function isIgnoredUrl(urlOriginal) {
-    const isViteRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    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') || !isUrl(urlOriginal) || isViteRequest);
+function assertIsUrl(urlOriginal) {
+    assertUsage(isUrl(urlOriginal), `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.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');
+    assertUsage(!isViteRequest, `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.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 } = getGlobalContext();
@@ -342,7 +342,7 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseObjectRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
+    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -378,7 +378,7 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
+    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -422,7 +422,7 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
     if (pageContextAbort._urlRedirect) {
         const pageContextReturn = createPageContext(pageContextInit);
         objectAssign(pageContextReturn, pageContextAbort);
-        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, (() => {
+        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, (() => {
             const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
             const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
             // The server-side doesn't have access to the hash
@@ -435,18 +435,13 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-function checkBaseUrl(pageContextInit, httpRequestId) {
+function assertBaseUrl(pageContextInit) {
     const { baseServer } = getGlobalContext();
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
-    if (!hasBaseServer) {
-        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;
+    assertUsage(hasBaseServer, `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which doesn't start with Base URL ${prettyUrl(baseServer)} (https://vike.dev/base-url)`);
 }
 function prettyUrl(url) {
-    return pc.bold(decodeURI(url));
+    return pc.code(decodeURI(url));
 }

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

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

package/dist/esm/shared/route/abort.d.ts

@@ -43,9 +43,9 @@ declare function redirect(url: string, statusCode?: 301 | 302): AbortRedirect;
  *   `404` Not Found
  *   `410` Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
  *   `429` Too Many Requests (rate limiting)
- *   `500` Internal Server Error (app has a bug)
- *   `503` Service Unavailable (server is overloaded, a third-party API isn't responding)
- * @param abortReason Sets `pageContext.abortReason` which is used by the error page to show a message to the user, see https://vike.dev/error-page
+ *   `500` Internal Server Error (your client or server has a bug)
+ *   `503` Service Unavailable (server is overloaded, or a third-party API isn't responding)
+ * @param abortReason Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
  */
 declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503, abortReason?: AbortReason): Error;
 /**

package/dist/esm/types/index.d.ts

@@ -3,7 +3,7 @@ export type { PageContextServer } from '../shared/types.js';
 export type { PageContextClient } from '../shared/types.js';
 export type { PageContextWithServerRouting } from '../shared/types.js';
 export type { PageContextClientWithServerRouting } from '../shared/types.js';
-export type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
+export type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.193";
+export declare const PROJECT_VERSION: "0.4.194";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.193';
+export const PROJECT_VERSION = '0.4.194';

package/dist/esm/utils/isArray.js

@@ -1,4 +1,4 @@
-// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+// Same as Array.isArray() but typesafe: asserts unknown[] instead of any[]
 export function isArray(value) {
     return Array.isArray(value);
 }

package/dist/esm/utils/parseUrl-extras.d.ts

@@ -5,6 +5,7 @@ export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
 export { addUrlOrigin };
+export { getUrlPretty };
 declare function prependBase(url: string, baseServer: string): string;
 declare function removeBaseServer(url: string, baseServer: string): string;
 declare function isBaseAssets(base: string): boolean;
@@ -15,3 +16,4 @@ declare function removeUrlOrigin(url: string): {
     origin: string | null;
 };
 declare function addUrlOrigin(url: string, origin: string | null): string;
+declare function getUrlPretty(url: string): string;

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

@@ -5,6 +5,7 @@ export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
 export { addUrlOrigin };
+export { getUrlPretty };
 import { assertUrlComponents, createUrlFromComponents, isBaseServer, parseUrl } from './parseUrl.js';
 import { assert } from './assert.js';
 import { slice } from './slice.js';
@@ -100,3 +101,7 @@ function addUrlOrigin(url, origin) {
     const urlModified = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
     return urlModified;
 }
+function getUrlPretty(url) {
+    const { urlModified } = removeUrlOrigin(url);
+    return urlModified;
+}

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.193";
+    projectVersion: "0.4.194";
 };