vike 0.4.160 → 0.4.161-commit-0e9c635

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

@@ -2,7 +2,8 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys } from '../../../utils.js';
+export { isV1Design };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
@@ -17,8 +18,9 @@ import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
-import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileConfigEnv.js';
+import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
+import { resolveFilePathRelativeToUserRootDir } from './getVikeConfig/resolveFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -69,6 +71,12 @@ async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, exten
     }
     return await vikeConfigPromise;
 }
+async function isV1Design(config, isDev) {
+    const vikeConfig = await getVikeConfig(config, isDev);
+    const { pageConfigs } = vikeConfig;
+    const isV1Design = pageConfigs.length > 0;
+    return isV1Design;
+}
 async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
     const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, extensions);
     const configFiles = [];
@@ -82,69 +90,77 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         }
     });
     let interfaceFilesByLocationId = {};
-    // Config files
-    await Promise.all(configFiles.map(async (filePath) => {
-        const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
-        const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
-        const locationId = getLocationId(filePath.filePathAbsoluteVite);
-        interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-        interfaceFilesByLocationId[locationId].push(interfaceFile);
-        extendsConfigs.forEach((extendsConfig) => {
-            const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true);
-            interfaceFilesByLocationId[locationId].push(interfaceFile);
-        });
-    }));
-    // Value files
-    await Promise.all(valueFiles.map(async (filePath) => {
-        const configName = getConfigName(filePath.filePathAbsoluteVite);
-        assert(configName);
-        const interfaceFile = {
-            filePath,
-            fileExportsByConfigName: {
-                [configName]: {}
-            },
-            isConfigFile: false,
-            isValueFile: true,
-            configName
-        };
-        {
-            // We don't have access to the custom config definitions defined by the user yet.
-            //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
-            //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
-            if (configDef && isConfigEnv(configDef, configName)) {
-                await loadValueFile(interfaceFile, configName, userRootDir);
-            }
-        }
-        {
-            const locationId = getLocationId(filePath.filePathAbsoluteVite);
+    await Promise.all([
+        // Config files
+        ...configFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            assert(filePathRelativeToUserRootDir);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
+            assert(filePath.filePathRelativeToUserRootDir);
+            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[locationId].push(interfaceFile);
-        }
-    }));
+            extendsConfigs.forEach((extendsConfig) => {
+                /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
+                ```js
+                // /pages/admin/+config.h.js
+        
+                import vikeVue from 'vike-vue/config'
+                // Should only apply to /pages/admin/**
+                export default { extends: [vikeVue] }
+                ```
+                ```js
+                // /pages/marketing/+config.h.js
+        
+                import vikeReact from 'vike-react/config'
+                // Should only apply to /pages/marketing/**
+                export default { extends: [vikeReact] }
+                ```
+                */
+                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
+                interfaceFilesByLocationId[locationId].push(interfaceFile);
+            });
+        }),
+        // Value files
+        ...valueFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            assert(filePathRelativeToUserRootDir);
+            const configName = getConfigName(filePathRelativeToUserRootDir);
+            assert(configName);
+            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const interfaceFile = {
+                locationId,
+                filePath,
+                fileExportsByConfigName: {
+                    [configName]: {}
+                },
+                isConfigFile: false,
+                isValueFile: true,
+                configName
+            };
+            {
+                // We don't have access to the custom config definitions defined by the user yet.
+                //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
+                //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
+                const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
+                if (configDef && isConfigEnv(configDef, configName)) {
+                    await loadValueFile(interfaceFile, configName, userRootDir);
+                }
+            }
+            {
+                interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
+                interfaceFilesByLocationId[locationId].push(interfaceFile);
+            }
+        })
+    ]);
     assertAllConfigsAreKnown(interfaceFilesByLocationId);
     return interfaceFilesByLocationId;
 }
-function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
-    const configDef = configDefinitionsRelevant[configName];
-    assertConfigExists(configName, Object.keys(configDefinitionsRelevant), filePathToShowToUser);
-    assert(configDef);
-    return configDef;
-}
-function getConfigDefinitionOptional(configDefinitions, configName) {
-    return configDefinitions[configName] ?? null;
-}
-function isConfigEnv(configDef, configName) {
-    const configEnv = configDef.env;
-    if (configDef.cumulative) {
-        // In principle we could lift that requirement (but it requires non-trivial modifications)
-        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
-    }
-    return !!configEnv.config;
-}
-function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
+function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
+        locationId,
         filePath,
         fileExportsByConfigName: {},
         isConfigFile: true,
