vike 0.4.193 → 0.4.195-commit-486b49a

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

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

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

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

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

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

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

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

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

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

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.d.ts

@@ -22,7 +22,7 @@ type InjectFilterEntry = {
     isEntry: boolean;
     inject: PreloadFilterInject;
 };
-type Position = 'HTML_BEGIN' | 'HTML_END' | 'STREAM';
+type Position = 'HTML_BEGIN' | 'HTML_END' | 'HTML_STREAM';
 type HtmlTag = {
     htmlTag: string | (() => string);
     position: Position;

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

@@ -20,7 +20,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
         if (asset.isEntry && asset.assetType === 'script') {
             // We could allow the user to change the position of <script> but we currently don't:
             //  - Because of mergeScriptEntries()
-            //  - We would need to add STREAM to to PreloadFilterInject
+            //  - We would need to add HTML_STREAM to to PreloadFilterInject
             // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
             return false;
         }
@@ -77,31 +77,36 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
     // ==========
     // JavaScript
     // ==========
-    // - The pageContext JSON should be fully sent before Vike's client runtime starts executing.
+    // - By default, we place the entry <script> towards the end of the HTML for better performance.
+    //   - Performance-wise, it's more interesting to start showing the page (parse HTML and load CSS) before starting loading scripts.
+    //   - But with HTML streaming, in order to support [Progressive Rendering](https://vike.dev/streaming#progressive-rendering), the entry <script> should be injected earlier instead.
+    // - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
+    // - `<script id="vike_pageContext" type="application/json">` (the `pageContext` JSON) should be fully sent before Vike's client runtime starts executing.
     //   - Otherwise, race condition "SyntaxError: Unterminated string in JSON": https://github.com/vikejs/vike/issues/567
-    //   - <script id="vike_pageContext" type="application/json"> must appear before the entry <script> (which loads Vike's client runtime).
-    //   - <script id="vike_pageContext" type="application/json"> can't be async nor defer.
-    // - The entry <script> can't be defer, otherwise progressive hydration while SSR streaming won't work.
-    // - The entry <script> should be towards the end of the HTML as performance-wise it's more interesting to parse <div id="page-view"> before running the entry <script> which initiates the hydration.
-    //   - But with HTML streaming, in order to support [Progressive Rendering](https://vike.dev/streaming#progressive-rendering), the entry <script> should be injected early instead.
+    //   - `<script id="vike_pageContext" type="application/json">` must appear before the entry <script> (which loads Vike's client runtime).
+    //   - `<script id="vike_pageContext" type="application/json">` can't be async nor defer.
+    const positionJavaScriptDefault = 'HTML_END';
     const positionJavaScriptEntry = (() => {
         if (injectScriptsAt !== null) {
             if (pageContext._pageContextPromise) {
                 assertWarning(injectScriptsAt === 'HTML_END' || !isStream, `You're setting injectScriptsAt to ${pc.code(JSON.stringify(injectScriptsAt))} while using HTML streaming with a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) which is contradictory: the pageContext promise is skipped.`, { onlyOnce: true });
             }
+            if (injectScriptsAt === 'HTML_STREAM' && !isStream) {
+                return positionJavaScriptDefault;
+            }
             return injectScriptsAt;
         }
         if (pageContext._pageContextPromise) {
             // - If there is a pageContext._pageContextPromise then <script id="vike_pageContext" type="application/json"> needs to await for it.
             // - pageContext._pageContextPromise is typically resolved only after the page's components are rendered and the stream ended.
             // - https://vike.dev/streaming#initial-data-after-stream-end
-            return 'HTML_END';
+            return positionJavaScriptDefault;
         }
         if (streamFromReactStreamingPackage && !streamFromReactStreamingPackage.hasStreamEnded()) {
             // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary.
-            return 'STREAM';
+            return 'HTML_STREAM';
         }
-        return 'HTML_END';
+        return positionJavaScriptDefault;
     })();
     if (pageContext._pageContextPromise && streamFromReactStreamingPackage) {
         // - Should we show this warning for Solid as well? Solid seems to also support progressive rendering.
@@ -135,7 +140,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
         const htmlTag = inferPreloadTag(asset);
         if (!asset.inject)
             return;
-        // Ideally, instead of this conditional ternary operator, we should add STREAM to PreloadFilterInject (or a better fitting name such as HTML_STREAM)
+        // Ideally, instead of this conditional ternary operator, we should add HTML_STREAM to PreloadFilterInject
         const position = asset.inject === 'HTML_END' ? positionJavaScriptEntry : asset.inject;
         htmlTags.push({ htmlTag, position });
     });
@@ -217,6 +222,6 @@ function getInjectScriptsAt(pageId, pageConfigs) {
     assertUsage(injectScriptsAt === null ||
         injectScriptsAt === 'HTML_BEGIN' ||
         injectScriptsAt === 'HTML_END' ||
-        injectScriptsAt === 'STREAM', `${configDefinedAt} has an invalid value`);
+        injectScriptsAt === 'HTML_STREAM', `${configDefinedAt} has an invalid value`);
     return injectScriptsAt;
 }

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

