vike 0.4.224 → 0.4.225

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

@@ -23,6 +23,9 @@ import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
 import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase, isJsonValue } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
+import { getEnvVarObject } from '../../../shared/getEnvVarObject.js';
+import { getApiOperation } from '../../../../api/context.js';
+import { getCliOptions } from '../../../../cli/context.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -145,6 +148,8 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
+    // TODO/now: add validation
+    setCliAndApiOptions(pageConfigGlobal);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
     const global = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues });
@@ -203,13 +208,13 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
     objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, 
         // We use `plusFilesAll` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
-        Object.values(plusFilesAll).flat(), userRootDir, true);
+        Object.values(plusFilesAll).flat(), userRootDir, true, plusFilesAll);
         if (sources.length === 0)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
     });
     applyEffectsMetaEnv(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal);
-    applyEffectsConfVal(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal);
+    applyEffectsConfVal(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal, plusFilesAll);
     sortConfigValueSources(pageConfigGlobal.configValueSources, null);
     assertPageConfigGlobal(pageConfigGlobal, plusFilesAll);
     const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
@@ -220,14 +225,14 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
         objectEntries(configDefinitionsLocal)
             .filter(([_configName, configDef]) => configDef.global !== true)
             .forEach(([configName, configDef]) => {
-            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false);
+            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false, plusFilesAll);
             if (sources.length === 0)
                 return;
             configValueSources[configName] = sources;
         });
         const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsMetaEnv(configValueSources, configDefinitionsLocal);
-        applyEffectsConfVal(configValueSources, configDefinitionsLocal);
+        applyEffectsConfVal(configValueSources, configDefinitionsLocal, plusFilesAll);
         sortConfigValueSources(configValueSources, locationId);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
@@ -352,6 +357,7 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
         assert(includes(objectKeys(configDefinitionsBuiltIn), configName));
         const configDef = configDefinitionsBuiltIn[configName];
         const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+        // TODO/now: use getSourceNonConfigFile()
         sources.push({
             valueIsLoaded: true,
             value,
@@ -370,6 +376,49 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
         });
     });
 }
