vike 0.4.194 → 0.4.195-commit-486b49a

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2021-present Romuald Brillout
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

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

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

@@ -25,7 +25,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;
         }
@@ -82,31 +82,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) {
                 (0, utils_js_1.assertWarning)(injectScriptsAt === 'HTML_END' || !isStream, `You're setting injectScriptsAt to ${picocolors_1.default.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.
@@ -140,7 +145,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
         const htmlTag = (0, inferHtmlTags_js_1.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 });
     });
@@ -223,6 +228,6 @@ function getInjectScriptsAt(pageId, pageConfigs) {
     (0, utils_js_1.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/cjs/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -13,7 +13,7 @@ function injectHtmlTags(htmlString, htmlTags, position) {
 exports.injectHtmlTags = injectHtmlTags;
 // 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) {
         (0, utils_js_1.assert)(!streamFromReactStreamingPackage.hasStreamEnded());
         streamFromReactStreamingPackage.injectToStream(htmlFragment, { flush: true });

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

@@ -13,7 +13,7 @@ async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
-    (0, utils_js_1.assert)(htmlTags.filter((snippet) => snippet.position === 'STREAM').length === 0);
+    (0, utils_js_1.assert)(htmlTags.filter((snippet) => snippet.position === 'HTML_STREAM').length === 0);
     return htmlString;
 }
 exports.injectHtmlTagsToString = injectHtmlTagsToString;
@@ -41,7 +41,7 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
         if (streamFromReactStreamingPackage)
             return null;
         (0, utils_js_1.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 = (0, injectHtmlTags_js_1.joinHtmlTags)(tags);

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

@@ -9,17 +9,17 @@ const globalContext_js_1 = require("../globalContext.js");
 const getConfigValue_js_1 = require("../../../shared/page-configs/getConfigValue.js");
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
-        const { clientEntryLoaded, isClientRouting } = (0, analyzeClientSide_js_1.analyzeClientSide)(pageConfig, pageFilesAll, pageId);
+        const { isClientRuntimeLoaded, isClientRouting } = (0, analyzeClientSide_js_1.analyzeClientSide)(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
         const clientFilePath = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'client', 'string')?.value ?? null;
         if (clientFilePath)
             clientEntries.push(clientFilePath);
-        if (clientEntryLoaded)
+        if (isClientRuntimeLoaded)
             clientEntries.push((0, determineClientEntry_js_1.getVikeClientEntry)(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: (0, virtualFilePageConfigValuesAll_js_1.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
@@ -55,7 +55,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
             });
         });
         return {
-            isHtmlOnly: !clientEntryLoaded,
+            isHtmlOnly: !isClientRuntimeLoaded,
             isClientRouting,
             clientEntries,
             clientDependencies,

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHttpResponseFavicon404 = exports.createHttpResponseRedirect = exports.createHttpResponseError = exports.createHttpResponsePageContextJson = exports.createHttpResponse = void 0;
+exports.createHttpResponseFavicon404 = exports.createHttpResponseRedirect = exports.createHttpResponseError = exports.createHttpResponsePageContextJson = exports.createHttpResponsePage = void 0;
 const utils_js_1 = require("../utils.js");
 const error_page_js_1 = require("../../../shared/error-page.js");
 const getHttpResponseBody_js_1 = require("./getHttpResponseBody.js");
 const getEarlyHints_js_1 = require("./getEarlyHints.js");
-const getCacheControl_js_1 = require("./createHttpResponseObject/getCacheControl.js");
-const assertNoInfiniteHttpRedirect_js_1 = require("./createHttpResponseObject/assertNoInfiniteHttpRedirect.js");
-async function createHttpResponse(htmlRender, renderHook, pageContext) {
+const getCacheControl_js_1 = require("./createHttpResponse/getCacheControl.js");
+const assertNoInfiniteHttpRedirect_js_1 = require("./createHttpResponse/assertNoInfiniteHttpRedirect.js");
+async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
         const isError = !pageContext._pageId || (0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs);
@@ -30,21 +30,33 @@ async function createHttpResponse(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);
 }
-exports.createHttpResponse = createHttpResponse;
+exports.createHttpResponsePage = createHttpResponsePage;
 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>");
+    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;
 }
 exports.createHttpResponseFavicon404 = createHttpResponseFavicon404;
-function createHttpResponseError() {
-    const httpResponse = getHttpResponse(500, 'text/html;charset=utf-8', [], "<p>An error occurred.</p><script>console.log('This HTTP response was generated by Vike. This response is used instead of rendering the error page (https://vike.dev/error-page), either because there isn't error page or because an error occurred while rendering the error page.')</script>");
+function createHttpResponseError(pageContext) {
+    const reason = (() => {
+        if (!pageContext) {
+            return 'no error page (https://vike.dev/error-page) could be rendered';
+        }
+        const errorPageId = (0, error_page_js_1.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;
 }
 exports.createHttpResponseError = createHttpResponseError;
 async function createHttpResponsePageContextJson(pageContextSerialized) {
-    const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
 exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
@@ -56,13 +68,13 @@ urlLogical) {
     (0, utils_js_1.assert)(statusCode);
     (0, utils_js_1.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><script>console.log('This HTTP response was generated by Vike.')</script>`);
 }
 exports.createHttpResponseRedirect = createHttpResponseRedirect;
