vike 0.4.193-commit-c1d490a → 0.4.194

package/dist/cjs/utils/PROJECT_VERSION.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/esm/node/runtime/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 { 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/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>>;