vike 0.4.220-commit-9a798ce → 0.4.220-commit-af5c91f

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

@@ -4,8 +4,9 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
-export { getConfigValueInterfaceFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
+export { getConfVal };
+export { getConfigDefinitionOptional };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse, unique, isCallable } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltInAll } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
@@ -18,15 +19,13 @@ import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
-import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
-import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
+import { loadConfigFile, loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
+import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsRequire, assertExtensionsConventions } from './assertExtensions.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-const configDefinitionsBuiltIn = getConfigDefinitionsBuiltIn();
-const configDefinitionsBuiltInGlobal = getConfigDefinitionsBuiltInGlobal();
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -37,7 +36,6 @@ function reloadVikeConfig(config) {
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
     assert(vikeVitePluginOptions);
     vikeConfigDependencies.clear();
-    clearFilesEnvMap();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
 }
@@ -96,7 +94,7 @@ async function isV1Design(config) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir) {
+async function loadInterfaceFiles(userRootDir, esbuildCache) {
     const plusFiles = await findPlusFiles(userRootDir, null);
     const configFiles = [];
     const valueFiles = [];
@@ -114,10 +112,10 @@ async function loadInterfaceFiles(userRootDir) {
         ...configFiles.map(async (filePath) => {
             const { filePathAbsoluteUserRootDir } = filePath;
             assert(filePathAbsoluteUserRootDir);
-            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, esbuildCache);
             assert(filePath.filePathAbsoluteUserRootDir);
             const locationId = getLocationId(filePathAbsoluteUserRootDir);
-            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
+            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId, userRootDir);
             interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
             interfaceFilesAll[locationId].push(interfaceFile);
             extendsConfigs.forEach((extendsConfig) => {
@@ -137,7 +135,7 @@ async function loadInterfaceFiles(userRootDir) {
                 export default { extends: [vikeReact] }
                 ```
                 */
-                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
+                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId, userRootDir);
                 assertExtensionsConventions(interfaceFile);
                 interfaceFilesAll[locationId].push(interfaceFile);
             });
@@ -152,60 +150,50 @@ async function loadInterfaceFiles(userRootDir) {
             const interfaceFile = {
                 locationId,
                 filePath,
-                fileExportsByConfigName: {
-                    [configName]: {}
-                },
                 isConfigFile: false,
                 isValueFile: true,
+                isValueFileLoaded: false,
                 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 && shouldBeLoadableAtBuildTime(configDef)) {
-                    await loadValueFile(interfaceFile, configName, userRootDir);
-                }
-            }
-            {
-                interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
-                interfaceFilesAll[locationId].push(interfaceFile);
-            }
+            interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
+            interfaceFilesAll[locationId].push(interfaceFile);
+            // 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)
+            await loadValueFile(interfaceFile, configDefinitionsBuiltInAll, userRootDir, esbuildCache);
         })
     ]);
-    assertAllConfigsAreKnown(interfaceFilesAll);
+    assertKnownConfigs(interfaceFilesAll);
     return interfaceFilesAll;
 }
-function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
+function getInterfaceFileFromConfigFile(configFile, isConfigExtension, locationId, userRootDir) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
+    const fileExportsByConfigName = {};
+    const pointerImportsByConfigName = {};
+    const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
+    Object.entries(fileExport).forEach(([configName, configValue]) => {
+        fileExportsByConfigName[configName] = configValue;
+        const pointerImport = resolvePointerImport(configValue, configFile.filePath, userRootDir, configName);
+        if (pointerImport) {
+            pointerImportsByConfigName[configName] = {
+                ...pointerImport,
+                fileExportValueLoaded: false
+            };
+        }
+    });
     const interfaceFile = {
         locationId,
         filePath,
-        fileExportsByConfigName: {},
+        fileExportsByConfigName,
+        pointerImportsByConfigName,
         isConfigFile: true,
         isValueFile: false,
-        isConfigExtend,
+        isValueFileLoaded: true,
+        isConfigExtension,
         extendsFilePaths
     };
-    const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
-    Object.entries(fileExport).forEach(([configName, configValue]) => {
-        interfaceFile.fileExportsByConfigName[configName] = { configValue };
-    });
     return interfaceFile;
 }
-/** Show error message upon unknown config */
-function assertAllConfigsAreKnown(interfaceFilesAll) {
-    objectEntries(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
-        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitions), interfaceFile.filePath.filePathToShowToUser);
-            });
-        });
-    });
-}
 async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     let hasError = false;
     let ret;
@@ -240,7 +228,6 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                 pageConfigs: [],
                 pageConfigGlobal: {
                     configDefinitions: {},
-                    interfaceFiles: {},
                     configValueSources: {}
                 },
                 global: getPageConfigUserFriendlyNew({ configValues: {} })
@@ -250,9 +237,10 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const interfaceFilesAll = await loadInterfaceFiles(userRootDir);
-    const importedFilesLoaded = {};
-    const { pageConfigGlobal, pageConfigs } = await getPageConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded);
+    const esbuildCache = {};
+    const interfaceFilesAll = await loadInterfaceFiles(userRootDir, esbuildCache);
+    const configDefinitionsResolved = await resolveConfigDefinitions(interfaceFilesAll, userRootDir, esbuildCache);
+    const { pageConfigGlobal, pageConfigs } = getPageConfigs(configDefinitionsResolved, interfaceFilesAll, userRootDir);
     // interop vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
@@ -260,189 +248,138 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const global = getPageConfigUserFriendlyNew({ configValues });
     return { pageConfigs, pageConfigGlobal, global };
 }
-async function getGlobalConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
-    /* TODO/now: dedupe
-    // Validate that global configs live in global interface files
-    {
-      const interfaceFilesGlobalPaths: string[] = []
-      objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-        assert(isGlobalLocation(locationId, locationIds))
-        interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
-          if (filePathAbsoluteUserRootDir) {
-            interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir)
-          }
-        })
-      })
-      const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))))
-      objectEntries(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
-        interfaceFiles.forEach((interfaceFile) => {
-          Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-            if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
-              assertUsage(
-                false,
-                [
-                  `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(
-                    configName
-                  )} which is global:`,
-                  globalPaths.length
-                    ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
-                    : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
-                ].join(' ')
-              )
-            }
-          })
-        })
-      })
-    }
-    //*/
-}
-function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir) {
-    assert(isObject(vikeVitePluginOptions));
-    assertWarning(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${pc.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
-    Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
-        var _a;
-        assert(includes(objectKeys(configDefinitionsBuiltInGlobal), configName));
-        const configDef = configDefinitionsBuiltInGlobal[configName];
-        const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-        sources.push({
-            value,
-            configEnv: configDef.env,
-            definedAtFilePath: {
-                ...getFilePathResolved({
-                    userRootDir,
-                    filePathAbsoluteUserRootDir: '/vite.config.js'
-                }),
-                fileExportPathToShowToUser: null
-            },
-            locationId: '/',
-            interfaceFile: null,
-            isOverriden: configDef.cumulative ? false : sources.length > 0,
-            valueIsImportedAtRuntime: false,
-            valueIsDefinedByPlusFile: false
-        });
-    });
+async function resolveConfigDefinitions(interfaceFilesAll, userRootDir, esbuildCache) {
+    const configDefinitionsGlobal = getConfigDefinitions(
+    // We use `interfaceFilesAll` in order to allow local Vike extensions to create global configs.
+    interfaceFilesAll, // TODO/now sort
+    (configDef) => !!configDef.global);
+    await loadCustomConfigBuildTimeFiles(interfaceFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
+    const configDefinitionsLocal = {};
+    await Promise.all(objectEntries(interfaceFilesAll).map(async ([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
+        //    configDefinitions = getConfigDefinitions(interfaceFilesRelevant, (configDef) => configDef.global !== true) // TODO/now
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
+        await loadCustomConfigBuildTimeFiles(interfaceFiles, configDefinitions, userRootDir, esbuildCache);
+        configDefinitionsLocal[locationId] = { configDefinitions, interfaceFiles, interfaceFilesRelevant };
+    }));
+    const configDefinitionsResolved = {
+        configDefinitionsGlobal,
+        configDefinitionsLocal
+    };
+    return configDefinitionsResolved;
 }
-async function getPageConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
-    const locationIds = objectKeys(interfaceFilesAll);
-    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => {
-        return isGlobalLocation(locationId, locationIds);
+// Load value files (with `env.config===true`) of *custom* configs.
+// - The value files of *built-in* configs are already loaded at `loadInterfaceFiles()`.
+async function loadCustomConfigBuildTimeFiles(interfaceFiles, configDefinitions, userRootDir, esbuildCache) {
+    const interfaceFileList = Object.values(interfaceFiles).flat(1);
+    await Promise.all(interfaceFileList.map(async (interfaceFile) => {
+        if (interfaceFile.isValueFile) {
+            await loadValueFile(interfaceFile, configDefinitions, userRootDir, esbuildCache);
+        }
+        else {
+            await Promise.all(Object.entries(interfaceFile.pointerImportsByConfigName).map(async ([configName, pointerImport]) => {
+                await loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache);
+            }));
+        }
     }));
+}
+function getPageConfigs(configDefinitionsResolved, interfaceFilesAll, userRootDir) {
     const pageConfigGlobal = {
-        configDefinitions: configDefinitionsBuiltInGlobal,
-        interfaceFiles: interfaceFilesGlobal,
+        configDefinitions: configDefinitionsResolved.configDefinitionsGlobal,
         configValueSources: {}
     };
-    await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
-        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
-        const configValueSource = sources[0];
-        if (!configValueSource)
+    objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
+        const sources = resolveConfigValueSources(configName, configDef, 
+        // We use `interfaceFilesAll` in order to allow local Vike extensions to set the value of global configs (e.g. `vite`).
+        interfaceFilesAll, // TODO/now check sort order
+        userRootDir, true);
+        if (sources.length === 0)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
-    }));
-    const pageConfigs = [];
-    await Promise.all(objectEntries(interfaceFilesAll)
-        .filter(([_locationId, interfaceFiles]) => isDefiningPage(interfaceFiles))
-        .map(async ([locationId]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
-        const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);
-        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        // Load value files of `env.config===true` custom configs
-        await Promise.all(interfaceFilesRelevantList.map(async (interfaceFile) => {
-            if (!interfaceFile.isValueFile)
-                return;
-            const { configName } = interfaceFile;
-            if (isGlobalConfig(configName))
-                return;
-            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (!shouldBeLoadableAtBuildTime(configDef))
-                return;
-            const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
-            if (isAlreadyLoaded)
-                return;
-            // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
-            assert(!(configName in configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configName, userRootDir);
-        }));
+    });
+    assertPageConfigGlobal(pageConfigGlobal, interfaceFilesAll);
+    const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
+        .filter(([_locationId, { interfaceFiles }]) => isDefiningPage(interfaceFiles))
+        .map(([locationId, { configDefinitions, interfaceFilesRelevant }]) => {
+        const configDefinitionsLocal = configDefinitions;
         let configValueSources = {};
-        await Promise.all(objectEntries(configDefinitions)
-            .filter(([configName]) => !isGlobalConfig(configName))
-            .map(async ([configName, configDef]) => {
-            const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
+        objectEntries(configDefinitionsLocal)
+            .filter(([_configName, configDef]) => configDef.global !== true)
+            .forEach(([configName, configDef]) => {
+            const sources = resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, false);
             if (sources.length === 0)
                 return;
+            // assertUsage(!isGlobalConfig(configName, configDefinitionsLocal, sources), 'TODO') // TODO/now
             configValueSources[configName] = sources;
-        }));
+        });
         configValueSources = sortConfigValueSources(configValueSources, locationId);
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitions);
-        const configValuesComputed = getComputed(configValueSources, configDefinitions);
+        applyEffectsAll(configValueSources, configDefinitionsLocal);
+        const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
-            configDefinitions,
+            configDefinitions: configDefinitionsLocal,
             interfaceFiles: interfaceFilesRelevant,
             configValueSources,
             configValuesComputed
         };
-        pageConfigs.push(pageConfig);
-    }));
-    assertPageConfigs(pageConfigs, interfaceFilesAll);
+        return pageConfig;
+    });
+    assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal };
 }
-function assertPageConfigs(pageConfigs, interfaceFilesAll) {
-    pageConfigs.forEach((pageConfig) => {
-        assertGlobalConfigs(pageConfig, interfaceFilesAll);
-        assertExtensionsRequire(pageConfig);
-        assertOnBeforeRenderEnv(pageConfig);
+function assertPageConfigGlobal(pageConfigGlobal, interfaceFilesAll) {
+    Object.entries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
+        assertGlobalConfigLocation(configName, sources, interfaceFilesAll, pageConfigGlobal.configDefinitions);
     });
 }
-// TODO/now: refactor
-//  - Dedupe: most of the assertGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
-//    - This assertUsage() message is slightly better: use this one for getGlobalConfigs()
-// Global configs should be defined at global locations
-function assertGlobalConfigs(pageConfig, interfaceFilesAll) {
-    const interfaceFilesRelevantList = Object.values(pageConfig.interfaceFiles).flat(1);
-    const { configDefinitions } = pageConfig;
-    interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const configNames = [];
-        if (interfaceFile.isValueFile) {
-            configNames.push(interfaceFile.configName);
+function assertGlobalConfigLocation(configName, sources, interfaceFilesAll, configDefinitionsGlobal) {
+    const locationIdsAll = objectKeys(interfaceFilesAll);
+    // Determine existing global +config.js files
+    const configFilePathsGlobal = [];
+    const interfaceFilesGlobal = Object.values(objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => isGlobalLocation(locationId, locationIdsAll)))).flat();
+    interfaceFilesGlobal
+        .filter((i) => i.isConfigFile)
+        .forEach((interfaceFile) => {
+        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
+        if (filePathAbsoluteUserRootDir) {
+            configFilePathsGlobal.push(filePathAbsoluteUserRootDir);
         }
-        else {
-            configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName));
+    });
+    // Call assertWarning()
+    sources.forEach((source) => {
+        const { interfaceFile } = source;
+        // It's `null` when the config is defined by `vike(options)` in vite.config.js
+        assert(interfaceFile);
+        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
+        // Allow local Vike extensions to set gloabl configs (`filePathAbsoluteUserRootDir===null` for Vike extension)
+        if (!filePathAbsoluteUserRootDir)
+            return;
+        assert(!interfaceFile.isConfigExtension);
+        if (!isGlobalLocation(source.locationId, locationIdsAll)) {
+            const configDef = configDefinitionsGlobal[configName];
+            assert(configDef);
+            const isConditionallyGlobal = isCallable(configDef.global);
+            const errBeg = `${filePathAbsoluteUserRootDir} (which is a local config file) sets the config ${pc.cyan(configName)}`;
+            const errMid = !isConditionallyGlobal
+                ? "but it's a global config"
+                : 'to a value that is global';
+            const what = isConditionallyGlobal ? 'global values' : pc.cyan(configName);
+            const errEnd = configFilePathsGlobal.length > 0
+                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal, 'or')} instead`
+                : `create a global config file (e.g. /pages/+config.js) and define ${what} there instead`;
+            // When updating this error message => also update error message at https://vike.dev/warning/global-config
+            const errMsg = `${errBeg} ${errMid}: ${errEnd} (https://vike.dev/warning/global-config).`;
+            assertWarning(false, errMsg, { onlyOnce: true });
         }
-        configNames.forEach((configName) => {
-            if (isGlobalConfig(configName))
-                return;
-            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (configDef.global === true) {
-                const locationIds = objectKeys(interfaceFilesAll);
-                if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
-                    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => {
-                        return isGlobalLocation(locationId, locationIds);
-                    }));
-                    const configFilesGlobal = [];
-                    objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-                        assert(isGlobalLocation(locationId, locationIds));
-                        interfaceFiles.forEach((interfaceFile) => {
-                            if (!interfaceFile.isConfigFile)
-                                return;
-                            const { filePath: { filePathAbsoluteUserRootDir } } = interfaceFile;
-                            if (filePathAbsoluteUserRootDir) {
-                                configFilesGlobal.push(filePathAbsoluteUserRootDir);
-                            }
-                        });
-                    });
-                    assertUsage(false, [
-                        `${interfaceFile.filePath.filePathToShowToUser} sets the config ${pc.cyan(configName)} but it's a global config:`,
-                        configFilesGlobal.length > 0
-                            ? `define ${pc.cyan(configName)} at ${joinEnglish(configFilesGlobal, 'or')} instead.`
-                            : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead.`
-                    ].join(' '));
-                }
-            }
-        });
+    });
+}
+function assertPageConfigs(pageConfigs) {
+    pageConfigs.forEach((pageConfig) => {
+        assertExtensionsRequire(pageConfig);
+        assertOnBeforeRenderEnv(pageConfig);
     });
 }
 function assertOnBeforeRenderEnv(pageConfig) {
@@ -482,13 +419,31 @@ function getConfigValues(pageConfig) {
     });
     return configValues;
 }
-function interfacefileIsAlreaydLoaded(interfaceFile) {
-    const configMapValues = Object.values(interfaceFile.fileExportsByConfigName);
-    const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
-    if (isAlreadyLoaded) {
-        assert(configMapValues.every((conf) => 'configValue' in conf));
-    }
-    return isAlreadyLoaded;
+function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir) {
+    assert(isObject(vikeVitePluginOptions));
+    assertWarning(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${pc.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
+    Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+        var _a;
+        assert(includes(objectKeys(configDefinitionsBuiltInAll), configName));
+        const configDef = configDefinitionsBuiltInAll[configName];
+        const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+        sources.push({
+            value,
+            configEnv: configDef.env,
+            definedAtFilePath: {
+                ...getFilePathResolved({
+                    userRootDir,
+                    filePathAbsoluteUserRootDir: '/vite.config.js'
+                }),
+                fileExportPathToShowToUser: null
+            },
+            locationId: '/',
+            interfaceFile: null,
+            isOverriden: configDef.cumulative ? false : sources.length > 0,
+            valueIsImportedAtRuntime: false,
+            valueIsDefinedByPlusFile: false
+        });
+    });
 }
 function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
     const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesAll)
@@ -498,26 +453,19 @@ function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
-    const sourcesInfo = [];
+function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, isGlobal) {
+    const interfaceFilesSource = [];
     // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
     for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
-        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.fileExportsByConfigName[configName]);
+        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => getDefiningConfigNames(interfaceFile).includes(configName));
         if (interfaceFilesDefiningConfig.length === 0)
             continue;
         const visited = new WeakSet();
         const add = (interfaceFile) => {
             assert(!visited.has(interfaceFile));
             visited.add(interfaceFile);
-            const isHighestInheritancePrecedence = sourcesInfo.length === 0;
-            sourcesInfo.push([
-                configName,
-                interfaceFile,
-                configDef,
-                userRootDir,
-                importedFilesLoaded,
-                isHighestInheritancePrecedence
-            ]);
+            const isHighestInheritancePrecedence = interfaceFilesSource.length === 0;
+            interfaceFilesSource.push({ interfaceFile, isHighestInheritancePrecedence });
         };
         // Main resolution logic
         {
@@ -528,8 +476,8 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
                 .sort(makeOrderDeterministic);
             const interfaceConfigFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isConfigFile &&
-                // We consider value from extended configs (e.g. vike-react) later (i.e. with less priority)
-                !interfaceFile.isConfigExtend)
+                // We consider values from extensions (e.g. vike-react) later (i.e. with less priority)
+                !interfaceFile.isConfigExtension)
                 .sort(makeOrderDeterministic);
             const interfaceValueFile = interfaceValueFiles[0];
             const interfaceConfigFile = interfaceConfigFiles[0];
@@ -557,8 +505,8 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
         });
         // extends
         interfaceFilesDefiningConfig
-            .filter((interfaceFile) => interfaceFile.isConfigFile && interfaceFile.isConfigExtend)
-            // extended config files are already sorted by inheritance order
+            .filter((interfaceFile) => interfaceFile.isConfigFile && interfaceFile.isConfigExtension)
+            // Extension config files are already sorted by inheritance order
             .forEach((interfaceFile) => {
             add(interfaceFile);
         });
@@ -566,31 +514,26 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
             assert(visited.has(interfaceFile));
         });
     }
-    const sources = await Promise.all(sourcesInfo.map(async (args) => await getConfigValueSource(...args)));
-    return sources;
-}
-function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
-    return lowerFirst((interfaceFile) => {
-        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
-        assert(isInterfaceFileUserLand(interfaceFile));
-        assert(filePathAbsoluteUserRootDir);
-        return filePathAbsoluteUserRootDir.length;
-    })(interfaceFile1, interfaceFile2);
-}
-function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
-    interfaceFilesOverriden.forEach((interfaceFileLoser) => {
-        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
-        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
-        const confName = pc.cyan(configName);
-        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
+    let sources = interfaceFilesSource.map(({ interfaceFile, isHighestInheritancePrecedence }) => {
+        const configValueSource = getConfigValueSource(configName, interfaceFile, configDef, userRootDir, isHighestInheritancePrecedence);
+        return configValueSource;
     });
+    if (isCallable(configDef.global)) {
+        const isGlobalValue = configDef.global;
+        assert(configDef.env.config);
+        sources = sources.filter((source) => {
+            assert(source.configEnv.config);
+            // TODO/now: source.valueIsDefined
+            assert('value' in source);
+            const valueIsGlobal = isGlobalValue(source.value);
+            return isGlobal ? valueIsGlobal : !valueIsGlobal;
+        });
+    }
+    return sources;
 }
-function isInterfaceFileUserLand(interfaceFile) {
-    return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
-}
-async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
-    const conf = interfaceFile.fileExportsByConfigName[configName];
-    assert(conf);
+function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, isHighestInheritancePrecedence) {
+    const confVal = getConfVal(interfaceFile, configName);
+    assert(confVal);
     const configValueSourceCommon = {
         locationId: interfaceFile.locationId,
         interfaceFile
@@ -606,11 +549,12 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             // Defined over pointer import
-            const resolved = resolvePointerImportOfConfig(conf.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
+            assert(confVal.configValueLoaded);
+            const pointerImport = resolvePointerImport(confVal.configValue, interfaceFile.filePath, userRootDir, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
-            assertUsage(resolved, `${configDefinedAt} should be an import`);
-            valueFilePath = resolved.pointerImport.filePathAbsoluteVite;
-            definedAtFilePath = resolved.pointerImport;
+            assertUsage(pointerImport, `${configDefinedAt} should be an import`);
+            valueFilePath = pointerImport.fileExportPath.filePathAbsoluteVite;
+            definedAtFilePath = pointerImport.fileExportPath;
         }
         else {
             // Defined by value file, i.e. +{configName}.js
@@ -635,31 +579,22 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     // +config.js
     if (interfaceFile.isConfigFile) {
-        assert('configValue' in conf);
-        const { configValue } = conf;
+        assert(confVal.configValueLoaded);
+        const { configValue } = confVal;
         // Defined over pointer import
-        const resolved = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
-        if (resolved) {
+        const pointerImport = interfaceFile.pointerImportsByConfigName[configName];
+        if (pointerImport) {
             const configValueSource = {
                 ...configValueSourceCommon,
-                configEnv: resolved.configEnvResolved,
+                configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
                 isOverriden,
-                definedAtFilePath: resolved.pointerImport
+                definedAtFilePath: pointerImport.fileExportPath
             };
-            // Load pointer import
-            if (shouldBeLoadableAtBuildTime(configDef) &&
-                // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
-                configName !== 'extends') {
-                if (resolved.pointerImport.filePathAbsoluteFilesystem) {
-                    const fileExport = await loadImportedFile(resolved.pointerImport, userRootDir, importedFilesLoaded);
-                    configValueSource.value = fileExport;
-                }
-                else {
-                    const configDefinedAt = getConfigDefinedAt('Config', configName, configValueSource.definedAtFilePath);
-                    assertUsage(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
-                }
+            if (pointerImport.fileExportValueLoaded) {
+                configValueSource.value = pointerImport.fileExportValue;
+                assert('fileExportValue' in pointerImport);
             }
             return configValueSource;
         }
@@ -677,8 +612,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     // Defined by value file, i.e. +{configName}.js
     if (interfaceFile.isValueFile) {
-        const configEnvResolved = resolveConfigEnvWithFileName(configDef.env, interfaceFile.filePath);
-        const valueAlreadyLoaded = 'configValue' in conf;
+        const configEnvResolved = resolveConfigEnv(configDef.env, interfaceFile.filePath);
+        const valueAlreadyLoaded = confVal.configValueLoaded;
         assert(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
             ...configValueSourceCommon,
@@ -695,15 +630,34 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             }
         };
         if (valueAlreadyLoaded) {
-            configValueSource.value = conf.configValue;
+            configValueSource.value = confVal.configValue;
         }
         return configValueSource;
     }
     assert(false);
 }
+function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
+    return lowerFirst((interfaceFile) => {
+        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
+        assert(isInterfaceFileUserLand(interfaceFile));
+        assert(filePathAbsoluteUserRootDir);
+        return filePathAbsoluteUserRootDir.length;
+    })(interfaceFile1, interfaceFile2);
+}
+function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
+    interfaceFilesOverriden.forEach((interfaceFileLoser) => {
+        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
+        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
+        const confName = pc.cyan(configName);
+        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
+    });
+}
+function isInterfaceFileUserLand(interfaceFile) {
+    return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtension) || interfaceFile.isValueFile;
+}
 function isDefiningPage(interfaceFiles) {
     for (const interfaceFile of interfaceFiles) {
-        const configNames = Object.keys(interfaceFile.fileExportsByConfigName);
+        const configNames = getDefiningConfigNames(interfaceFile);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -713,16 +667,29 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function getConfigDefinitions(interfaceFilesRelevant) {
-    const configDefinitionsMerged = { ...configDefinitionsBuiltIn };
+function getDefiningConfigNames(interfaceFile) {
+    let configNames = [];
+    if (interfaceFile.isValueFile) {
+        configNames.push(interfaceFile.configName);
+    }
+    if (interfaceFile.isValueFileLoaded) {
+        configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName));
+    }
+    configNames = unique(configNames);
+    return configNames;
+}
+function getConfigDefinitions(interfaceFilesRelevant, filter) {
+    let configDefinitions = { ...configDefinitionsBuiltInAll };
+    // Add user-land meta configs
     Object.entries(interfaceFilesRelevant)
         .reverse()
         .forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
-            const configMeta = interfaceFile.fileExportsByConfigName['meta'];
-            if (!configMeta)
+            const confVal = getConfVal(interfaceFile, 'meta');
+            if (!confVal)
                 return;
-            const meta = configMeta.configValue;
+            assert(confVal.configValueLoaded);
+            const meta = confVal.configValue;
             assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
@@ -734,16 +701,18 @@ function getConfigDefinitions(interfaceFilesRelevant) {
                     fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
                 };
             });
-            objectEntries(meta).forEach(([configName, configDefinition]) => {
+            objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
                 // User can override an existing config definition
-                configDefinitionsMerged[configName] = {
-                    ...configDefinitionsMerged[configName],
-                    ...configDefinition
+                configDefinitions[configName] = {
+                    ...configDefinitions[configName],
+                    ...configDefinitionUserLand
                 };
             });
         });
     });
-    const configDefinitions = configDefinitionsMerged;
+    if (filter) {
+        configDefinitions = Object.fromEntries(Object.entries(configDefinitions).filter(([_configName, configDef]) => filter(configDef)));
+    }
     return configDefinitions;
 }
 function assertMetaUsage(metaVal, metaConfigDefinedAt) {
@@ -897,10 +866,35 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
   )
 }
 */
-function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
+// Show error message upon unknown config
+function assertKnownConfigs(interfaceFilesAll) {
+    const configDefinitionsAll = getConfigDefinitions(interfaceFilesAll);
+    const configNamesKnownAll = Object.keys(configDefinitionsAll);
+    objectEntries(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
+        const configDefinitionsLocal = getConfigDefinitions(interfaceFilesRelevant);
+        const configNamesKnownLocal = Object.keys(configDefinitionsLocal);
+        interfaceFiles.forEach((interfaceFile) => {
+            const configNames = getDefiningConfigNames(interfaceFile);
+            configNames.forEach((configName) => {
+                assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, interfaceFile);
+                assert(configNamesKnownLocal.includes(configName));
+                assert(configNamesKnownAll.includes(configName));
+            });
+        });
+    });
+}
+function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, interfaceFile) {
+    if (configNamesKnownLocal.includes(configName))
+        return;
     const configNameColored = pc.cyan(configName);
-    let errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}.`;
-    // vike-{react,vue,solid} hint
+    const { locationId, filePath: { filePathToShowToUser } } = interfaceFile;
+    const errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}`;
+    // Inheritance issue: config is known but isn't defined at `locationId`
+    if (configNamesKnownAll.includes(configName)) {
+        assertUsage(false, `${filePathToShowToUser} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`);
+    }
+    // Missing vike-{react,vue,solid} installation
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];
         const knownVikeExntensionConfigs = {
@@ -915,15 +909,11 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
             Wrapper: ui
         };
         if (configName in knownVikeExntensionConfigs) {
-            const requiredVikeExtension = knownVikeExntensionConfigs[configName];
-            assertUsage(false, [
-                errMsg,
-                `If you want to use the configuration documented at https://vike.dev/${configName} then make sure to install the Vike extension ${requiredVikeExtension
-                    .map((e) => pc.bold(e))
-                    .join('/')}.`,
-                `Also make sure it applies to ${filePathToShowToUser} (see https://vike.dev/extends#inheritance).`,
-                `Alternatively, if you don't want to use the aforementioned Vike extension, define it yourself by using ${pc.cyan('meta')} (https://vike.dev/meta).`
-            ].join(' '));
+            const requiredVikeExtension = knownVikeExntensionConfigs[configName]
+                .map((e) => pc.bold(e))
+                .join('/');
+            const errMsgEnhanced = `${errMsg}. If you want to use the configuration ${configNameColored} documented at ${pc.underline(`https://vike.dev/${configName}`)} then make sure to install ${requiredVikeExtension}. (Alternatively, you can define ${configNameColored} yourself by using ${pc.cyan('meta')}, see ${pc.underline('https://vike.dev/meta')} for more information.)`;
+            assertUsage(false, errMsgEnhanced);
         }
     }
     // Similarity hint