@@ -160,12 +176,12 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
 }
 /** Show error message upon unknown config */
 function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+    objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
             Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
+                assertConfigExists(configName, Object.keys(configDefinitions), interfaceFile.filePath.filePathToShowToUser);
             });
         });
     });
@@ -215,11 +231,11 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
-    const pageConfigs = await Promise.all(Object.entries(interfaceFilesByLocationId)
+    const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         // Load value files of custom config-only configs
         await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
@@ -227,7 +243,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             const { configName } = interfaceFile;
             if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, interfaceFile.filePath.filePathToShowToUser);
+            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
             if (!isConfigEnv(configDef, configName))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
@@ -237,8 +253,8 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             assert(!(configName in configDefinitionsBuiltIn));
             await loadValueFile(interfaceFile, configName, userRootDir);
         }));
-        const configValueSources = {};
-        await Promise.all(objectEntries(configDefinitionsRelevant)
+        let configValueSources = {};
+        await Promise.all(objectEntries(configDefinitions)
             .filter(([configName]) => !isGlobalConfig(configName))
             .map(async ([configName, configDef]) => {
             const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
@@ -246,10 +262,11 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
                 return;
             configValueSources[configName] = sources;
         }));
+        configValueSources = sortConfigValueSources(configValueSources, locationId);
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitionsRelevant);
-        const configValuesComputed = getComputed(configValueSources, configDefinitionsRelevant);
-        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant);
+        applyEffectsAll(configValueSources, configDefinitions);
+        const configValuesComputed = getComputed(configValueSources, configDefinitions);
+        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitions);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
@@ -286,7 +303,7 @@ function interfacefileIsAlreaydLoaded(interfaceFile) {
     return isAlreadyLoaded;
 }
 function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(Object.entries(interfaceFilesByLocationId)
+    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesByLocationId)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
@@ -301,14 +318,14 @@ function getInterfaceFileList(interfaceFilesByLocationId) {
     return interfaceFiles;
 }
 async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const locationIds = Object.keys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = Object.fromEntries(Object.entries(interfaceFilesByLocationId).filter(([locationId]) => {
+    const locationIds = objectKeys(interfaceFilesByLocationId);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
     }));
     // Validate that global configs live in global interface files
     {
         const interfaceFilesGlobalPaths = [];
-        Object.entries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             assert(isGlobalLocation(locationId, locationIds));
             interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
                 if (filePathRelativeToUserRootDir) {
@@ -317,7 +334,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             });
         });
         const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
-        Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
             interfaceFiles.forEach((interfaceFile) => {
                 Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
                     if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
@@ -441,6 +458,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
     const configEnv = configDef.env;
+    const { locationId } = interfaceFile;
     const definedAtConfigFile = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
@@ -466,6 +484,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
+            locationId,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
@@ -482,6 +501,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
             const configValueSource = {
+                locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 definedAt: import_
@@ -504,6 +524,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         }
         // Defined by config file, i.e. +config.js file
         const configValueSource = {
+            locationId,
             value: configValue,
             configEnv,
             valueIsImportedAtRuntime: false,
@@ -516,6 +537,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const valueAlreadyLoaded = 'configValue' in conf;
         assert(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
+            locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             definedAt: {
@@ -546,8 +568,10 @@ function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
 function getConfigDefinitions(interfaceFilesRelevant) {
-    const configDefinitions = { ...configDefinitionsBuiltIn };
-    Object.entries(interfaceFilesRelevant).forEach(([_locationId, interfaceFiles]) => {
+    const configDefinitionsMerged = { ...configDefinitionsBuiltIn };
+    Object.entries(interfaceFilesRelevant)
+        .reverse()
+        .forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
             const configMeta = interfaceFile.fileExportsByConfigName['meta'];
             if (!configMeta)
@@ -566,13 +590,14 @@ function getConfigDefinitions(interfaceFilesRelevant) {
             });
             objectEntries(meta).forEach(([configName, configDefinition]) => {
                 // User can override an existing config definition
-                configDefinitions[configName] = {
-                    ...configDefinitions[configName],
+                configDefinitionsMerged[configName] = {
+                    ...configDefinitionsMerged[configName],
                     ...configDefinition
                 };
             });
         });
     });
+    const configDefinitions = configDefinitionsMerged;
     return configDefinitions;
 }
 function assertMetaValue(metaVal, configMetaDefinedAt) {
@@ -611,8 +636,8 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         }
     });
 }