-function getHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
+function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
     headers.push(['Content-Type', contentType]);
     (0, utils_js_1.assert)(renderHook || typeof htmlRender === 'string');
     return {

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

@@ -18,14 +18,14 @@ async function handleErrorWithoutErrorPage(pageContext) {
         warnMissingErrorPage(isV1);
     }
     if (!pageContext.isClientSideNavigation) {
-        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)();
+        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }
     else {
         const __getPageAssets = async () => [];
         (0, utils_js_1.objectAssign)(pageContext, { __getPageAssets });
-        const httpResponse = await (0, createHttpResponse_js_1.createHttpResponse)((0, stringify_1.stringify)({ serverSideError: true }), null, pageContext);
+        const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePage)((0, stringify_1.stringify)({ serverSideError: true }), null, pageContext);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }

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

@@ -58,7 +58,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     const renderHookResult = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
     const { htmlRender, renderHook } = renderHookResult;
-    const httpResponse = await (0, createHttpResponse_js_1.createHttpResponse)(htmlRender, renderHook, pageContext);
+    const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePage)(htmlRender, renderHook, pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
     return pageContext;
 }

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

@@ -56,7 +56,7 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
     const handleInvalidConfig = (err) => {
         (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
         return pageContextWithError;
     };
     if (isConfigInvalid_js_1.isConfigInvalid) {
@@ -76,7 +76,7 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
         return pageContextWithError;
     }
     if (isConfigInvalid_js_1.isConfigInvalid) {
@@ -182,7 +182,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit);
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
                     return pageContextHttpWithError;
                 }
                 // `throw redirect()` / `throw render(url)`
@@ -191,7 +191,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
                 (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit);
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
             return pageContextWithError;
         }
         return pageContextErrorPage;
@@ -242,9 +242,12 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
-function getPageContextHttpResponseError(err, pageContextInit) {
+function prettyUrl(url) {
+    return picocolors_1.default.bold(decodeURI(url));
+}
+function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     const pageContextWithError = createPageContext(pageContextInit);
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)();
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
     (0, utils_js_1.objectAssign)(pageContextWithError, {
         httpResponse,
         errorWhileRendering: err
@@ -284,6 +287,7 @@ async function renderPageNominal(pageContext) {
         }
     }
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'));
+    (0, utils_js_1.assert)(pageContext.errorWhileRendering === null);
     // Render
     const pageContextAfterRender = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContext);
     (0, utils_js_1.assert)(pageContext === pageContextAfterRender);
@@ -446,8 +450,5 @@ function assertBaseUrl(pageContextInit) {
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     const { hasBaseServer } = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, baseServer);
-    (0, utils_js_1.assertUsage)(hasBaseServer, `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which doesn't start with Base URL ${prettyUrl(baseServer)} (https://vike.dev/base-url)`);
-}
-function prettyUrl(url) {
-    return picocolors_1.default.code(decodeURI(url));
+    (0, utils_js_1.assertUsage)(hasBaseServer, `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which doesn't start with Base URL ${picocolors_1.default.code(baseServer)} (https://vike.dev/base-url)`);
 }

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

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

package/dist/cjs/shared/route/executeOnBeforeRouteHook.js

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

package/dist/cjs/utils/PROJECT_VERSION.js

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

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

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

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

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

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

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

package/dist/esm/node/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/createHttpResponse.d.ts

