vike 0.4.171 → 0.4.172-commit-c1b0884

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -2,7 +2,6 @@ export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, assertIsNpmPackageImport, createDebugger, isArray, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
@@ -45,20 +44,24 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
-                if (!configValueSource.valueIsImportedAtRuntime)
-                    return;
-                const { definedAtFilePath, configEnv } = configValueSource;
-                if (!configEnv.client)
-                    return;
-                if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
-                    // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                    addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
-                }
-                else {
-                    // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                    addInclude(definedAtFilePath.importPathAbsolute);
-                }
+            Object.values(pageConfig.configValueSources).forEach((sources) => {
+                sources
+                    .filter((c) => !c.isOverriden)
+                    .forEach((configValueSource) => {
+                    if (!configValueSource.valueIsImportedAtRuntime)
+                        return;
+                    const { definedAtFilePath, configEnv } = configValueSource;
+                    if (!configEnv.client)
+                        return;
+                    if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                        // Vite expects entries to be filesystem absolute paths (surprisingly so).
+                        addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
+                    }
+                    else {
+                        // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                        addInclude(definedAtFilePath.importPathAbsolute);
+                    }
+                });
             });
         });
     }

package/dist/esm/node/plugin/plugins/devConfig/index.js

@@ -73,7 +73,8 @@ function devConfig() {
             configureServer: {
                 order: 'post',
                 handler(server) {
-                    if (config.server.middlewareMode)
+                    const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
+                    if (config.server.middlewareMode || hasHonoViteDevServer)
                         return;
                     return () => {
                         addSsrMiddleware(server.middlewares);

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

@@ -50,7 +50,8 @@ function envVarsPlugin() {
                             assertUsage(false, errMsg);
                         }
                         else {
-                            // Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
+                            // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
+                            // - But only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
                             assertWarning(false, errMsg, { onlyOnce: true });
                         }
                     }

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

@@ -101,7 +101,7 @@ function extractAssetsPlugin() {
                 }
                 // If the import path resolves to a file in `node_modules/`, we ignore that file:
                 //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
-                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)
+                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
                 assertPosixPath(file);
                 if (file.includes('/node_modules/')) {
                     return emptyModule(file, importer);

package/dist/esm/node/plugin/plugins/importUserCode/addImportStatement.d.ts

@@ -0,0 +1,14 @@
+export { addImportStatement };
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ */
+declare function addImportStatement(importStatements: string[], importPath: string, exportName: string): {
+    importName: string;
+};

package/dist/esm/node/plugin/plugins/importUserCode/{generateEagerImport.js → addImportStatement.js}

@@ -1,5 +1,4 @@
-export { generateEagerImport };
-let varCounterGlobal = 0;
+export { addImportStatement };
 /**
  * Naming:
  *   `import { someExport as someImport } from './some-file'`
@@ -9,14 +8,12 @@ let varCounterGlobal = 0;
  *      `exportName: 'someExport',`
  *      `importName: 'someImport',`
  *    `}`
- * We discard the information that the import variable is called `someImport` because we don't need it.
  */
-function generateEagerImport(importPath, varCounter, exportName) {
-    if (varCounter === undefined)
-        varCounter = varCounterGlobal++;
-    const importName = `import_${varCounter}`;
+function addImportStatement(importStatements, importPath, exportName) {
+    const importCounter = importStatements.length + 1;
+    const importName = `import${importCounter}`;
     const importLiteral = (() => {
-        if (!exportName || exportName === '*') {
+        if (exportName === '*') {
             return `* as ${importName}`;
         }
         if (exportName === 'default') {
@@ -25,5 +22,6 @@ function generateEagerImport(importPath, varCounter, exportName) {
         return `{ ${exportName} as ${importName} }`;
     })();
     const importStatement = `import ${importLiteral} from '${importPath}';`;
-    return { importName, importStatement };
+    importStatements.push(importStatement);
+    return { importName };
 }

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -63,7 +63,6 @@ export const pageFilesExportNamesLazy = {};
 export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
-export const isGeneratedFile = true;
 
 ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config)}
 

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.d.ts

@@ -56,7 +56,8 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;
 };
-type ConfigDefinitions = Record<string, ConfigDefinitionInternal>;
+type ConfigDefinitions = Record<string, // configName
+ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';

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

@@ -21,7 +21,7 @@ const configDefinitionsBuiltIn = {
         env: { server: true }
     },
     onBeforePrerenderStart: {
-        env: { server: true }
+        env: { server: true, production: true }
     },
     Page: {
         env: { server: true, client: true }
@@ -47,7 +47,7 @@ const configDefinitionsBuiltIn = {
     },
     client: {
         // The value of the client config is merely the file path to the client entry file, which is only needed on the sever-side
-        env: { server: true },
+        env: { server: true, config: true },
         _valueIsFilePath: true
     },
     clientRouting: {
@@ -95,7 +95,7 @@ const configDefinitionsBuiltIn = {
 };
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: { server: true }
+        env: { server: true, production: true }
     },
     onBeforeRoute: {
         env: { server: true, client: 'if-client-routing', eager: true }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -1,4 +1,4 @@
 export { crawlPlusFiles };
-declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
+declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean, crawlWithGit: null | boolean): Promise<{
     filePathAbsoluteUserRootDir: string;
 }[]>;

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

@@ -1,5 +1,5 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions, humanizeTime, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove } from '../../../../utils.js';
+import { assertPosixPath, assert, assertWarning, scriptFileExtensionList, scriptFileExtensions, humanizeTime, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
@@ -10,7 +10,7 @@ const execA = promisify(exec);
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
-async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev, crawlWithGit) {
     assertPosixPath(userRootDir);
     assertPosixPath(outDirAbsoluteFilesystem);
     let outDirRelativeFromUserRootDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
@@ -26,8 +26,9 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
             //
             !outDirRelativeFromUserRootDir.startsWith('../')));
     const timeBefore = new Date().getTime();
+    // Crawl
     let files = [];
-    const res = await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir);
+    const res = crawlWithGit !== false && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
     if (res &&
         // Fallback to fast-glob for users that dynamically generate plus files. (Assuming all (generetad) plus files to be skipped because users usually included them in `.gitignore`.)
         res.length > 0) {
@@ -36,7 +37,9 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     else {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
+    // Filter build files
     files = files.filter((file) => !isTemporaryBuildFile(file));
+    // Check performance
     {
         const timeAfter = new Date().getTime();
         const timeSpent = timeAfter - timeBefore;
@@ -48,10 +51,12 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
             });
         }
     }
-    const plusFiles = files.map((p) => {
-        p = toPosixPath(p);
-        assert(!p.startsWith(userRootDir));
-        const filePathAbsoluteUserRootDir = path.posix.join('/', p);
+    // Normalize
+    const plusFiles = files.map((filePath) => {
+        // Both `$ git-ls files` and fast-glob return posix paths
+        assertPosixPath(filePath);
+        assert(!filePath.startsWith(userRootDir));
+        const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
         return { filePathAbsoluteUserRootDir };
     });
     return plusFiles;
@@ -60,10 +65,17 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
 async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
     if (gitIsNotUsable)
         return null;
+    // Preserve UTF-8 file paths.
+    // https://github.com/vikejs/vike/issues/1658
+    // https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window/22828826#22828826
+    // https://stackoverflow.com/questions/15884180/how-do-i-override-git-configuration-options-by-command-line-parameters/15884261#15884261
+    const preserveUTF8 = '-c core.quotepath=off';
     const ignoreAsPatterns = getIgnoreAsPatterns(outDirRelativeFromUserRootDir);
     const ignoreAsFilterFn = getIgnoreAsFilterFn(outDirRelativeFromUserRootDir);
     const cmd = [
-        'git ls-files',
+        'git',
+        preserveUTF8,
+        'ls-files',
         ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
         ...ignoreAsPatterns.map((pattern) => `--exclude="${pattern}"`),
         // --others lists untracked files only (but using .gitignore because --exclude-standard)

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

@@ -10,7 +10,7 @@ import { parsePointerImportData } from './transformFileImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
 assertIsNotProductionRuntime();
-// Load fake import
+// Load pointer import
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
@@ -30,7 +30,7 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
         interfaceValueFile.fileExportsByConfigName[configName_] = { configValue };
     });
 }
-// Load +config.js, including all its extends fake imports
+// Load +config.js, including all its extends pointer imports
 async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);

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