-function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
-    objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+function applyEffectsAll(configValueSources, configDefinitions) {
+    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef.effect)
             return;
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
@@ -671,9 +696,9 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         }
     });
 }
-function getComputed(configValueSources, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitions) {
     const configValuesComputed = {};
-    objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
         const value = configDef._computed(configValueSources);
@@ -688,15 +713,7 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
-        return {
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathAbsoluteFilesystem,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-    });
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir));
     // TODO/v1-release: remove
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
@@ -748,22 +765,6 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
   )
 }
 */
-function isGlobalConfig(configName) {
-    if (configName === 'prerender')
-        return false;
-    const configNamesGlobal = getConfigNamesGlobal();
-    return arrayIncludes(configNamesGlobal, configName);
-}
-function getConfigNamesGlobal() {
-    return Object.keys(configDefinitionsBuiltInGlobal);
-}
-function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
-    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
-    if (configNames.includes(configName))
-        return;
-    handleUnknownConfig(configName, configNames, filePathToShowToUser);
-    assert(false);
-}
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     let errMsg = `${filePathToShowToUser} defines an unknown config ${pc.cyan(configName)}`;
     let configNameSimilar = null;
@@ -833,7 +834,7 @@ function determineIsErrorPage(routeFilesystem) {
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
-function getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant) {
+function getConfigValues(configValueSources, configValuesComputed, configDefinitions) {
     const configValues = {};
     Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
         configValues[configName] = {
@@ -842,7 +843,7 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
         };
     });
     Object.entries(configValueSources).forEach(([configName, sources]) => {
-        const configDef = configDefinitionsRelevant[configName];
+        const configDef = configDefinitions[configName];
         assert(configDef);
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
@@ -956,3 +957,48 @@ function getConfigEnvValue(val, errMsgIntro) {
     */
     return val;
 }
+function getConfigDefinition(configDefinitions, configName, filePathToShowToUser) {
+    const configDef = configDefinitions[configName];
+    assertConfigExists(configName, Object.keys(configDefinitions), filePathToShowToUser);
+    assert(configDef);
+    return configDef;
+}
+function getConfigDefinitionOptional(configDefinitions, configName) {
+    return configDefinitions[configName] ?? null;
+}
+function isConfigEnv(configDef, configName) {
+    const configEnv = configDef.env;
+    if (configDef.cumulative) {
+        // In principle we could lift that requirement (but it requires non-trivial modifications)
+        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
+}
+function isGlobalConfig(configName) {
+    if (configName === 'prerender')
+        return false;
+    const configNamesGlobal = getConfigNamesGlobal();
+    return arrayIncludes(configNamesGlobal, configName);
+}
+function getConfigNamesGlobal() {
+    return Object.keys(configDefinitionsBuiltInGlobal);
+}
+function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
+    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
+    if (configNames.includes(configName))
+        return;
+    handleUnknownConfig(configName, configNames, filePathToShowToUser);
+    assert(false);
+}
+function sortConfigValueSources(configValueSources, locationIdPage) {
+    return Object.fromEntries(Object.entries(configValueSources)
+        // Make order deterministic (no other purpose)
+        .sort(([, [source1]], [, [source2]]) => source1.definedAt.filePathAbsoluteVite < source2.definedAt.filePathAbsoluteVite ? -1 : 1)
+        // Sort after whether the config value was defined by an npm package
+        .sort(makeFirst(([, [source]]) => {
+        const { importPathAbsolute } = source.definedAt;
+        return !!importPathAbsolute && isNpmPackageImport(importPathAbsolute);
+    }))
+        // Sort after the filesystem inheritance of the config value
+        .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
+}

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

@@ -10,6 +10,7 @@ import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { getConfigValuesSerialized } from './getConfigValuesSerialized.js';
+import { fixServerAssets_isEnabled } from '../../buildConfig/fixServerAssets.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
@@ -42,7 +43,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
         isClientRouting
     })));
     lines.push('};');