@@ -1,4 +1,4 @@
-export { createHttpResponse };
+export { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
 export { createHttpResponseRedirect };
@@ -11,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][];
@@ -18,7 +19,7 @@ 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 createHttpResponse(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
+declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
     _pageId: null | string;
     is404: null | boolean;
     errorWhileRendering: null | Error;
@@ -27,6 +28,9 @@ declare function createHttpResponse(htmlRender: HtmlRender, renderHook: null | R
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse>;
 declare function createHttpResponseFavicon404(): HttpResponse;
-declare function createHttpResponseError(): HttpResponse;
+declare function createHttpResponseError(pageContext: null | {
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+}): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
 declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;

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

@@ -1,15 +1,15 @@
-export { createHttpResponse };
+export { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
 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 createHttpResponse(htmlRender, renderHook, pageContext) {
+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);
@@ -32,18 +32,30 @@ async function createHttpResponse(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 = getHttpResponse(404, 'text/html;charset=utf-8', [], "<p>No favicon.ico found.</p><script>console.log('This HTTP response was generated by Vike.')</script>");
+    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() {
-    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>");
+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 createHttpResponseRedirect({ url, statusCode }, 
@@ -54,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><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/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 { createHttpResponse, createHttpResponseError } from './createHttpResponse.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,14 +13,14 @@ async function handleErrorWithoutErrorPage(pageContext) {
         warnMissingErrorPage(isV1);
     }
     if (!pageContext.isClientSideNavigation) {
-        const httpResponse = createHttpResponseError();
+        const httpResponse = createHttpResponseError(pageContext);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponse(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/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 { createHttpResponse, createHttpResponsePageContextJson } from './createHttpResponse.js';
+import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
 import { loadUserFilesServerSide } from './loadUserFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
 import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
@@ -57,7 +57,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     const renderHookResult = await executeOnRenderHtmlHook(pageContext);
     const { htmlRender, renderHook } = renderHookResult;
-    const httpResponse = await createHttpResponse(htmlRender, renderHook, pageContext);
+    const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
     objectAssign(pageContext, { httpResponse });
     return pageContext;
 }

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

@@ -50,7 +50,7 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
     const handleInvalidConfig = (err) => {
         logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
         return pageContextWithError;
     };
     if (isConfigInvalid) {
@@ -70,7 +70,7 @@ 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 pageContextWithError = getPageContextHttpResponseError(err, pageContextInit);
+        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
         return pageContextWithError;
     }
     if (isConfigInvalid) {
@@ -176,7 +176,7 @@ 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 pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit);
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
                     return pageContextHttpWithError;
                 }
                 // `throw redirect()` / `throw render(url)`
@@ -185,7 +185,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if (isNewError(errErrorPage, errNominalPage)) {
                 logRuntimeError(errErrorPage, httpRequestId);
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit);
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
             return pageContextWithError;
         }
         return pageContextErrorPage;
@@ -236,9 +236,12 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     }
     logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
-function getPageContextHttpResponseError(err, pageContextInit) {
+function prettyUrl(url) {
+    return pc.bold(decodeURI(url));
+}
+function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     const pageContextWithError = createPageContext(pageContextInit);
-    const httpResponse = createHttpResponseError();
+    const httpResponse = createHttpResponseError(pageContext);
     objectAssign(pageContextWithError, {
         httpResponse,
         errorWhileRendering: err
@@ -278,6 +281,7 @@ async function renderPageNominal(pageContext) {
         }
     }
     assert(hasProp(pageContext, '_pageId', 'string'));
+    assert(pageContext.errorWhileRendering === null);
     // Render
     const pageContextAfterRender = await renderPageAlreadyRouted(pageContext);
     assert(pageContext === pageContextAfterRender);
@@ -440,8 +444,5 @@ function assertBaseUrl(pageContextInit) {
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
-    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.code(decodeURI(url));
+    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 ${pc.code(baseServer)} (https://vike.dev/base-url)`);
 }

package/dist/esm/shared/getPageFiles/analyzeClientSide.d.ts

@@ -2,6 +2,6 @@ export { analyzeClientSide };
 import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
 declare function analyzeClientSide(pageConfig: PageConfigRuntime | null, pageFilesAll: PageFile[], pageId: string): {
-    clientEntryLoaded: boolean;
+    isClientRuntimeLoaded: boolean;
     isClientRouting: boolean;
 };

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

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

package/dist/esm/shared/page-configs/Config.d.ts

@@ -41,7 +41,7 @@ type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
 type HookNameOldDesign = 'render' | 'prerender';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'clientEntryLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
 /** Hook for fetching data.
  *
@@ -358,7 +358,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/injectScriptsAt
      */
-    injectScriptsAt?: 'HTML_BEGIN' | 'HTML_END' | 'STREAM' | null;
+    injectScriptsAt?: 'HTML_BEGIN' | 'HTML_END' | 'HTML_STREAM' | null;
     /** Used by Vike extensions to set their name.
      *
      * https://vike.dev/extends

package/dist/esm/shared/route/executeOnBeforeRouteHook.js

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

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.194";
+export declare const PROJECT_VERSION: "0.4.195-commit-486b49a";

package/dist/esm/utils/PROJECT_VERSION.js

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

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

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.194";
+    projectVersion: "0.4.195-commit-486b49a";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.194",
+  "version": "0.4.195-commit-486b49a",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -123,7 +123,7 @@
   "dependencies": {
     "@brillout/import": "^0.2.3",
     "@brillout/json-serializer": "^0.5.13",
-    "@brillout/picocolors": "^1.0.14",
+    "@brillout/picocolors": "^1.0.15",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-server-entry": "^0.4.11",
     "acorn": "^8.0.0",
@@ -225,11 +225,12 @@
   ],
   "devDependencies": {
     "@biomejs/biome": "^1.5.3",
-    "@brillout/release-me": "^0.4.0",
+    "@brillout/release-me": "^0.4.2",
     "@types/estree": "^1.0.5",
     "@types/jest": "^29.5.11",
     "@types/node": "^20.10.5",
     "@types/resolve": "^1.20.6",
+    "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
     "acorn": "^8.11.2",
     "cac": "^6.7.14",
@@ -255,4 +256,4 @@
     "release:minor": "release-me minor",
     "release:commit": "release-me commit"
   }
-}
+}