@@ -29,6 +29,9 @@ type VikeConfigObject = {
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: true): Promise<VikeConfigObject>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, { crawlWithGit, tolerateInvalidConfig }?: {
+    crawlWithGit?: null | boolean;
+    tolerateInvalidConfig?: true;
+}): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;

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

@@ -14,12 +14,13 @@ import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNot
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
+import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
+import { getConfigVike } from '../../../../shared/getConfigVike.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -62,11 +63,12 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, tolerateInvalidConfig) {
+async function getVikeConfig(config, isDev, { crawlWithGit, tolerateInvalidConfig } = {}) {
     const { outDirRoot } = getOutDirs(config);
     const userRootDir = config.root;
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, tolerateInvalidConfig);
+        const crawlWithGit_ = crawlWithGit !== undefined ? crawlWithGit : (await getConfigVike(config)).crawl.git;
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit_, tolerateInvalidConfig);
     }
     return await vikeConfigPromise;
 }
@@ -76,8 +78,8 @@ async function isV1Design(config, isDev) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
-    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev);
+async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, crawlWithGit) {
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -166,7 +168,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
                 //  - 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)) {
+                if (configDef && isLoadableAtBuildTime(configDef)) {
                     await loadValueFile(interfaceFile, configName, userRootDir);
                 }
             }
@@ -208,12 +210,12 @@ function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
         });
     });
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, tolerateInvalidConfig) {
+async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev);
+        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit);
     }
     catch (err_) {
         hasError = true;
@@ -241,6 +243,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
+                    configDefinitions: {},
                     configValueSources: {}
                 },
                 globalVikeConfig: {}
