vike 0.4.223 → 0.4.224-commit-00ed9fe

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

@@ -23,7 +23,6 @@ import type { ResolvedConfig, ViteDevServer } from 'vite';
 import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 import { type BaseUrlsResolved } from '../shared/resolveBase.js';
-type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages' | 'baseAssets' | 'baseServer'>;
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
 type GlobalContextInternal = GlobalContext & {
     globalContext_public: GlobalContextPublic;
@@ -57,6 +56,8 @@ declare function getGlobalContextInternal(): Promise<GlobalContextInternal>;
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
+type GlobalContextPublic = ReturnType<typeof makePublic>;
+declare function makePublic(globalContext: GlobalContext): Pick<GlobalContext, "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): Promise<void>;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
 declare function setGlobalContext_isPrerendering(): void;
@@ -74,7 +75,7 @@ declare function getUserFiles(): Promise<{
     pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     pages: PageConfigsUserFriendly;
-    config: import("../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+    config: import("../../types/index.js").ConfigResolved;
 }>;
 declare function setGlobalContext_buildEntry(buildEntry: unknown): Promise<void>;
 type BuildInfo = {

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

@@ -159,6 +159,13 @@ function getStreamReadableWeb(htmlRender) {
     if (isStreamReadableWeb(htmlRender)) {
         return htmlRender;
     }
+    if (isStreamPipeWeb(htmlRender)) {
+        const streamPipeWeb = getStreamPipeWeb(htmlRender);
+        assert(streamPipeWeb);
+        const { readable, writable } = new TransformStream();
+        streamPipeWeb(writable);
+        return readable;
+    }
     return null;
 }
 function pipeToStreamWritableWeb(htmlRender, writable) {

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

@@ -1,2 +1,4 @@
 export { assertNoInfiniteHttpRedirect };
-declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, urlLogical: string): void;
+declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, pageContextInit: {
+    urlOriginal: string;
+}): void;

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

@@ -1,23 +1,31 @@
 export { assertNoInfiniteHttpRedirect };
-import { assert, assertUsage, getGlobalObject } from '../../utils.js';
+import { assert, assertUsage, getGlobalObject, removeUrlOrigin } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+// It's too strict, see https://github.com/vikejs/vike/issues/1270#issuecomment-1820608999
+// - Let's create a new setting `+doNotCatchInfiniteRedirect` if someone complains.
+function assertNoInfiniteHttpRedirect(
+// The exact URL that the user will be redirected to.
+// - It includes the Base URL as well as the locale (i18n) base.
+urlRedirectTarget, 
+// Rationale for checking against `pageContextInit.urlOriginal`: https://github.com/vikejs/vike/pull/2264#issuecomment-2713890263
+pageContextInit) {
     if (!urlRedirectTarget.startsWith('/')) {
-        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (at least not in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin; we hope/assume the user sets the URL without origin.
         //    ```js
         //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    assert(urlLogical.startsWith('/'));
+    const urlOriginalNormalized = removeUrlOrigin(pageContextInit.urlOriginal).urlModified;
+    assert(urlOriginalNormalized.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
     graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
-    graph[urlRedirectTarget].add(urlLogical);
+    graph[urlRedirectTarget].add(urlOriginalNormalized);
     validate(graph);
     globalObject.redirectGraph = graph;
 }

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

@@ -35,4 +35,6 @@ declare function createHttpResponseError(pageContext: null | {
     _pageConfigs: PageConfigRuntime[];
 }): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: {
+    urlOriginal: string;
+}): HttpResponse;

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

@@ -82,10 +82,8 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
     const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
-function createHttpResponseRedirect({ url, statusCode }, 
-// The URL we assume the redirect to be logically based on
-urlLogical) {
-    assertNoInfiniteHttpRedirect(url, urlLogical);
+function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
+    assertNoInfiniteHttpRedirect(url, pageContextInit);
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);

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

@@ -23,15 +23,25 @@ const errorsMisc = [
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext',
         mustMentionNodeModules: false
+    },
+    {
+        errMsg: 'ERR_UNKNOWN_FILE_EXTENSION',
+        link: 'https://vike.dev/broken-npm-package#err-unknown-file-extension'
     }
 ];
+const reactInvalidEelement = 'https://vike.dev/broken-npm-package#react-invalid-component';
 const errorsReact = [
     {
         errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
-        link: 'https://vike.dev/broken-npm-package#react-invalid-component',
+        link: reactInvalidEelement,
         // The stack trace can be user-land while the import is coming from node_modules
         mustMentionNodeModules: false
     },
+    {
+        errMsg: 'Objects are not valid as a React child',
+        link: reactInvalidEelement,
+        mustMentionNodeModules: false
+    },
     {
         // React's "Invalid hook call.", see https://github.com/vikejs/vike/discussions/1637#discussioncomment-9424712
         errMsg: "Cannot read properties of null (reading 'useContext')"
@@ -67,7 +77,8 @@ const errorsCjsEsm = [
     { errMsg: 'exports is not defined' },
     { errMsg: 'module is not defined' },
     { errMsg: 'not defined in ES' },
-    { errMsg: "Unexpected token 'export'" }
+    { errMsg: "Unexpected token 'export'" },
+    { errMsg: 'Failed to resolve entry for package' }
 ];
 function logErrorHint(error) {
     /* Collect errors for ./logErrorHint.spec.ts

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

@@ -48,7 +48,39 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         _globalContext: GlobalContextInternal;
         /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: import("../globalContext.js").GlobalContextPublic;
+        globalContext: Pick<{
+            viteConfigRuntime: {
+                _baseViteOriginal: null | string;
+            };
+            config: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        } & import("../../shared/resolveBase.js").BaseUrlsResolved & ({
+            pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+            pageConfigs: import("../../../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+            allPageIds: string[];
+            pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+            config: import("../../../types/index.js").ConfigResolved;
+        } & ({
+            isProduction: false;
+            isPrerendering: false;
+            viteConfig: import("vite").ResolvedConfig;
+            viteDevServer: import("vite").ViteDevServer;
+            assetsManifest: null;
+        } | ({
+            isProduction: true;
+            assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+            viteDevServer: null;
+        } & ({
+            isPrerendering: false;
+            viteConfig: null;
+        } | {
+            isPrerendering: true;
+            usesClientRouter: boolean;
+            viteConfig: import("vite").ResolvedConfig;
+        })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -102,7 +134,39 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         _globalContext: GlobalContextInternal;
         /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: import("../globalContext.js").GlobalContextPublic;
+        globalContext: Pick<{
+            viteConfigRuntime: {
+                _baseViteOriginal: null | string;
+            };
+            config: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        } & import("../../shared/resolveBase.js").BaseUrlsResolved & ({
+            pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+            pageConfigs: import("../../../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+            allPageIds: string[];
+            pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+            config: import("../../../types/index.js").ConfigResolved;
+        } & ({
+            isProduction: false;
+            isPrerendering: false;
+            viteConfig: import("vite").ResolvedConfig;
+            viteDevServer: import("vite").ViteDevServer;
+            assetsManifest: null;
+        } | ({
+            isProduction: true;
+            assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+            viteDevServer: null;
+        } & ({
+            isPrerendering: false;
+            viteConfig: null;
+        } | {
+            isPrerendering: true;
+            usesClientRouter: boolean;
+            viteConfig: import("vite").ResolvedConfig;
+        })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -157,7 +221,39 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         _globalContext: GlobalContextInternal;
         /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: import("../globalContext.js").GlobalContextPublic;
+        globalContext: Pick<{
+            viteConfigRuntime: {
+                _baseViteOriginal: null | string;
+            };
+            config: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        } & import("../../shared/resolveBase.js").BaseUrlsResolved & ({
+            pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+            pageConfigs: import("../../../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+            allPageIds: string[];
+            pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+            config: import("../../../types/index.js").ConfigResolved;
+        } & ({
+            isProduction: false;
+            isPrerendering: false;
+            viteConfig: import("vite").ResolvedConfig;
+            viteDevServer: import("vite").ViteDevServer;
+            assetsManifest: null;
+        } | ({
+            isProduction: true;
+            assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+            viteDevServer: null;
+        } & ({
+            isPrerendering: false;
+            viteConfig: null;
+        } | {
+            isPrerendering: true;
+            usesClientRouter: boolean;
+            viteConfig: import("vite").ResolvedConfig;
+        })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -211,7 +307,39 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         _globalContext: GlobalContextInternal;
         /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: import("../globalContext.js").GlobalContextPublic;
+        globalContext: Pick<{
+            viteConfigRuntime: {
+                _baseViteOriginal: null | string;
+            };
+            config: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        } & import("../../shared/resolveBase.js").BaseUrlsResolved & ({
+            pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+            pageConfigs: import("../../../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+            allPageIds: string[];
+            pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+            pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+            config: import("../../../types/index.js").ConfigResolved;
+        } & ({
+            isProduction: false;
+            isPrerendering: false;
+            viteConfig: import("vite").ResolvedConfig;
+            viteDevServer: import("vite").ViteDevServer;
+            assetsManifest: null;
+        } | ({
+            isProduction: true;
+            assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+            viteDevServer: null;
+        } & ({
+            isPrerendering: false;
+            viteConfig: null;
+        } | {
+            isPrerendering: true;
+            usesClientRouter: boolean;
+            viteConfig: import("vite").ResolvedConfig;
+        })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -274,7 +402,39 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
     _globalContext: GlobalContextInternal;
     /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-    globalContext: import("../globalContext.js").GlobalContextPublic;
+    globalContext: Pick<{
+        viteConfigRuntime: {
+            _baseViteOriginal: null | string;
+        };
+        config: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & import("../../shared/resolveBase.js").BaseUrlsResolved & ({
+        pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        pageConfigs: import("../../../__internal/index.js").PageConfig[];
+        pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        allPageIds: string[];
+        pageRoutes: import("../../../__internal/index.js").PageRoutes;
+        onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        config: import("../../../types/index.js").ConfigResolved;
+    } & ({
+        isProduction: false;
+        isPrerendering: false;
+        viteConfig: import("vite").ResolvedConfig;
+        viteDevServer: import("vite").ViteDevServer;
+        assetsManifest: null;
+    } | ({
+        isProduction: true;
+        assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+        viteDevServer: null;
+    } & ({
+        isPrerendering: false;
+        viteConfig: null;
+    } | {
+        isPrerendering: true;
+        usesClientRouter: boolean;
+        viteConfig: import("vite").ResolvedConfig;
+    })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
     _pageContextInit: {
         urlOriginal: string;
         headersOriginal?: unknown;

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addAsyncHookwrapper };
 import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -341,7 +341,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
+    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -383,7 +383,7 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
+    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContextInit);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -391,7 +391,9 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
 function normalize(url) {
     return url || '/';
 }
-async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
+async function handleAbortError(errAbort, pageContextsFromRewrite, 
+// The original `pageContextInit` object passed to `renderPage(pageContextInit)`
+pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
 pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
     logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
@@ -429,13 +431,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
     if (pageContextAbort._urlRedirect) {
         const pageContextReturn = createPageContext(pageContextInit);
         objectAssign(pageContextReturn, pageContextAbort);
-        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, (() => {
-            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
-            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
-            // The server-side doesn't have access to the hash
-            null);
-            return urlLogical;
-        })());
+        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextInit);
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -37,7 +37,7 @@ function getUrlParsed(pageContext) {
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
     // Determine logical URL
-    const assertUrlResolved = (src) => assert(urlResolved && typeof urlResolved === 'string', 
+    const assertUrlResolved = (src) => assert(typeof urlResolved === 'string', 
     // TODO/eventually: remove debug logs, see:
     // - https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
     // - https://github.com/vikejs/vike/commit/5c7810f3080ab62536950f26e019bb2a3a517082

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

@@ -296,6 +296,14 @@ type ConfigBuiltIn = {
          * @default false
          */
         disableAutoRun?: boolean;
+        /**
+         * Set prerender settings without enabling pre-rendering.
+         *
+         * https://vike.dev/prerender#value
+         *
+         * @default true
+         */
+        value?: boolean | null;
     };
     /**
      * Install Vike extensions.
@@ -422,10 +430,12 @@ type ConfigBuiltIn = {
     includeAssetsImportedByServer?: boolean;
     /** @deprecated See https://vike.dev/disableAutoFullBuild */
     disableAutoFullBuild?: boolean | 'prerender';
-    /** Use Vite Environment API to orchestrate the build process.
+    /**
+     * Use builder.buildApp() to orchestrate the build process.
+     *
      * @experimental
      */
-    viteEnvironmentAPI?: boolean;
+    vite6BuilderApp?: boolean;
     /** The Base URL of your server.
      *
      * https://vike.dev/base-url

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

@@ -22,7 +22,7 @@ import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js'
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-import type { PlusFile, PlusFilesByLocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
+import type { PlusFile } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
 type PageConfigCommon = {
     pageId: string;
 } & PageConfigRoute;
@@ -49,7 +49,7 @@ type PageConfigGlobalRuntime = {
 /** Page config, build-time data structure */
 type PageConfigBuildTime = PageConfigCommon & {
     configDefinitions: ConfigDefinitions;
-    plusFiles: PlusFilesByLocationId;
+    plusFiles: PlusFile[];
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
 };
@@ -92,12 +92,12 @@ type ConfigValueSource = {
     definedAtFilePath: DefinedAtFilePath;
     plusFile: PlusFile | null;
     locationId: LocationId;
-    isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
-    valueIsImportedAtRuntime: boolean;
+    valueIsLoadedWithImport: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
-    valueIsDefinedByPlusFile: boolean;
+    /** Whether the config value is defined by a +{configName}.js file */
+    valueIsDefinedByPlusValueFile: boolean;
 } & ({
     valueIsLoaded: false;
 } | {

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

@@ -27,9 +27,7 @@ function getConfigValue(pageConfig, configName) {
     if (!configDef.cumulative) {
         const configValueSource = sources[0];
         assert(configValueSource);
-        assert(configValueSource.isOverriden === false);
-        assert(sources.slice(1).every((s) => s.isOverriden === true));
-        assert('value' in configValueSource);
+        assert(configValueSource.valueIsLoaded);
         return {
             type: 'standard',
             value: configValueSource.value,
@@ -50,9 +48,8 @@ function mergeCumulative(configValueSources) {
     const value = [];
     const definedAtData = [];
     configValueSources.forEach((configValueSource) => {
-        assert(configValueSource.isOverriden === false);
         assert(configValueSource.configEnv.config === true);
-        assert('value' in configValueSource);
+        assert(configValueSource.valueIsLoaded);
         value.push(configValueSource.value);
         definedAtData.push(getDefinedAtFile(configValueSource));
     });

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.js

@@ -64,7 +64,9 @@ function parseConfigValuesSerialized_tmp(configValuesSerialized) {
             const { valueSerialized, ...common } = configValueSeriliazed;
             const { value, sideExports } = parseValueSerialized(valueSerialized, configName, () => {
                 assert(configValueSeriliazed.type !== 'computed');
-                return configValueSeriliazed.definedAtData;
+                const { definedAtData } = configValueSeriliazed;
+                const definedAtFile = Array.isArray(definedAtData) ? definedAtData[0] : definedAtData;
+                return definedAtFile;
             });
             addSideExports(sideExports);
             configValue = { value, ...common };

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -1,8 +1,10 @@
 export { serializeConfigValues };
 export { getConfigValuesBase };
+export { isJsonValue };
 export type { FilesEnv };
 import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
 declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
+declare function isJsonValue(value: unknown): boolean;
 declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
 type ConfigValuesBase = ({
     configValueBase: {

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -1,11 +1,14 @@
 export { serializeConfigValues };
 export { getConfigValuesBase };
+export { isJsonValue };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
+import { isOverriden } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+const stringifyOptions = { forbidReactElements: true };
 const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
 const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
@@ -42,9 +45,8 @@ function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatc
     return lines;
 }
 function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
-    assert(configValueSource.isOverriden === false);
     let valueData;
-    if ('value' in configValueSource) {
+    if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
         valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {
@@ -96,14 +98,13 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
 }
 function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     assert(!configValueSource.valueIsFilePath);
-    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath, configEnv } = configValueSource;
-    assert(valueIsImportedAtRuntime);
+    const { valueIsDefinedByPlusValueFile, definedAtFilePath, configEnv } = configValueSource;
     const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
-    if (valueIsDefinedByPlusFile)
+    if (valueIsDefinedByPlusValueFile)
         assert(fileExportName === undefined);
     const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
     return {
-        type: valueIsDefinedByPlusFile ? 'plus-file' : 'pointer-import',
+        type: valueIsDefinedByPlusValueFile ? 'plus-file' : 'pointer-import',
         valueAsJsCode: importName
     };
 }
@@ -120,7 +121,7 @@ function valueToJson(value, configName, definedAtData, importStatements, filesEn
     try {
         configValueSerialized = stringify(value, {
             valueName,
-            forbidReactElements: true,
+            ...stringifyOptions,
             // Replace import strings with import variables.
             // - We don't need this anymore and could remove it.
             //   - We temporarily needed it for nested document configs (`config.document.{title,description,favicon}`), but we finally decided to go for flat document configs instead (`config.{title,description,favicon}`).
@@ -147,6 +148,15 @@ function valueToJson(value, configName, definedAtData, importStatements, filesEn
     assert(!configValueSerialized.includes(REPLACE_ME_AFTER));
     return configValueSerialized;
 }
+function isJsonValue(value) {
+    try {
+        stringify(value, stringifyOptions);
+    }
+    catch (err) {
+        return false;
+    }
+    return true;
+}
 function logJsonSerializeError(err, configName, definedAtData) {
     /*
     // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
@@ -186,7 +196,6 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
         if (!configDef.cumulative) {
             const source = sources[0];
             assert(source);
-            assert(sources.slice(1).every((s) => s.isOverriden === true));
             if (!isEnvMatch(source.configEnv))
                 return 'SKIP';
             const definedAtFile = getDefinedAtFileSource(source);
@@ -197,7 +206,9 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
             return { configValueBase, sourceRelevant: source, configName };
         }
         else {
-            const sourcesRelevant = sources.filter((source) => !source.isOverriden && isEnvMatch(source.configEnv));
+            const sourcesRelevant = sources
+                .filter((source) => !isOverriden(source, configName, pageConfig))
+                .filter((source) => isEnvMatch(source.configEnv));
             if (sourcesRelevant.length === 0)
                 return 'SKIP';
             const definedAtData = [];

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

@@ -8,9 +8,11 @@ export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
 export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, KeepScrollPosition } from '../shared/page-configs/Config.js';
+export type { ConfigResolved } from '../shared/page-configs/Config/PageContextConfig.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/page-configs/getPageConfigUserFriendly.js';
+export type { VikeConfigPublic as VikeConfig } from '../node/plugin/plugins/commonConfig.js';
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.223";
+export declare const PROJECT_VERSION: "0.4.224-commit-00ed9fe";