@@ -16,7 +16,7 @@ function injectHtmlTags(htmlString, htmlTags, position) {
 }
 // Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
 function injectHtmlTagsUsingStream(htmlTags, streamFromReactStreamingPackage) {
-    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'STREAM'));
+    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'HTML_STREAM'));
     if (htmlFragment) {
         assert(!streamFromReactStreamingPackage.hasStreamEnded());
         streamFromReactStreamingPackage.injectToStream(htmlFragment, { flush: true });

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

@@ -12,7 +12,7 @@ async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
-    assert(htmlTags.filter((snippet) => snippet.position === 'STREAM').length === 0);
+    assert(htmlTags.filter((snippet) => snippet.position === 'HTML_STREAM').length === 0);
     return htmlString;
 }
 function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, injectFilter) {
@@ -39,7 +39,7 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
         if (streamFromReactStreamingPackage)
             return null;
         assert(htmlTags);
-        const tags = htmlTags.filter((h) => h.position === 'STREAM');
+        const tags = htmlTags.filter((h) => h.position === 'HTML_STREAM');
         if (tags.length === 0)
             return null;
         const htmlFragment = joinHtmlTags(tags);

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

@@ -7,17 +7,17 @@ import { getGlobalContext } from '../globalContext.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValue.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
-        const { clientEntryLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
+        const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
         const clientFilePath = getConfigValueRuntime(pageConfig, 'client', 'string')?.value ?? null;
         if (clientFilePath)
             clientEntries.push(clientFilePath);
-        if (clientEntryLoaded)
+        if (isClientRuntimeLoaded)
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
-            onlyAssets: clientEntryLoaded ? false : true,
+            onlyAssets: isClientRuntimeLoaded ? false : true,
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
@@ -53,7 +53,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
             });
         });
         return {
-            isHtmlOnly: !clientEntryLoaded,
+            isHtmlOnly: !isClientRuntimeLoaded,
             isClientRouting,
             clientEntries,
             clientDependencies,

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

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

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

@@ -1,6 +1,8 @@
-export { createHttpResponseObject };
+export { createHttpResponsePage };
 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';
@@ -9,6 +11,7 @@ import type { RenderHook } from './executeOnRenderHtmlHook.js';
 import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';
+import type { PageFile } from '../../../shared/getPageFiles.js';
 type HttpResponse = {
     statusCode: 200 | 404 | 500 | RedirectStatusCode | AbortStatusCode;
     headers: [string, string][];
@@ -16,13 +19,18 @@ 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 createHttpResponsePage(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(pageContext: null | {
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+}): 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 { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
-export { createHttpResponseObjectRedirect };
+export { createHttpResponseError };
+export { createHttpResponseRedirect };
+export { createHttpResponseFavicon404 };
 import { assert, assertWarning } from '../utils.js';
-import { isErrorPage } from '../../../shared/error-page.js';
+import { getErrorPageId, 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;
-    }
+import { getCacheControl } from './createHttpResponse/getCacheControl.js';
+import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
+async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
         const isError = !pageContext._pageId || isErrorPage(pageContext._pageId, pageContext._pageConfigs);
@@ -33,13 +32,33 @@ async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
     if (cacheControl) {
         headers.push(['Cache-Control', cacheControl]);
     }
-    return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+}
+function createHttpResponseFavicon404() {
+    const httpResponse = createHttpResponse(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(pageContext) {
+    const reason = (() => {
+        if (!pageContext) {
+            return 'no error page (https://vike.dev/error-page) could be rendered';
+        }
+        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+        if (errorPageId) {
+            return "the error page (https://vike.dev/error-page) couldn't be rendered (for example if an error occurred while rendering the error page)";
+        }
+        else {
+            return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
+        }
+    })();
+    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTTP response was generated by Vike. Vike returned this response because ${reason}.`)})</script>`);
+    return httpResponse;
 }
 async function createHttpResponsePageContextJson(pageContextSerialized) {
-    const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    const httpResponse = createHttpResponse(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);
@@ -47,12 +66,12 @@ urlLogical) {
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);
     const headers = [['Location', url]];
-    return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
+    return createHttpResponse(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) {
+function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
     headers.push(['Content-Type', contentType]);
     assert(renderHook || typeof htmlRender === 'string');
     return {

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.d.ts

@@ -1,11 +1,13 @@
 export { handleErrorWithoutErrorPage };
 import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
+import type { PageFile } from '../../../shared/getPageFiles.js';
 declare function handleErrorWithoutErrorPage<PageContext extends {
     isClientSideNavigation: boolean;
     errorWhileRendering: null | Error;
     is404: null | boolean;
     _pageId: null;
+    _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     urlOriginal: string;
 }>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;

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 { createHttpResponsePage, 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(pageContext);
+        objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponseObject(stringify({ serverSideError: true }), null, pageContext);
+        const httpResponse = await createHttpResponsePage(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 { createHttpResponsePage, 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 createHttpResponsePage(htmlRender, renderHook, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
 async function prerenderPage(pageContext) {
     objectAssign(pageContext, {