@@ -249,8 +252,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
         }
     }
 }
-async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev);
+async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
@@ -266,7 +269,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (!isConfigEnv(configDef, configName))
+            if (!isLoadableAtBuildTime(configDef))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
@@ -288,14 +291,13 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitions);
         const configValuesComputed = getComputed(configValueSources, configDefinitions);
-        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitions);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
+            configDefinitions,
             configValueSources,
-            configValuesComputed,
-            configValues
+            configValuesComputed
         };
         return pageConfig;
     }));
@@ -328,7 +330,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     if (!onBeforeRenderConfig)
         return;
     const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
-    const isClientRouting = !!pageConfig.configValues.clientRouting?.value;
+    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
@@ -389,6 +391,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
     }
     const globalVikeConfig = {};
     const pageConfigGlobal = {
+        configDefinitions: configDefinitionsBuiltInGlobal,
         configValueSources: {}
     };
     await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
@@ -422,7 +425,15 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
         const add = (interfaceFile) => {
             assert(!visited.has(interfaceFile));
             visited.add(interfaceFile);
-            sourcesInfo.push([configName, interfaceFile, configDef, userRootDir, importedFilesLoaded]);
+            const isHighestInheritancePrecedence = sourcesInfo.length === 0;
+            sourcesInfo.push([
+                configName,
+                interfaceFile,
+                configDef,
+                userRootDir,
+                importedFilesLoaded,
+                isHighestInheritancePrecedence
+            ]);
         };
         // Main resolution logic
         {
@@ -493,7 +504,7 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
-async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded) {
+async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
     const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
     const configEnv = deriveConfigEnvFromFileName(configDef.env, interfaceFile.filePath.fileName);
@@ -502,6 +513,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
+    const isOverriden = configDef.cumulative ? false : !isHighestInheritancePrecedence;
     // +client.js
     if (configDef._valueIsFilePath) {
         let definedAtFilePath;
@@ -528,7 +540,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            valueIsDefinedByValueFile: false,
+            valueIsDefinedByPlusFile: false,
+            isOverriden,
             definedAtFilePath
         };
         return configValueSource;
@@ -544,11 +557,12 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                valueIsDefinedByValueFile: false,
+                valueIsDefinedByPlusFile: false,
+                isOverriden,
                 definedAtFilePath: pointerImport
             };
-            // Load fake import
-            if (isConfigEnv(configDef, configName) &&
+            // Load pointer import
+            if (isLoadableAtBuildTime(configDef) &&
                 // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
                 configName !== 'extends') {
                 if (pointerImport.filePathAbsoluteFilesystem) {
@@ -568,7 +582,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             value: configValue,
             configEnv,
             valueIsImportedAtRuntime: false,
-            valueIsDefinedByValueFile: false,
+            valueIsDefinedByPlusFile: false,
+            isOverriden,
             definedAtFilePath: definedAtFilePath_
         };
         return configValueSource;
@@ -581,7 +596,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            valueIsDefinedByValueFile: true,
+            valueIsDefinedByPlusFile: true,
+            isOverriden,
             definedAtFilePath: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName
@@ -751,8 +767,8 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot, isDev) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
+async function findPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
@@ -876,59 +892,6 @@ function determineIsErrorPage(routeFilesystem) {
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
-function getConfigValues(configValueSources, configValuesComputed, configDefinitions) {
-    const configValues = {};
-    Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
-        configValues[configName] = {
-            type: 'computed',
-            value: configValueComputed.value,
-            definedAtData: null
-        };
-    });
-    Object.entries(configValueSources).forEach(([configName, sources]) => {
-        const configDef = configDefinitions[configName];
-        assert(configDef);
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            if ('value' in configValueSource) {
-                configValues[configName] = {
-                    type: 'classic',
-                    value: configValueSource.value,
-                    definedAtData: getDefinedAtFile(configValueSource)
-                };
-            }
-        }
-        else {
-            const value = mergeCumulative(configName, sources);
-            const definedAtData = sources.map((source) => getDefinedAtFile(source));
-            assert(value.length === definedAtData.length);
-            configValues[configName] = {
-                type: 'cumulative',
-                value,
-                definedAtData
-            };
-        }
-    });
-    return configValues;
-}
-function getDefinedAtFile(configValueSource) {
-    return {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
-    };
-}
-function mergeCumulative(configName, configValueSources) {
-    const configValues = [];
-    configValueSources.forEach((configValueSource) => {
-        // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
-        assert('value' in configValueSource);
-        // Make sure configValueSource.value is serializable
-        assertConfigValueIsSerializable(configValueSource.value, configName, getDefinedAtFile(configValueSource));
-        const { value } = configValueSource;
-        configValues.push(value);
-    });
-    return configValues;
-}
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
     // Legacy outdated values
@@ -971,13 +934,8 @@ function getConfigDefinition(configDefinitions, configName, filePathToShowToUser
 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 isLoadableAtBuildTime(configDef) {
+    return !!configDef.env.config && !configDef._valueIsFilePath;
 }
 function isGlobalConfig(configName) {
     if (configName === 'prerender')