vike 0.4.221 → 0.4.222-commit-207e079

package/dist/esm/client/shared/loadUserFilesClientSide.js

@@ -6,7 +6,7 @@ import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../server-routing-runtime/utils.js';
 const stamp = '__whileFetchingAssets';
-async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
+async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
@@ -30,7 +30,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -5,10 +5,10 @@ export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
 import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
+declare function prepareViteApiCall(viteConfigFromOptions: InlineConfig | undefined, operation: Operation): Promise<{
     vikeConfig: VikeConfigObject;
     viteConfigEnhanced: InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
+declare function getViteRoot(operation: Operation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;
 declare function assertViteRoot(root: string, config: ResolvedConfig): void;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -11,18 +11,18 @@ import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './u
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
 const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
-async function prepareViteApiCall(viteConfig, operation) {
+async function prepareViteApiCall(viteConfigFromOptions, operation) {
     clear();
     setContextApiOperation(operation);
-    return enhanceViteConfig(viteConfig, operation);
+    return enhanceViteConfig(viteConfigFromOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextApiOperation();
     clearGlobalContext();
 }
-async function enhanceViteConfig(viteConfig, operation) {
-    const viteInfo = await getInfoFromVite(viteConfig, operation);
+async function enhanceViteConfig(viteConfigFromOptions, operation) {
+    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
     const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
@@ -38,6 +38,7 @@ function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
         viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
+        assertUsage(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
     return viteConfigEnhanced;
 }
@@ -47,13 +48,14 @@ async function getViteRoot(operation) {
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfig, operation) {
-    const viteConfigFromFile = await loadViteConfigFile(viteConfig, operation);
-    const root = normalizeViteRoot(viteConfigFromFile?.root ?? viteConfig?.root ?? process.cwd());
+async function getInfoFromVite(viteConfigFromOptions, operation) {
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
+    const root = normalizeViteRoot(viteConfigFromUserViteFile?.root ?? viteConfigFromOptions?.root ?? process.cwd());
     globalObject.root = root;
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfig;
-    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    let viteConfigEnhanced = viteConfigFromOptions;
+    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
+    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -62,20 +64,20 @@ async function getInfoFromVite(viteConfig, operation) {
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
         viteConfigEnhanced = {
-            ...viteConfig,
-            plugins: [...(viteConfig?.plugins ?? []), vikePlugin()]
+            ...viteConfigFromOptions,
+            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        const res = findVikeVitePlugin(viteConfigEnhanced);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
     return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-function findVikeVitePlugin(plugins) {
+function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
-    plugins.forEach((p) => {
+    viteConfig?.plugins?.forEach((p) => {
         if (p && '__vikeVitePluginOptions' in p) {
             vikeVitePuginFound = true;
             const options = p.__vikeVitePluginOptions;
@@ -88,8 +90,8 @@ function findVikeVitePlugin(plugins) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfig, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfig, operation);
+async function loadViteConfigFile(viteConfigFromOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {

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

@@ -4,7 +4,10 @@ export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
 export type { VikeVitePluginOptions };
 export { PROJECT_VERSION as version } from './utils.js';
-declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;
+type PluginInterop = Record<string, unknown> & {
+    name: string;
+};
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): PluginInterop[];
 /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
 type VikeVitePluginOptions = {
     /** @deprecated Define Vike settings in +config.js instead of vite.config.js */

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

@@ -29,7 +29,7 @@ import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegres
 import { buildApp } from './plugins/buildApp.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
-// Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
+// Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
         ...commonConfig(vikeVitePluginOptions),

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

@@ -1,5 +1,5 @@
 export { baseUrls };
-import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
+import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 function baseUrls() {
@@ -38,3 +38,8 @@ function baseUrls() {
         }
     };
 }
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.d.ts

@@ -2,7 +2,6 @@ export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
-export { fixServerAssets_assertCssTarget_populate };
 import { ViteManifest } from '../../../shared/ViteManifest.js';
 import { ResolvedConfig } from 'vite';
 /**
@@ -18,5 +17,4 @@ declare function fixServerAssets(config: ResolvedConfig): Promise<{
     serverManifestMod: ViteManifest;
 }>;
 declare function fixServerAssets_assertCssCodeSplit(config: ResolvedConfig): void;
-declare function fixServerAssets_assertCssTarget_populate(config: ResolvedConfig): void;
 declare function fixServerAssets_assertCssTarget(config: ResolvedConfig): Promise<void>;

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.js

@@ -2,7 +2,6 @@ export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
-export { fixServerAssets_assertCssTarget_populate };
 import fs from 'fs/promises';
 import fs_sync from 'fs';
 import path from 'path';
@@ -195,17 +194,15 @@ function fixServerAssets_assertCssCodeSplit(config) {
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
 const targets = [];
-function fixServerAssets_assertCssTarget_populate(config) {
-    const isServerSide = viteIsSSR(config);
-    assert(typeof isServerSide === 'boolean');
-    assert(config.build.target !== undefined);
-    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
-}
 async function fixServerAssets_assertCssTarget(config) {
     if (!fixServerAssets_isEnabled())
         return;
     if (!(await isV1Design(config)))
         return;
+    const isServerSide = viteIsSSR(config);
+    assert(typeof isServerSide === 'boolean');
+    assert(config.build.target !== undefined);
+    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
     const targetsServer = targets.filter((t) => t.isServerSide);
     const targetsClient = targets.filter((t) => !t.isServerSide);
     targetsClient.forEach((targetClient) => {
@@ -213,9 +210,10 @@ async function fixServerAssets_assertCssTarget(config) {
         targetsServer.forEach((targetServer) => {
             const targetCssResolvedServer = resolveCssTarget(targetServer);
             assertWarning(isEqualStringList(targetCssResolvedClient, targetCssResolvedServer), [
-                'The CSS browser target should be the same for both client-side and server-side (https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979) but we got:',
-                `Client-side: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
-                `Server-side: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`
+                'The CSS browser target should be the same for both client and server, but we got:',
+                `Client: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
+                `Server: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`,
+                `Different targets lead to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`
             ].join('\n'), {
                 showStackTrace: true,
                 onlyOnce: 'different-css-target'

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

@@ -10,7 +10,7 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
-import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { set_ASSETS_MANIFEST } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
@@ -48,7 +48,6 @@ function buildConfig() {
                             config.build.ssrEmitAssets = true;
                             // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
                             config.build.cssMinify = 'esbuild';
-                            fixServerAssets_assertCssTarget_populate(config);
                             fixServerAssets_assertCssCodeSplit(config);
                         }
                     }

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -11,6 +11,7 @@ declare module 'vite' {
         _viteConfigEnhanced?: InlineConfig;
         vike?: {
             config: VikeConfigObject['global']['config'];
+            pages: VikeConfigObject['pages'];
             prerenderContext?: PrerenderContextPublic;
         };
     }

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

@@ -30,7 +30,10 @@ function commonConfig(vikeVitePluginOptions) {
                         _isDev: isDev,
                         _root: root,
                         _vikeVitePluginOptions: vikeVitePluginOptions,
-                        vike: { config: vikeConfig.global.config },
+                        vike: {
+                            pages: vikeConfig.pages,
+                            config: vikeConfig.global.config
+                        },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
                             prerender: isPrerenderEnabled(vikeConfig)

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

@@ -10,8 +10,8 @@ import { vikeConfigDependencies, reloadVikeConfig, isV1Design, getVikeConfig } f
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
-import { getPlusFileValueConfigName } from './v1-design/getVikeConfig/getPlusFilesAll.js';
 import { updateUserFiles } from '../../../runtime/globalContext.js';
+import { isPlusFile } from './v1-design/getVikeConfig/crawlPlusFiles.js';
 function importUserCode() {
     let config;
     let vikeConfig;
@@ -68,50 +68,55 @@ function handleFileAddRemove(server, config) {
     return;
     function listener(file, isRemove) {
         file = normalizePath(file);
-        const isVikeConfig = isVikeConfigModule(file) || isVikeConfigFile(file);
-        if (isVikeConfig) {
-            const virtualModules = getVirtualModules(server);
-            virtualModules.forEach((mod) => {
-                server.moduleGraph.invalidateModule(mod);
-            });
+        if (isPlusFile(file) || isVikeConfigDependency(file, server.moduleGraph)?.modifiesVikeVirtualFiles) {
+            invalidateVikeVirtualFiles(server);
             reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
     }
 }
+function invalidateVikeVirtualFiles(server) {
+    const vikeVirtualFiles = getVikeVirtualFiles(server);
+    vikeVirtualFiles.forEach((mod) => {
+        server.moduleGraph.invalidateModule(mod);
+    });
+}
 function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
-    const isVikeConfig = isVikeConfigModule(file);
-    const isViteModule = ctx.modules.length > 0;
-    /* Should we show this?
-    // - Can be useful for server files that aren't processed by Vite.
-    // - Can be annoying for files that obviously aren't processed by Vite.
-    if (!isVikeConfig && !isViteModule) {
-      logViteAny(
-        `${msg} — ${pc.cyan('no HMR')}, see https://vike.dev/on-demand-compiler`,
-        'info',
-        null,
-        true
-      )
-      return
-    }
-    //*/
-    // It can hide an error it shouldn't hide (because the error isn't shown again), but it's ok since users can reload the page and the error will be shown again (Vite transpilation errors are shown again upon a page reload).
-    if (!isVikeConfig && isViteModule) {
-        return;
-    }
+    const isVikeConfig = isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
-        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
-        assert(!isViteModule)
-        */
-        reloadConfig(file, config, 'modified');
-        const virtualModules = getVirtualModules(server);
-        return virtualModules;
+        if (isVikeConfig.modifiesVikeVirtualFiles) {
+            /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+            const isViteModule = ctx.modules.length > 0
+            assert(!isViteModule)
+            */
+            // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
+            invalidateVikeVirtualFiles(server);
+            reloadConfig(file, config, 'modified');
+            // Triggers a full page reload
+            const vikeVirtualFiles = getVikeVirtualFiles(server);
+            return vikeVirtualFiles;
+        }
+        else {
+            // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
+            // Vite already invalidates it, but possibly *after* handleHotUpdate() and thus after server.ssrLoadModule()
+            ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
+            updateUserFiles();
+        }
     }
 }
-function isVikeConfigModule(filePathAbsoluteFilesystem) {
+function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
+    // Check config-only files, for example all pages/+config.js dependencies. (There aren't part of Vite's module graph.)
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.forEach((f) => assertPosixPath(f));
-    return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
+    if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
+        return { modifiesVikeVirtualFiles: true };
+    // Check using Vite's module graph, for example all +htmlAttributes dependencies.
+    // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
+    const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
+    const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
+    if (isPlusValueFileDependency)
+        return { modifiesVikeVirtualFiles: false };
+    return null;
 }
 function reloadConfig(filePath, config, op) {
     {
@@ -122,16 +127,45 @@ function reloadConfig(filePath, config, op) {
     reloadVikeConfig(config);
     updateUserFiles();
 }
-function getVirtualModules(server) {
-    const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+function getVikeVirtualFiles(server) {
+    const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
         .filter((url) => isVirtualFileIdPageConfigValuesAll(url) || isVirtualFileIdImportUserCode(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);
         return mod;
     });
-    return virtualModules;
+    return vikeVirtualFiles;
+}
+// Get all transitive importers (including the module itself)
+function getImporters(file, moduleGraph) {
+    const importers = new Set();
+    const mods = moduleGraph.getModulesByFile(file);
+    if (!mods)
+        return importers;
+    for (const mod of mods) {
+        getModuleImporters(mod).forEach((importer) => {
+            if (importer)
+                importers.add(importer);
+        });
+    }
+    return importers;
 }
-function isVikeConfigFile(filePath) {
-    return !!getPlusFileValueConfigName(filePath);
+function getModuleImporters(mod, seen = new Set()) {
+    if (seen.has(mod))
+        return new Set();
+    seen.add(mod);
+    const importers = new Set();
+    if (mod.id)
+        importers.add(mod);
+    // Traverse through the importers (modules that import this module)
+    for (const importer of mod.importers) {
+        if (importer.id)
+            importers.add(importer);
+        getModuleImporters(importer, seen).forEach((importerTransitive) => {
+            if (importerTransitive)
+                importers.add(importerTransitive);
+        });
+    }
+    return importers;
 }

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

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

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

@@ -1,5 +1,7 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList } from '../../../../utils.js';
+export { isPlusFile };
+export { getPlusFileValueConfigName };
+import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
@@ -7,6 +9,7 @@ import { promisify } from 'util';
 import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
 import { getEnvVarObject } from '../../../../shared/getEnvVarObject.js';
 const execA = promisify(exec);
+const debug = createDebugger('vike:crawl');
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
@@ -30,17 +33,16 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem) {
             //
             !outDirRelativeFromUserRootDir.startsWith('../')));
     // Crawl
-    let files;
-    const res = !isGitCrawlDisabled() && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
-    if (res &&
-        // Fallback to fast-glob for users that dynamically generate plus files. (Assuming that no plus file is found because of the user's .gitignore list.)
-        res.length > 0) {
-        files = res;
-        // We cannot find files inside symlink directories with `$ git ls-files` => we use fast-glob
-    }
-    else {
-        files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
-    }
+    const filesGit = !isGitCrawlDisabled() && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
+    const filesGitNothingFound = !filesGit || filesGit.length === 0;
+    const filesGlob = (filesGitNothingFound || debug.isActivated) && (await fastGlob(userRootDir, outDirRelativeFromUserRootDir));
+    let files = !filesGitNothingFound
+        ? filesGit
+        : // Fallback to fast-glob for users that dynamically generate plus files. (Assuming that no plus file is found because of the user's .gitignore list.)
+            filesGlob;
+    assert(files);
+    if (debug.isActivated)
+        assert(deepEqual(filesGlob, filesGit), "Git and glob results aren't matching.");
     // Filter build files
     files = files.filter((filePath) => !isTemporaryBuildFile(filePath));
     // Normalize
@@ -49,6 +51,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem) {
         assertPosixPath(filePath);
         assert(!filePath.startsWith(userRootDir));
         const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
+        assert(isPlusFile(filePathAbsoluteUserRootDir));
         return { filePathAbsoluteUserRootDir };
     });
     return plusFiles;
@@ -69,7 +72,7 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
         preserveUTF8,
         'ls-files',
         // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
-        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}" "+*.${ext}"`),
         // Performance gain is non-negligible.
         //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
         //  - When node_modules/ is untracked the performance gain could be significant?
@@ -96,6 +99,12 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
         }
         throw err;
     }
+    if (debug.isActivated) {
+        debug('[git] userRootDir:', userRootDir);
+        debug('[git] cmd:', cmd);
+        debug('[git] result:', filesAll);
+        debug('[git] filesDeleted:', filesDeleted);
+    }
     const files = [];
     for (const filePath of filesAll) {
         // + file?
@@ -116,14 +125,21 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
 }
 // Same as gitLsFiles() but using fast-glob
 async function fastGlob(userRootDir, outDirRelativeFromUserRootDir) {
-    const files = await glob(`**/+*.${scriptFileExtensions}`, {
+    const pattern = `**/+*.${scriptFileExtensions}`;
+    const options = {
         ignore: getIgnoreAsPatterns(outDirRelativeFromUserRootDir),
         cwd: userRootDir,
         dot: false
-    });
+    };
+    const files = await glob(pattern, options);
     // Make build deterministic, in order to get a stable generated hash for dist/client/assets/entries/entry-client-routing.${hash}.js
     // https://github.com/vikejs/vike/pull/1750
     files.sort();
+    if (debug.isActivated) {
+        debug('[glob] pattern:', pattern);
+        debug('[glob] options:', options);
+        debug('[glob] result:', files);
+    }
     return files;
 }
 // Same as getIgnoreAsFilterFn() but as glob pattern
@@ -210,3 +226,37 @@ function isGitCrawlDisabled() {
     const crawSettings = getEnvVarObject('VIKE_CRAWL');
     return crawSettings?.git === false;
 }
+function isPlusFile(filePath) {
+    assertPosixPath(filePath);
+    if (isTemporaryBuildFile(filePath))
+        return false;
+    const fileName = filePath.split('/').pop();
+    return fileName.startsWith('+');
+}
+function getPlusFileValueConfigName(filePath) {
+    if (!isPlusFile(filePath))
+        return null;
+    const fileName = path.posix.basename(filePath);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
+    const basename = fileName.split('.')[0];
+    assert(basename.startsWith('+'));
+    const configName = basename.slice(1);
+    assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
+    return configName;
+}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split('/')
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join('/')
+    assertUsage(
+      !dir.includes('+'),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes('+'),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+*/

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

@@ -3,7 +3,6 @@ export { getFilesystemRouteDefinedBy };
 export { isInherited };
 export { getLocationId };
 export { sortAfterInheritanceOrder };
-export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
 export type { LocationId };
 export { getLogicalPath };
@@ -46,8 +45,6 @@ declare function getFilesystemRouteString(locationId: LocationId): string;
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
  */
 declare function getLogicalPath(locationId: LocationId, ignoredDirs: string[], removeParenthesesDirs?: true): string;
-/** Whether configs defined in `locationId` apply in every `locationIds` */
-declare function isGlobalLocation(locationId: LocationId, locationIds: LocationId[]): boolean;
 declare function sortAfterInheritanceOrder(locationId1: LocationId, locationId2: LocationId, locationIdPage: LocationId): -1 | 1 | 0;
 /** Whether configs defined at `locationId1` also apply at `locationId2` */
 declare function isInherited(locationId1: LocationId, locationId2: LocationId): boolean;

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

@@ -3,7 +3,6 @@ export { getFilesystemRouteDefinedBy };
 export { isInherited };
 export { getLocationId };
 export { sortAfterInheritanceOrder };
-export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
 // For ./filesystemRouting.spec.ts
 export { getLogicalPath };
@@ -41,10 +40,6 @@ function getLogicalPath(locationId, ignoredDirs, removeParenthesesDirs) {
     assertIsPath(logicalPath);
     return logicalPath;
 }
-/** Whether configs defined in `locationId` apply in every `locationIds` */
-function isGlobalLocation(locationId, locationIds) {
-    return locationIds.every((locId) => isInherited(locationId, locId) || locationIsRendererDir(locId));
-}
 function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     assertLocationId(locationId1);
     assertLocationId(locationId2);

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

@@ -1,5 +1,4 @@
 export { getPlusFilesAll };
-export { getPlusFileValueConfigName };
 export type { PlusFileValue };
 export type { PlusFile };
 export type { PlusFilesByLocationId };
@@ -36,4 +35,3 @@ type PlusFileValue = PlusFileCommons & {
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
 declare function getPlusFilesAll(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
-declare function getPlusFileValueConfigName(filePath: string): string | null;