+function setCliAndApiOptions(pageConfigGlobal) {
+    // VIKE_CONFIG
+    const configFromEnv = getEnvVarObject('VIKE_CONFIG');
+    if (configFromEnv) {
+        add(configFromEnv, { definedBy: 'env' });
+    }
+    // Vike API — passed options
+    const apiOperation = getApiOperation();
+    if (apiOperation?.options.vikeConfig) {
+        add(apiOperation.options.vikeConfig, {
+            definedBy: 'api',
+            operation: apiOperation.operation
+        });
+    }
+    // Vike CLI options
+    const cliOptions = getCliOptions();
+    if (cliOptions) {
+        add(cliOptions, { definedBy: 'cli' });
+    }
+    return;
+    function add(configValues, definedBy) {
+        Object.entries(configValues).forEach(([configName, value]) => {
+            var _a;
+            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+            sources.unshift(getSourceNonConfigFile(configName, value, definedBy));
+        });
+    }
+}
+function getSourceNonConfigFile(configName, value, definedAt) {
+    assert(includes(objectKeys(configDefinitionsBuiltIn), configName));
+    const configDef = configDefinitionsBuiltIn[configName];
+    const source = {
+        valueIsLoaded: true,
+        value,
+        configEnv: configDef.env,
+        definedAtFilePath: definedAt,
+        locationId: '/',
+        plusFile: null,
+        valueIsLoadedWithImport: false,
+        valueIsDefinedByPlusValueFile: false
+    };
+    return source;
+}
 function sortConfigValueSources(configValueSources, locationIdPage) {
     Object.entries(configValueSources).forEach(([configName, sources]) => {
         sources
@@ -456,7 +505,7 @@ function sortPlusFilesSameLocationId(plusFile1, plusFile2, configName) {
     // No need to make it deterministic: the overall order is arleady deterministic, see sortMakeDeterministic() at getPlusFilesAll()
     return 0;
 }
-function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal) {
+function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal, plusFilesAll) {
     let sources = plusFilesRelevant
         .filter((plusFile) => isDefiningConfig(plusFile, configName))
         .map((plusFile) => getConfigValueSource(configName, plusFile, configDef, userRootDir));
@@ -471,7 +520,7 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
         sources = sources.filter((source) => {
             assert(source.configEnv.config);
             assert(source.valueIsLoaded);
-            const valueIsGlobal = resolveIsGlobalValue(configDef.global, source.value);
+            const valueIsGlobal = resolveIsGlobalValue(configDef.global, source, plusFilesAll);
             return isGlobal ? valueIsGlobal : !valueIsGlobal;
         });
     }
@@ -595,10 +644,13 @@ function isDefiningPage(plusFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function resolveIsGlobalValue(configDefGlobal, configValue) {
+function resolveIsGlobalValue(configDefGlobal, source, plusFilesAll) {
+    assert(source.valueIsLoaded);
     let isGlobal;
     if (isCallable(configDefGlobal))
-        isGlobal = configDefGlobal(configValue);
+        isGlobal = configDefGlobal(source.value, {
+            isGlobalLocation: isGlobalLocation(source.locationId, plusFilesAll)
+        });
     else
         isGlobal = configDefGlobal ?? false;
     assert(typeof isGlobal === 'boolean');
@@ -688,7 +740,7 @@ function assertMetaUsage(metaVal, metaConfigDefinedAt) {
     });
 }
 // Test: https://github.com/vikejs/vike/blob/441a37c4c1a3b07bb8f6efb1d1f7be297a53974a/test/playground/vite.config.ts#L39
-function applyEffectsConfVal(configValueSources, configDefinitions) {
+function applyEffectsConfVal(configValueSources, configDefinitions, plusFilesAll) {
     objectEntries(configDefinitions).forEach(([configNameEffect, configDefEffect]) => {
         const sourceEffect = configValueSources[configNameEffect]?.[0];
         if (!sourceEffect)
@@ -696,8 +748,8 @@ function applyEffectsConfVal(configValueSources, configDefinitions) {
         const effect = runEffect(configNameEffect, configDefEffect, sourceEffect);
         if (!effect)
             return;
-        const { configModFromEffect, configValueEffectSource } = effect;
-        applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, configValueEffectSource);
+        const configModFromEffect = effect;
+        applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, plusFilesAll);
     });
 }
 // Test: https://github.com/vikejs/vike/blob/441a37c4c1a3b07bb8f6efb1d1f7be297a53974a/test/playground/pages/config-meta/effect/e2e-test.ts#L16
@@ -709,7 +761,7 @@ function applyEffectsMetaEnv(configValueSources, configDefinitions) {
         const effect = runEffect(configNameEffect, configDefEffect, sourceEffect);
         if (!effect)
             return;
-        const { configModFromEffect } = effect;
+        const configModFromEffect = effect;
         applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEffect);
     });
 }
@@ -721,17 +773,16 @@ function runEffect(configName, configDef, source) {
         `Cannot add meta.effect to ${pc.cyan(configName)} because its meta.env is ${pc.cyan(JSON.stringify(configDef.env))} but an effect can only be added to a config that has a meta.env with ${pc.cyan('{ config: true }')}.`
     ].join(' '));
     assert(source.valueIsLoaded);
-    const configValueEffectSource = source.value;
     // Call effect
     const configModFromEffect = configDef.effect({
-        configValue: configValueEffectSource,
+        configValue: source.value,
         configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAtFilePath)
     });
     if (!configModFromEffect)
         return null;
-    return { configModFromEffect, configValueEffectSource };
+    return configModFromEffect;
 }