@@ -932,18 +922,15 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
         configNameSimilar = 'Page';
     }
     else {
-        configNameSimilar = getMostSimilar(configName, configNames);
+        configNameSimilar = getMostSimilar(configName, configNamesKnownAll);
     }
     if (configNameSimilar) {
         assert(configNameSimilar !== configName);
-        errMsg += ` Did you mean to set ${pc.cyan(configNameSimilar)} instead?`;
+        let errMsgEnhanced = `${errMsg}. Did you mean ${pc.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
-            errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
+            errMsgEnhanced += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
         }
-    }
-    // `meta` hint
-    if (!configNameSimilar) {
-        errMsg += ` Make sure to define ${configNameColored} by using ${pc.cyan('meta')} (https://vike.dev/meta), and also make sure the meta configuration applies to ${filePathToShowToUser} (see https://vike.dev/config#inheritance).`;
+        assertUsage(false, errMsgEnhanced);
     }
     assertUsage(false, errMsg);
 }
@@ -1030,52 +1017,9 @@ 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 shouldBeLoadableAtBuildTime(configDef) {
-    return !!configDef.env.config && !configDef._valueIsFilePath;
-}
-function isGlobalConfig(configName) {
-    // TODO/now
-    if (configName === 'prerender')
-        return false;
-    const configNamesGlobal = getConfigNamesGlobal();
-    return includes(configNamesGlobal, configName);
-}
-/*
-// TODO/now
-function isGlobalConfig(configName: string, configDefinitions: ConfigDefinitions): configName is ConfigNameGlobal {
-  const configSpec = configDefinitions[configName]
-  assert(configSpec)
-  const globalValue = configSpec.global
-  if (!globalValue) return false
-  if (globalValue === true ) return true
-  return globalValue(value)
-}
-*/
-function getConfigNamesGlobal() {
-    return Object.keys(configDefinitionsBuiltInGlobal);
-}
-function getConfigDefinitionsBuiltInGlobal() {
-    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== undefined));
-}
-function getConfigDefinitionsBuiltIn() {
-    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== true));
-}
-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)
@@ -1092,6 +1036,31 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
 }
-function getConfigValueInterfaceFile(interfaceFile, configName) {
-    return interfaceFile.fileExportsByConfigName[configName]?.configValue;
+function getConfVal(interfaceFile, configName) {
+    const configNames = getDefiningConfigNames(interfaceFile);
+    if (!configNames.includes(configName))
+        return null;
+    if (!interfaceFile.isValueFileLoaded)
+        return { configValueLoaded: false };
+    const confVal = { configValue: interfaceFile.fileExportsByConfigName[configName], configValueLoaded: true };
+    return confVal;
+}
+function resolveConfigEnv(configEnv, filePath) {
+    const configEnvResolved = { ...configEnv };
+    if (filePath.filePathAbsoluteFilesystem) {
+        const { fileName } = filePath;
+        if (fileName.includes('.server.')) {
+            configEnvResolved.server = true;
+            configEnvResolved.client = false;
+        }
+        else if (fileName.includes('.client.')) {
+            configEnvResolved.client = true;
+            configEnvResolved.server = false;
+        }
+        else if (fileName.includes('.shared.')) {
+            configEnvResolved.server = true;
+            configEnvResolved.client = true;
+        }
+    }
+    return configEnvResolved;
 }