vike 0.4.237-commit-92dc549 → 0.4.237-commit-2d6f480

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -1,7 +1,9 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveDistFile, } from '../../utils.js';
+export { pluginAutoFullBuild };
+export { isPrerenderForceExit };
+import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveDistFile, assertWarning, getGlobalObject, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
@@ -9,13 +11,21 @@ import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { isViteServerSide_withoutEnv } from '../../shared/isViteServerSide.js';
-import { resolveOutDir_configEnvironment } from '../../shared/getOutDirs.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
+import { isViteServerSide_withoutEnv, isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
+import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
+import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
+import pc from '@brillout/picocolors';
+import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
+import { isVikeCliOrApi } from '../../../api/context.js';
+import { runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
+const globalObject = getGlobalObject('build/pluginAutoFullBuild.ts', {
+    forceExit: false,
+});
 function pluginBuildConfig() {
     let config;
-    let configUnresolved;
     return [
         {
             name: 'vike:build:pluginBuildConfig',
@@ -34,21 +44,9 @@ function pluginBuildConfig() {
                     handleAssetsManifest_assertUsageCssCodeSplit(config);
                 },
             },
-            configEnvironment: {
-                order: 'post',
-                async handler(envName, configEnv) {
-                    assert(configUnresolved);
-                    return {
-                        build: {
-                            outDir: resolveOutDir_configEnvironment(configUnresolved, envName, configEnv),
-                        },
-                    };
-                },
-            },
             config: {
                 order: 'post',
                 async handler(config) {
-                    configUnresolved = config;
                     onSetupBuild();
                     const build = await handleAssetsManifest_getBuildConfig(config);
                     return { build };
@@ -230,3 +228,108 @@ function assertRollupInput(config) {
     const htmlInput = htmlInputs[0];
     assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }
+function pluginAutoFullBuild() {
+    let config;
+    return [
+        {
+            name: 'vike:build:pluginAutoFullBuild',
+            apply: 'build',
+            enforce: 'pre',
+            async configResolved(config_) {
+                config = config_;
+                await abortViteBuildSsr();
+            },
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(options, bundle) {
+                    try {
+                        await handleAssetsManifest(config, this.environment, options, bundle);
+                        await triggerPrerendering(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        logErrorHint(err);
+                        process.exit(1);
+                    }
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginAutoFullBuild:post',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    onSetupBuild();
+                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
+                    /* Let vike:build:pluginBuildApp force exit
+                    runPrerender_forceExit()
+                    */
+                },
+            },
+        },
+    ];
+}
+async function triggerPrerendering(config, viteEnv, bundle) {
+    const vikeConfig = await getVikeConfigInternal();
+    if (!isViteServerSide_onlySsrEnv(config, viteEnv))
+        return;
+    if (isDisabled(vikeConfig))
+        return;
+    // Workaround for @vitejs/plugin-legacy
+    //  - The legacy plugin triggers its own Rollup build for the client-side.
+    //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
+    //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
+    if (!bundle[getManifestFilePathRelative(config.build.manifest)])
+        return;
+    const configInline = getFullBuildInlineConfig(config);
+    if (isPrerenderAutoRunEnabled(vikeConfig)) {
+        const res = await runPrerenderFromAutoRun(configInline);
+        globalObject.forceExit = res.forceExit;
+        assert(wasPrerenderRun());
+    }
+}
+async function abortViteBuildSsr() {
+    const vikeConfig = await getVikeConfigInternal();
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+        assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
+        process.exit(0);
+    }
+}
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isUserUsingViteApi;
+    }
+    else {
+        return disableAutoFullBuild;
+    }
+}
+function isPrerenderForceExit() {
+    return globalObject.forceExit;
+}
+function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build,
+            },
+        };
+    }
+}

package/dist/esm/node/vite/plugins/pluginBuild.js

@@ -3,9 +3,8 @@ import { pluginBuildApp } from './pluginBuild/pluginBuildApp.js';
 import { pluginDistPackageJsonFile } from './pluginBuild/pluginDistPackageJsonFile.js';
 import { pluginSuppressRollupWarning } from './pluginBuild/pluginSuppressRollupWarning.js';
 import { pluginDistFileNames } from './pluginBuild/pluginDistFileNames.js';
-import { pluginAutoFullBuild } from './pluginBuild/pluginAutoFullBuild.js';
 import { pluginBuildEntry } from './pluginBuild/pluginBuildEntry.js';