-function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, configValueEffectSource) {
+function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, plusFilesAll) {
     objectEntries(configModFromEffect).forEach(([configNameTarget, configValue]) => {
         if (configNameTarget === 'meta')
             return;
@@ -748,11 +799,12 @@ function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSource
             valueIsLoaded: true,
             value: configValue
         };
-        const isValueGlobalSource = resolveIsGlobalValue(configDefEffect.global, configValueEffectSource);
-        const isValueGlobalTarget = resolveIsGlobalValue(configDef.global, configValue);
+        assert(sourceEffect.valueIsLoaded);
+        const isValueGlobalSource = resolveIsGlobalValue(configDefEffect.global, sourceEffect, plusFilesAll);
+        const isValueGlobalTarget = resolveIsGlobalValue(configDef.global, configValueSource, plusFilesAll);
         const isGlobalHumanReadable = (isGlobal) => `${isGlobal ? 'non-' : ''}global`;
         // The error message make it sound like it's an inherent limitation, it actually isn't (both ways can make senses).
-        assertUsage(isValueGlobalSource === isValueGlobalTarget, `The configuration ${pc.cyan(configNameEffect)} is set to ${pc.cyan(JSON.stringify(configValueEffectSource))} which is considered ${isGlobalHumanReadable(isValueGlobalSource)}. However, it has a meta.effect that sets the configuration ${pc.cyan(configNameTarget)} to ${pc.cyan(JSON.stringify(configValue))} which is considered ${isGlobalHumanReadable(isValueGlobalTarget)}. This is contradictory: make sure the values are either both non-global or both global.`);
+        assertUsage(isValueGlobalSource === isValueGlobalTarget, `The configuration ${pc.cyan(configNameEffect)} is set to ${pc.cyan(JSON.stringify(sourceEffect.value))} which is considered ${isGlobalHumanReadable(isValueGlobalSource)}. However, it has a meta.effect that sets the configuration ${pc.cyan(configNameTarget)} to ${pc.cyan(JSON.stringify(configValue))} which is considered ${isGlobalHumanReadable(isValueGlobalTarget)}. This is contradictory: make sure the values are either both non-global or both global.`);
         configValueSources[configNameTarget] ?? (configValueSources[configNameTarget] = []);
         configValueSources[configNameTarget].push(configValueSource);
     });
@@ -889,7 +941,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     assert(filesystemRouteString.startsWith('/'));
     const routeFilesystem = {
         routeString: filesystemRouteString,
-        definedBy: filesystemRouteDefinedBy
+        definedAtLocation: filesystemRouteDefinedBy
     };
     return { routeFilesystem, isErrorPage: undefined };
 }
@@ -901,7 +953,9 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     const configDefinedAt = getConfigDefinedAt('Config', configName, configFilesystemRoutingRoot.definedAtFilePath);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAtFilePath;
+    const { definedAtFilePath } = configFilesystemRoutingRoot;
+    assert(!definedAtFilePath.definedBy);
+    const { filePathAbsoluteUserRootDir } = definedAtFilePath;
     assert(filePathAbsoluteUserRootDir);
     const before = getFilesystemRouteString(getLocationId(filePathAbsoluteUserRootDir));
     const after = value;

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -6,6 +6,8 @@ import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
 import { logDockerHint } from './devConfig/index.js';
 import { getOutDirs, resolveOutDir } from '../shared/getOutDirs.js';