-    if (includeAssetsImportedByServer && isForClientSide && !isDev) {
+    if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');

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

@@ -1,5 +1,5 @@
 export { setGlobalContext };
-import { setGlobalContext_viteDevServer, setGlobalContext_vitePreviewServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { setGlobalContext_viteDevServer } from '../../runtime/globalContext.js';
 function setGlobalContext() {
     return {
         name: 'vike:setGlobalContext',
@@ -9,20 +9,6 @@ function setGlobalContext() {
             handler(viteDevServer) {
                 setGlobalContext_viteDevServer(viteDevServer);
             }
-        },
-        configurePreviewServer: {
-            order: 'pre',
-            handler(vitePreviewServer) {
-                setGlobalContext_vitePreviewServer(
-                // Type cast won't be necessary after https://github.com/vitejs/vite/pull/14119 is released in Vite 5
-                vitePreviewServer);
-            }
-        },
-        configResolved: {
-            order: 'pre',
-            handler(config) {
-                setGlobalContext_viteConfig(config);
-            }
         }
     };
 }

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

@@ -0,0 +1,14 @@
+export { sourceMapRemove };
+export { sourceMapPassthrough };
+/** Remove entire source mapping, to save KBs. */
+declare function sourceMapRemove(code: string): {
+    code: string;
+    map: {
+        mappings: '';
+    };
+};
+/** Don't provide any source map, pass through current source map instead. */
+declare function sourceMapPassthrough(code: string): {
+    code: string;
+    map: null;
+};

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

@@ -0,0 +1,17 @@
+export { sourceMapRemove };
+export { sourceMapPassthrough };
+// https://rollupjs.org/guide/en/#source-code-transformations
+/** Remove entire source mapping, to save KBs. */
+function sourceMapRemove(code) {
+    return {
+        code,
+        map: { mappings: '' }
+    };
+}
+/** Don't provide any source map, pass through current source map instead. */
+function sourceMapPassthrough(code) {
+    return {
+        code,
+        map: null
+    };
+}

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

@@ -5,7 +5,6 @@ export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
-export * from '../../utils/objectKeys.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
 export * from '../../utils/joinEnglish.js';
@@ -13,10 +12,12 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/isVersionOrAbove.js';

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

@@ -11,7 +11,6 @@ export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
-export * from '../../utils/objectKeys.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
 export * from '../../utils/joinEnglish.js';
@@ -19,10 +18,12 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/isVersionOrAbove.js';

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

@@ -5,12 +5,12 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError, assertNodeEnvIsNotDev, getNodeEnv } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
-import { getGlobalContext, initGlobalContext } from '../runtime/globalContext.js';
+import { getGlobalContext, initGlobalContext, setGlobalContext_prerender } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
@@ -26,11 +26,11 @@ import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServ
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import { logHintForCjsEsmError } from '../runtime/renderPage/logHintForCjsEsmError.js';
+import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
-    // - We don't use logHintForCjsEsmError() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
+    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 async function runPrerenderFromCLI(options) {
     try {
@@ -38,7 +38,7 @@ async function runPrerenderFromCLI(options) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
 }
@@ -48,7 +48,7 @@ async function runPrerenderFromAutoFullBuild(options) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
 }
@@ -59,9 +59,10 @@ async function runPrerender(options, manuallyTriggered) {
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
-    setNodeEnvToProduction();
+    handleNodeEnv();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
+    setGlobalContext_prerender(viteConfig);
     assertLoadedConfig(viteConfig, options);
     const configVike = await getConfigVike(viteConfig);
     const { outDirClient, outDirRoot } = getOutDirs(viteConfig);
@@ -713,3 +714,10 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCall);
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
+function handleNodeEnv() {
+    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
+    if (getNodeEnv())
+        assertNodeEnv();
+    setNodeEnvToProduction();
+    assertNodeEnv();
+}