-import { pluginBuildConfig } from './pluginBuild/pluginBuildConfig.js';
+import { pluginBuildConfig, pluginAutoFullBuild } from './pluginBuild/pluginBuildConfig.js';
 import { pluginModuleBanner } from './pluginBuild/pluginModuleBanner.js';
 function pluginBuild() {
     return [

package/dist/esm/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -13,8 +13,9 @@ async function determineOptimizeDeps(config) {
     const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
     config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
     config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
-    // Workaround until https://github.com/vitejs/vite-plugin-react/issues/650
-    // - TODO/soon: remove workaround once https://github.com/vitejs/vite/pull/20495 is released
+    // Workaround for https://github.com/vitejs/vite-plugin-react/issues/650
+    // - The issue was closed as completed with https://github.com/vitejs/vite/pull/20495 but it doesn't fix the issue and the workaround is still needed.
+    // - TO-DO/eventually: try removing the workaround and see if the CI fails (at test/@cloudflare_vite-plugin/) — maybe the issue will get fixed at some point.
     includeServer.push('react/jsx-dev-runtime');
     for (const envName in config.environments) {
         const env = config.environments[envName];

package/dist/esm/node/vite/plugins/pluginFileEnv.js

@@ -7,6 +7,7 @@ import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
+import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 function pluginFileEnv() {
     let config;
     let viteDevServer;
@@ -28,7 +29,7 @@ function pluginFileEnv() {
             const importers = Array.from(moduleInfo.importers)
                 .map((m) => m.id)
                 .filter((id) => id !== null);
-            assertFileEnv(id, !!options?.ssr, importers, 
+            assertFileEnv(id, isViteServerSide_extraSafe(config, options, this.environment), importers, 
             // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
             true);
         },
@@ -40,7 +41,7 @@ function pluginFileEnv() {
                 return;
             if (skip(id))
                 return;
-            const isServerSide = !!options?.ssr;
+            const isServerSide = isViteServerSide_extraSafe(config, options, this.environment);
             if (!isWrongEnv(id, isServerSide))
                 return;
             const { importers } = this.getModuleInfo(id);
@@ -66,7 +67,7 @@ function pluginFileEnv() {
                     */
                     return;
                 }
-                assertFileEnv(moduleId, !!config.build.ssr, importers, false);
+                assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
             });
         },
         configResolved(config_) {

package/dist/esm/node/vite/plugins/pluginPreview.js

@@ -1,34 +1,24 @@
 export { pluginPreview };
-import { assertUsage, applyPreview, assert } from '../utils.js';
+import { assertUsage, applyPreview } from '../utils.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
 import { logDockerHint } from './pluginDev.js';
-import { getOutDirs, resolveOutDir_configEnvironment } from '../shared/getOutDirs.js';
+import { getOutDirs } from '../shared/getOutDirs.js';
 import sirv from 'sirv';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
     let config;
-    let configUnresolved;
     let vikeConfig;
     return {
         name: 'vike:pluginPreview',
         apply: applyPreview,
-        config(config) {
-            configUnresolved = config;
+        config() {
             return {
                 appType: 'custom',
             };
         },
-        configEnvironment(envName, configEnv) {
-            assert(configUnresolved);
-            return {
-                build: {
-                    outDir: resolveOutDir_configEnvironment(configUnresolved, envName, configEnv),
-                },
-            };
-        },
         async configResolved(config_) {
             config = config_;
             vikeConfig = await getVikeConfigInternal();

package/dist/esm/node/vite/shared/getOutDirs.d.ts

@@ -1,8 +1,7 @@
 export { getOutDirs };
 export { resolveOutDir };
-export { resolveOutDir_configEnvironment };
 export type { OutDirs };
-import type { UserConfig, ResolvedConfig, EnvironmentOptions } from 'vite';
+import type { UserConfig, ResolvedConfig } from 'vite';
 import { ViteEnv } from './isViteServerSide.js';
 type OutDirs = {
     /** Absolute path to `outDir` */
@@ -13,6 +12,5 @@ type OutDirs = {
     outDirServer: string;
 };
 declare function getOutDirs(configGlobal: ResolvedConfig, viteEnv: ViteEnv | undefined): OutDirs;
-declare function resolveOutDir_configEnvironment(configGlobal: UserConfig, envName: string, configEnv: EnvironmentOptions): string;
 /** Appends `client/` or `server/` to `config.build.outDir` */
 declare function resolveOutDir(config: UserConfig, isServerSide: boolean): string;

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -1,13 +1,12 @@
 export { getOutDirs };
 export { resolveOutDir };
-export { resolveOutDir_configEnvironment };
 import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { isViteServerSide, isViteServerSide_withoutEnv } from './isViteServerSide.js';
+import { isViteServerSide_withoutEnv } from './isViteServerSide.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(configGlobal, viteEnv) {
     debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromResolvedConfig(configGlobal);
+    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
     assertOutDirResolved(outDir, configGlobal, viteEnv);
     const outDirs = getOutDirsAll(outDir, configGlobal.root);
     assertNormalization(outDirs.outDirRoot);
@@ -15,12 +14,6 @@ function getOutDirs(configGlobal, viteEnv) {
     assertNormalization(outDirs.outDirServer);
     return outDirs;
 }
-function resolveOutDir_configEnvironment(configGlobal, envName, configEnv) {
-    assert(configGlobal && envName && configEnv);
-    const viteEnv = { name: envName, config: configEnv };
-    const isServerSide = isViteServerSide(configGlobal, viteEnv);
-    return resolveOutDir(configEnv, isServerSide);
-}
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config, isServerSide) {
     debug('resolveOutDir()', new Error().stack);
@@ -114,7 +107,8 @@ function assertOutDirResolved(outDir, configGlobal, viteEnv) {
     assert('/client'.length === '/server'.length);
     const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
     const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    if (isViteServerSide_withoutEnv(configGlobal, viteEnv)) {
+    const isServerSide = isViteServerSide_withoutEnv(configGlobal, viteEnv);
+    if (isServerSide) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {
@@ -128,8 +122,8 @@ function getOutDirFromViteUserConfig(config) {
     outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function getOutDirFromResolvedConfig(config) {
-    let outDir = config.build.outDir;
+function getOutDirFromResolvedConfig(config, viteEnv) {
+    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
     assert(outDir);
     outDir = normalizeOutDir(outDir);
     return outDir;

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -9,8 +9,8 @@ type ViteEnv = {
     name?: string;
     config: EnvironmentOptions | Environment['config'];
 };
-declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv): boolean;
 declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
 declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_extraSafe(config: ResolvedConfig, options: {

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -4,16 +4,16 @@ export { isViteServerSide_withoutEnv };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
 import { assert } from '../../../utils/assert.js';
-function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
+function isViteServerSide_impl(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
     const isServerSide1 = !viteEnv?.config.consumer ? null : viteEnv.config.consumer !== 'client';
-    const isServerSide2 = !viteEnv?.name ? null : viteEnv.name !== 'client'; // I can't think of a use case for creating another client-side environment
-    const isServerSide3 = !viteEnv ? null : !!viteEnv.config.build?.ssr;
-    const isServerSide4 = !!configGlobal.build?.ssr;
+    const isServerSide2 = !viteEnv?.config.build ? null : getBuildSsrValue(viteEnv.config.build.ssr);
+    const isServerSide3 = !configGlobal.build ? null : getBuildSsrValue(configGlobal.build.ssr);
+    const isServerSide4 = viteEnv?.name === 'ssr' ? true : viteEnv?.name === 'client' ? false : null;
     const debug = {
-        envIsUndefined: !viteEnv,
-        envName: viteEnv?.name ?? null,
-        envConsumer: viteEnv?.config.consumer ?? null,
+        viteEnvIsUndefined: !viteEnv,
+        viteEnvName: viteEnv?.name ?? null,
+        viteEnvConsumer: viteEnv?.config.consumer ?? null,
         configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
         configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
         isServerSide1,
@@ -22,25 +22,36 @@ function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
         isServerSide4,
     };
     if (isServerSide1 !== null) {
-        assert(isServerSide1 === isServerSide2 || isServerSide2 === null, debug);
+        // assert(isServerSide1 === isServerSide4 || isServerSide4 === null, debug)
         /* This assertion can fail, seems to be a Vite bug?
-        assert(isServerSide1 === isServerSide3, debug)
+        assert(isServerSide1 === isServerSide2, debug)
         */
         return isServerSide1;
     }
     if (isServerSide2 !== null) {
-        /* This assertion can fail, seems to be a Vite bug?
-        assert(isServerSide2 === isServerSide3, debug)
-        */
+        // assert(isServerSide2 === isServerSide4 || isServerSide4 === null, debug)
         return isServerSide2;
     }
     if (isServerSide3 !== null) {
+        // assert(isServerSide3 === isServerSide4 || isServerSide4 === null, debug)
         return isServerSide3;
     }
-    return isServerSide4;
+    if (isServerSide4 !== null) {
+        return isServerSide4;
+    }
+    assert(!viteEnv);
+    return !!configGlobal.build?.ssr;
+}
+function getBuildSsrValue(buildSsr) {
+    if (buildSsr === undefined)
+        return null;
+    return !!buildSsr;
 }
 function isViteServerSide(configGlobal, viteEnv) {
-    return isViteServerSide_withoutEnv(configGlobal, viteEnv);
+    return isViteServerSide_impl(configGlobal, viteEnv);
+}
+function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
+    return isViteServerSide_impl(configGlobal, viteEnv);
 }
 function isViteClientSide(configGlobal, viteEnv) {
     return !isViteServerSide(configGlobal, viteEnv);
@@ -51,20 +62,36 @@ function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
 }
 // Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
 function isViteServerSide_extraSafe(config, options, viteEnv) {
+    const isServerSide = isViteServerSide(config, viteEnv);
+    const debug = {
+        configCommand: config.command,
+        configBuildSsr: config.build.ssr,
+        optionsIsUndefined: options === undefined,
+        optionsSsr: options?.ssr,
+        isServerSide,
+    };
+    if (true) {
+        const res = options?.ssr;
+        if (typeof res === 'boolean') {
+            assert(res === isServerSide, debug);
+            return res;
+        }
+        return isServerSide;
+    }
     if (config.command === 'build') {
         const res = config.build.ssr;
-        assert(typeof res === 'boolean');
-        assert(res === options?.ssr || options?.ssr === undefined);
-        assert(res === isViteServerSide(config, viteEnv));
+        assert(typeof res === 'boolean', debug);
+        assert(res === options?.ssr || options?.ssr === undefined, debug);
+        assert(res === isServerSide, debug);
         return res;
     }
     else {
         const res = options?.ssr;
-        assert(typeof res === 'boolean');
+        assert(typeof res === 'boolean', debug);
         /* This assertion can fail, seems to be a Vite bug? It's very unexpected.
         if (typeof config.build.ssr === 'boolean') assert(res === config.build.ssr)
         */
-        assert(res === isViteServerSide(config, viteEnv));
+        assert(res === isServerSide, debug);
         return res;
     }
 }

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

@@ -0,0 +1,3 @@
+export { loadAndParseVirtualFilePageEntry };
+import type { PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
+declare function loadAndParseVirtualFilePageEntry(pageConfig: PageConfigRuntime, isDev: boolean): Promise<PageConfigRuntimeLoaded>;

package/dist/esm/shared/page-configs/{loadPageEntry.js → loadAndParseVirtualFilePageEntry.js}

@@ -1,7 +1,7 @@
-export { loadPageEntry };
+export { loadAndParseVirtualFilePageEntry };
 import { assert, objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
-async function loadPageEntry(pageConfig, isDev) {
+async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
     if ('isPageEntryLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
         !isDev) {

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

@@ -1,3 +1,8 @@
+// TO-DO/soon: rename PageConfig names
+// - Use `Internal` suffix, i.e. {Page,Global}ConfigInternal
+//   - While keeping {Page,Global}ConfigPublic or remove Public suffix and rename it to {Page,Global}Config ?
+// - rename EagerLoaded EagerlyLoaded
+// - remove `LazyLoaded` suffix
 // TO-DO/soon/same-api: use public API internally?
 // TO-DO/soon/flat-pageContext: rename definedAt => definedBy
 export { resolveVikeConfigPublicGlobal };

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

@@ -1,7 +1,7 @@
 export { execHookOnBeforeRoute };
-import type { PageContextForRoute, PageContextFromRoute } from './index.js';
-declare function execHookOnBeforeRoute(pageContext: PageContextForRoute): Promise<null | ({
+import type { PageContextBeforeRoute, PageContextAfterRoute } from './index.js';
+declare function execHookOnBeforeRoute(pageContext: PageContextBeforeRoute): Promise<null | ({
     _routingProvidedByOnBeforeRouteHook: true;
-} & PageContextFromRoute) | {
+} & PageContextAfterRoute) | {
     _routingProvidedByOnBeforeRouteHook: false;
 }>;

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

@@ -23,7 +23,6 @@ async function execHookOnBeforeRoute(pageContext) {
             }
             objectAssign(pageContextFromOnBeforeRouteHook, {
                 _routingProvidedByOnBeforeRouteHook: true,
-                _debugRouteMatches: 'CUSTOM_ROUTING',
             });
             return pageContextFromOnBeforeRouteHook;
         }

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

@@ -1,19 +1,18 @@
 export { route };
-export type { PageContextForRoute };
-export type { PageContextFromRoute };
+export type { PageContextBeforeRoute };
+export type { PageContextAfterRoute };
 export type { PageRoutes };
 export type { RouteMatches };
 import { type PageContextUrlInternal, type PageContextUrlSource } from '../getPageContextUrlComputed.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
 import type { GlobalContextInternal } from '../createGlobalContextShared.js';
-type PageContextForRoute = PageContextUrlInternal & {
+type PageContextBeforeRoute = PageContextUrlInternal & {
     _globalContext: GlobalContextInternal;
 } & PageContextUrlSource;
-type PageContextFromRoute = {
+type PageContextAfterRoute = {
     pageId: string | null;
     routeParams: Record<string, string>;
     _routingProvidedByOnBeforeRouteHook?: boolean;
-    _debugRouteMatches: RouteMatches;
 };
 type RouteMatch = {
     pageId: string;
@@ -23,4 +22,4 @@ type RouteMatch = {
     routeParams: Record<string, string>;
 };
 type RouteMatches = 'CUSTOM_ROUTING' | RouteMatch[];
-declare function route(pageContext: PageContextForRoute, skipOnBeforeRouteHook?: true): Promise<PageContextFromRoute>;
+declare function route(pageContext: PageContextBeforeRoute, skipOnBeforeRouteHook?: true): Promise<PageContextAfterRoute>;

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

@@ -81,7 +81,6 @@ async function route(pageContext, skipOnBeforeRouteHook) {
     resolvePrecedence(routeMatches);
     const winner = routeMatches[0] ?? null;
     debug(`Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
-    objectAssign(pageContextFromRoute, { _debugRouteMatches: routeMatches });
     // For vite-plugin-vercel https://github.com/magne4000/vite-plugin-vercel/blob/main/packages/vike-integration/vike.ts#L173
     objectAssign(pageContextFromRoute, { _routeMatch: winner });
     if (!winner) {

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

@@ -404,11 +404,9 @@ type ConfigBuiltIn = {
     /** @deprecated See https://vike.dev/disableAutoFullBuild */
     disableAutoFullBuild?: boolean | 'prerender';
     /**
-     * Use builder.buildApp() to orchestrate the build process.
-     *
-     * @experimental
+     * @deprecated It's value is now always true.
      */
-    vite6BuilderApp?: boolean;
+    vite6BuilderApp?: true;
     /** The Base URL of your server.
      *
      * https://vike.dev/base-url

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.237-commit-92dc549";
+export declare const PROJECT_VERSION: "0.4.237-commit-2d6f480";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.237-commit-92dc549';
+export const PROJECT_VERSION = '0.4.237-commit-2d6f480';

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

@@ -0,0 +1,3 @@
+export { updateType };
+/** Help TypeScript update the type of dynamically modified objects. */
+declare function updateType<Thing, Clone>(thing: Thing, clone: Clone): asserts thing is Thing & Clone;

package/dist/esm/utils/updateType.js

@@ -0,0 +1,7 @@
+export { updateType };
+import { assert } from './assert.js';
+/** Help TypeScript update the type of dynamically modified objects. */
+function updateType(thing, clone) {
+    // @ts-ignore
+    assert(thing === clone);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.237-commit-92dc549",
+  "version": "0.4.237-commit-2d6f480",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -132,7 +132,7 @@
     "@brillout/json-serializer": "^0.5.20",
     "@brillout/picocolors": "^1.0.26",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.7.12",
+    "@brillout/vite-plugin-server-entry": "^0.7.13",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
@@ -263,7 +263,7 @@
     "react-streaming": "^0.4.3",
     "rimraf": "^5.0.5",
     "typescript": "^5.8.3",
-    "vite": "^7.0.6"
+    "vite": "^7.1.3"
   },
   "scripts": {
     "dev": "tsc --watch",