+import sirv from 'sirv';
+import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
 function previewConfig() {
     let config;
     // let vikeConfig: VikeConfigObject
@@ -32,23 +34,26 @@ function previewConfig() {
             */
             return () => {
                 assertDist();
-                /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
-                if (!vikeConfig.global.config.prerender || vikeConfig.global.config.prerender.partial) {
-                  addSsrMiddleware(server.middlewares, config, true)
+                // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
+                addStaticAssetsMiddleware(server.middlewares);
+                const prerenderConfigGlobal = resolvePrerenderConfigGlobal(config._vikeConfigObject);
+                if (!prerenderConfigGlobal.isPrerenderingEnabledForAllPages) {
+                    addSsrMiddleware(server.middlewares, config, true, prerenderConfigGlobal.isPrerenderingEnabled);
                 }
-                /*/
-                addSsrMiddleware(server.middlewares, config, true);
-                //*/
                 addStatic404Middleware(server.middlewares);
             };
         }
     };
     function assertDist() {
-        let { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
+        const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
         [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
             assertUsage(fs.existsSync(outDirAny), `Cannot run ${pc.cyan('$ vike preview')}: your app isn't built (the build directory ${pc.cyan(outDirAny)} is missing). Make sure to run ${pc.cyan('$ vike build')} before running ${pc.cyan('$ vike preview')}.`);
         });
     }
+    function addStaticAssetsMiddleware(middlewares) {
+        const { outDirClient } = getOutDirs(config);
+        middlewares.use(sirv(outDirClient));
+    }
     function addStatic404Middleware(middlewares) {
         const { outDirClient } = getOutDirs(config);
         middlewares.use(config.base, (_, res, next) => {

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

@@ -1,4 +1,4 @@
 export { addSsrMiddleware };
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 type ConnectServer = ViteDevServer['middlewares'];
-declare function addSsrMiddleware(middlewares: ConnectServer, config: ResolvedConfig, isPreview: boolean): void;
+declare function addSsrMiddleware(middlewares: ConnectServer, config: ResolvedConfig, isPreview: boolean, isPrerenderingEnabled: boolean | null): void;

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

@@ -2,7 +2,7 @@ export { addSsrMiddleware };
 import { renderPage } from '../../runtime/renderPage.js';
 import { assertWarning } from '../utils.js';
 import pc from '@brillout/picocolors';
-function addSsrMiddleware(middlewares, config, isPreview) {
+function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
             return next();
@@ -37,6 +37,10 @@ function addSsrMiddleware(middlewares, config, isPreview) {
             // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
             return next();
         }
+        if (pageContext.httpResponse.statusCode === 404 && isPreview && isPrerenderingEnabled) {
+            // Serve /dist/client/404.html instead
+            return next();
+        }
         const configHeaders = (isPreview && config?.preview?.headers) || config?.server?.headers;
         if (configHeaders) {
             for (const [name, value] of Object.entries(configHeaders))

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

@@ -1,2 +1,4 @@
 export { getEnvVarObject };
-declare function getEnvVarObject(envVarName: 'VITE_CONFIG' | 'VIKE_CRAWL'): null | Record<string, unknown>;
+export { parseJson5 };
+declare function getEnvVarObject(envVarName: 'VITE_CONFIG' | 'VIKE_CRAWL' | 'VIKE_CONFIG'): null | Record<string, unknown>;
+declare function parseJson5(valueStr: string, what: string): unknown;

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

@@ -1,24 +1,25 @@
 export { getEnvVarObject };
+export { parseJson5 };
 import pc from '@brillout/picocolors';
 import { assertUsage, isObject } from '../utils.js';
 import JSON5 from 'json5';
-function getEnvVarObject(envVarName
-/* Let's eventually implement this for Vike's config as well
-| 'VIKE_CONFIG'
-*/
-) {
+function getEnvVarObject(envVarName) {
     const valueStr = process.env[envVarName];
     if (!valueStr)
         return null;
+    const value = parseJson5(valueStr, envVarName);
+    assertUsage(value, `${envVarName} should define an object but it's ${pc.bold(String(value))} instead.`);
+    assertUsage(isObject(value), `${envVarName} should define an object but it's set to the following which isn't an object: ${pc.bold(valueStr)}`);
+    return value;
+}
+function parseJson5(valueStr, what) {
     let value;
     try {
         value = JSON5.parse(valueStr);
     }
     catch (err) {
         console.error(err);
-        assertUsage(false, `Cannot parse ${envVarName} (see error above) because it's set to the following which isn't a valid JSON5 string: ${pc.bold(valueStr)}`);
+        assertUsage(false, `Cannot parse ${pc.cyan(what)} (see error above) because it's set to the following which isn't a valid JSON5 string: ${pc.bold(valueStr)}`);
     }
-    assertUsage(value, `${envVarName} should define an object but it's ${pc.bold(String(value))} instead.`);
-    assertUsage(isObject(value), `${envVarName} should define an object but it's set to the following which isn't an object: ${pc.bold(valueStr)}`);
     return value;
 }

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

@@ -2,7 +2,7 @@ export { logWithViteTag };
 export { logWithVikeTag };
 export { logDirectly };
 export { applyViteSourceMapToStackTrace };
-import { assert, projectInfo, stripAnsi, hasProp, assertIsNotProductionRuntime } from '../../utils.js';
+import { assert, stripAnsi, hasProp, assertIsNotProductionRuntime, PROJECT_VERSION } from '../../utils.js';
 import pc from '@brillout/picocolors';
 import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { getViteDevServer } from '../../../runtime/globalContext.js';
@@ -15,7 +15,7 @@ function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
 function getProjectTag(showVikeVersion) {
     let projectTag;
     if (showVikeVersion) {
-        projectTag = `[vike@${projectInfo.projectVersion}]`;
+        projectTag = `[vike@${PROJECT_VERSION}]`;
     }
     else {
         projectTag = `[vike]`;

package/dist/esm/node/prerender/context.js

@@ -7,7 +7,7 @@ import { resolvePrerenderConfigGlobal } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
 function isPrerenderAutoRunEnabled(vikeConfig) {
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
-    return (prerenderConfigGlobal.isEnabled &&
+    return (prerenderConfigGlobal.isPrerenderingEnabled &&
         !(prerenderConfigGlobal || {}).disableAutoRun &&
         !globalObject.isDisabled &&
         vikeConfig.global.config.disableAutoFullBuild !== 'prerender');

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -9,7 +9,8 @@ declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
     disableAutoRun: boolean;
 } & {
     defaultLocalValue: boolean;
-    isEnabled: boolean;
+    isPrerenderingEnabledForAllPages: boolean;
+    isPrerenderingEnabled: boolean;
 };
 declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): {
     value: boolean;

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -1,29 +1,43 @@
 export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import { assert, isArray, objectAssign } from './utils.js';
+import { assert, isArray, isObject, objectAssign } from './utils.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
+// When setting +prerender to an object => it also enables pre-rendering
+const defaultValueForObject = true;
 function resolvePrerenderConfigGlobal(vikeConfig) {
-    const prerenderConfigs = vikeConfig.global.config.prerender;
-    let prerenderConfigList = prerenderConfigs || [];
-    // Needed because of backwards compatibility of `vike({prerender:true})` in `vite.config.js`; after we remove it we can remove this line.
-    prerenderConfigList = prerenderConfigList.filter(isObject2);
-    assert(prerenderConfigList.every(isObject2)); // Help TS
+    const prerenderConfigs = vikeConfig.global.config.prerender || [];
+    const prerenderSettings = prerenderConfigs.filter(isObject2);
     const prerenderConfigGlobal = {
-        partial: pickFirst(prerenderConfigList.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(prerenderConfigList.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(prerenderConfigList.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(prerenderConfigList.map((c) => c.disableAutoRun)) ?? false
+        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
     };
-    const prerenderConfigGlobalLocalValue = prerenderConfigList.map((c) => c.value).filter((v) => v !== null);
-    const defaultLocalValue = pickFirst(prerenderConfigGlobalLocalValue) ??
-        (prerenderConfigGlobalLocalValue.length > 0 ||
-            // Backwards compatibility for with vike({ prerender: true }) in vite.config.js
-            prerenderConfigs?.some((p) => p === true) ||
-            false);
+    let defaultLocalValue = false;
+    {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.value !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.value ?? defaultValueForObject))) {
+            defaultLocalValue = true;
+        }
+    }
+    // TODO/next-major: remove
+    // Backwards compatibility for `vike({prerender:true})` in vite.config.js
+    {
+        const valuesWithDefinedAt = vikeConfig.global._from.configsCumulative.prerender?.values ?? [];
+        if (valuesWithDefinedAt.some((v) => v.definedAt.includes('vite.config.js') && v.value)) {
+            defaultLocalValue = true;
+        }
+    }
     objectAssign(prerenderConfigGlobal, {
         defaultLocalValue,
-        isEnabled: defaultLocalValue || vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)
+        isPrerenderingEnabledForAllPages: vikeConfig.pageConfigs.length > 0 &&
+            vikeConfig.pageConfigs.every((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue),
+        isPrerenderingEnabled: vikeConfig.pageConfigs.length > 0 &&
+            vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue)
     });
+    // TODO/next-major remove
+    if (vikeConfig.pageConfigs.length === 0 && defaultLocalValue)
+        prerenderConfigGlobal.isPrerenderingEnabled = true;
     return prerenderConfigGlobal;
 }
 function resolvePrerenderConfigLocal(pageConfig) {
@@ -33,13 +47,14 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const values = configValue.value;
     assert(isArray(values));
     const value = values[0];
+    // TODO/now I believe this assert() can fail
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
     const prerenderConfigLocal = { value };
     return prerenderConfigLocal;
 }
-function isObject2(p) {
-    return typeof p === 'object' && p !== null;
+function isObject2(value) {
+    return typeof value === 'object' && value !== null;
 }
 function pickFirst(arr) {
     return arr.filter((v) => v !== undefined)[0];

package/dist/esm/node/prerender/runPrerender.js

@@ -4,7 +4,7 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy, PROJECT_VERSION } from './utils.js';
 import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -38,7 +38,7 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareViteApiCall(undefined, 'prerender');
+        const { viteConfigEnhanced } = await prepareViteApiCall({}, 'prerender');
         await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
@@ -75,7 +75,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
-        console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
+        console.log(`${pc.cyan(`vike v${PROJECT_VERSION}`)} ${pc.green('pre-rendering HTML...')}`);
     }
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
@@ -84,13 +84,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
     validatePrerenderConfig(prerenderConfigGlobal);
-    const { partial, noExtraDir, parallel, defaultLocalValue, isEnabled } = prerenderConfigGlobal;
-    if (!isEnabled) {
+    const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
+    if (!isPrerenderingEnabled) {
         assert(standaloneTrigger);
-        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs whenever possible
-        assertWarning(prerenderConfigGlobal, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the config ${pc.cyan('prerender')} (${pc.underline('https://vike.dev/prerender')}) to enable it.`, {
-            onlyOnce: true
-        });
+        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs if pre-rendering is completely disabled
+        assertWarning(false, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${pc.cyan('prerender')} setting (${pc.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`, { onlyOnce: true });
     }
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();

package/dist/esm/node/prerender/utils.d.ts

@@ -1,6 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/hasProp.js';
-export * from '../../utils/projectInfo.js';
+export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';

package/dist/esm/node/prerender/utils.js

@@ -2,7 +2,7 @@ import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/hasProp.js';
-export * from '../../utils/projectInfo.js';
+export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';

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

@@ -75,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/globalContext.js

@@ -25,7 +25,7 @@ export { updateUserFiles };
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
 //   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, projectInfo, checkType } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, checkType, PROJECT_VERSION } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
 import pc from '@brillout/picocolors';
@@ -89,9 +89,10 @@ function makePublic(globalContext) {
 async function setGlobalContext_viteDevServer(viteDevServer) {
     debug('setGlobalContext_viteDevServer()');
     setIsProduction(false);
-    if (globalObject.viteDevServer)
-        return;
-    assertIsNotInitilizedYet();
+    /* We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
+    if (globalObject.viteDevServer) return
+    assertIsNotInitilizedYet()
+    */
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     await updateUserFiles();
@@ -351,7 +352,7 @@ function assertBuildInfo(buildInfo) {
     checkType({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
 function assertVersionAtBuildTime(versionAtBuildTime) {
-    const versionAtRuntime = projectInfo.projectVersion;
+    const versionAtRuntime = PROJECT_VERSION;
     const pretty = (version) => pc.bold(`vike@${version}`);
     assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
@@ -369,7 +370,7 @@ async function updateUserFiles() {
     const { promise, resolve } = genPromise();
     assert(!globalObject.isProduction);
     globalObject.waitForUserFilesUpdate = promise;
-    const viteDevServer = getViteDevServer();
+    const { viteDevServer } = globalObject;
     assert(viteDevServer);
     let virtualFileExports;
     try {
@@ -381,6 +382,9 @@ async function updateUserFiles() {
     }
     virtualFileExports = virtualFileExports.default || virtualFileExports;
     debugGlob('Glob result: ', virtualFileExports);
+    // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
+    if (viteDevServer !== globalObject.viteDevServer)
+        return;
     await setUserFiles(virtualFileExports);
     resolve();
 }

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/index-deprecated.d.ts

@@ -13,6 +13,4 @@ import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js
  *
  * See https://vike.dev/render
  */
-export declare const RenderErrorPage: (args_0?: {
-    pageContext?: Record<string, unknown>;
-} | undefined) => Error;
+export declare const RenderErrorPage: (...args: Parameters<typeof RenderErrorPage_>) => Error;

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;