vike 0.4.146 → 0.4.147-commit-2fa53b2

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

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ssr = exports.plugin = void 0;
+exports.version = exports.ssr = exports.plugin = void 0;
 exports.default = plugin;
-const utils_js_1 = require("./utils.js");
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
+const utils_js_2 = require("./utils.js");
 const buildConfig_js_1 = require("./plugins/buildConfig.js");
 const previewConfig_js_1 = require("./plugins/previewConfig.js");
 const autoFullBuild_js_1 = require("./plugins/autoFullBuild.js");
@@ -26,7 +28,7 @@ const extensionsAssets_js_1 = require("./plugins/extensionsAssets.js");
 const baseUrls_js_1 = require("./plugins/baseUrls.js");
 const envVars_js_1 = require("./plugins/envVars.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-(0, utils_js_1.markEnvAsVite)();
+(0, utils_js_2.markEnvAsVite)();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [
@@ -65,6 +67,6 @@ catch { }
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,
     get: () => {
-        (0, utils_js_1.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+        (0, utils_js_2.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });

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

@@ -4,7 +4,7 @@ exports.determineOptimizeDeps = void 0;
 const findPageFiles_js_1 = require("../../shared/findPageFiles.js");
 const utils_js_1 = require("../../utils.js");
 const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
-const getConfigValueSourcesRelevant_js_1 = require("../../shared/getConfigValueSourcesRelevant.js");
+const getConfigValueSourcesNotOverriden_js_1 = require("../../shared/getConfigValueSourcesNotOverriden.js");
 const buildConfig_js_1 = require("../buildConfig.js");
 const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
 async function determineOptimizeDeps(config, configVike, isDev) {
@@ -33,12 +33,11 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            const configValueSourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig);
-            configValueSourcesRelevant.forEach((configValueSource) => {
+            (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
                 const { definedAt, configEnv } = configValueSource;
-                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
+                if (!configEnv.client)
                     return;
                 if (definedAt.filePathRelativeToUserRootDir !== null) {
                     const { filePathAbsoluteFilesystem } = definedAt;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertConfigValueIsSerializable = exports.getConfigValuesSerialized = void 0;
+const utils_js_1 = require("../../../utils.js");
+const stringify_1 = require("@brillout/json-serializer/stringify");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
+const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
+const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfigValueSourcesNotOverriden.js");
+function getConfigValuesSerialized(pageConfig, isEnvMatch) {
+    const lines = [];
+    Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
+        const { value, configEnv } = configValuesComputed;
+        if (!isEnvMatch(configEnv))
+            return;
+        // configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return;
+        const configValue = pageConfig.configValues[configName];
+        (0, utils_js_1.assert)(configValue);
+        const { definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+    });
+    (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
+        const { configName, configEnv } = configValueSource;
+        const configValue = pageConfig.configValues[configName];
+        if (!configValue)
+            return;
+        if (!isEnvMatch(configEnv, configValueSource)) {
+            return;
+        }
+        const { value, definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+    });
+    const code = lines.join('\n');
+    return code;
+}
+exports.getConfigValuesSerialized = getConfigValuesSerialized;
+function assertConfigValueIsSerializable(value, configName, definedAt) {
+    // Contains asserts
+    getConfigValueSerialized(value, configName, definedAt);
+}
+exports.assertConfigValueIsSerializable = assertConfigValueIsSerializable;
+function getConfigValueSerialized(value, configName, definedAt) {
+    const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = (0, stringify_1.stringify)(value, { valueName, forbidReactElements: true });
+    }
+    catch (err) {
+        let serializationErrMsg = '';
+        if ((0, stringify_1.isJsonSerializerError)(err)) {
+            serializationErrMsg = err.messageCore;
+        }
+        else {
+            // When a property getter throws an error
+            console.error('Serialization error:');
+            console.error(err);
+            serializationErrMsg = 'see serialization error printed above';
+        }
+        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)({ definedAt });
+        (0, utils_js_1.assert)(configValueFilePathToShowToUser);
+        (0, utils_js_1.assertUsage)(false, [
+            `The value of the config ${picocolors_1.default.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
+            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
+        ].join(' '));
+    }
+    configValueSerialized = JSON.stringify(configValueSerialized);
+    return configValueSerialized;
+}

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

@@ -1,101 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configDefinitionsBuiltInGlobal = exports.configDefinitionsBuiltIn = void 0;
-const helpers_js_1 = require("../helpers.js");
+const utils_js_1 = require("../../../../utils.js");
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
-        env: 'server-only'
+        env: { server: true }
     },
     onRenderClient: {
-        env: 'client-only'
+        env: { client: true }
     },
     onHydrationEnd: {
-        env: 'client-only'
+        env: { client: true }
     },
     onPageTransitionStart: {
-        env: 'client-only'
+        env: { client: true }
     },
     onPageTransitionEnd: {
-        env: 'client-only'
+        env: { client: true }
     },
     onBeforeRender: {
-        env: 'server-only'
+        env: { server: true }
     },
     onBeforePrerenderStart: {
-        env: 'server-only'
+        env: { server: true }
     },
     Page: {
-        env: 'server-and-client'
+        env: { server: true, client: true }
     },
     passToClient: {
-        env: 'server-only',
+        env: { server: true, config: true },
         cumulative: true
     },
     route: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     guard: {
-        env: '_routing-lazy'
+        env: { server: true, client: 'if-client-routing' }
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     filesystemRoutingRoot: {
-        env: 'config-only'
+        env: { config: true }
     },
     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-only',
+        env: { server: true },
         _valueIsFilePath: true
     },
     clientRouting: {
-        // We could make it 'server-only' (we don't yet because of some legacy V0.4 design code)
-        env: 'server-and-client'
+        // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
+        env: { server: true, client: true, config: true, eager: true }
     },
     prerender: {
-        env: 'config-only'
+        env: { config: true }
     },
     hydrationCanBeAborted: {
-        env: 'client-only'
+        env: { client: true }
     },
     prefetchStaticAssets: {
-        env: 'client-only'
+        env: { client: true }
     },
     extends: {
-        env: 'config-only'
+        env: { config: true }
     },
     meta: {
-        env: 'config-only'
+        env: { config: true }
     },
     isClientSideRenderable: {
-        env: 'server-and-client',
-        _computed: (configValueSources) => (0, helpers_js_1.isConfigSet)(configValueSources, 'onRenderClient') &&
-            (0, helpers_js_1.isConfigSet)(configValueSources, 'Page') &&
-            (0, helpers_js_1.getConfigEnv)(configValueSources, 'Page') !== 'server-only'
+        env: { server: true, client: true, eager: true },
+        _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
+            isConfigSet(configValueSources, 'Page') &&
+            !!getConfigEnv(configValueSources, 'Page')?.client
     },
     onBeforeRenderEnv: {
-        env: 'client-only',
-        _computed: (configValueSources) => !(0, helpers_js_1.isConfigSet)(configValueSources, 'onBeforeRender') ? null : (0, helpers_js_1.getConfigEnv)(configValueSources, 'onBeforeRender')
+        env: { client: true },
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: 'server-only'
+        env: { server: true }
     },
     onBeforeRoute: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     prerender: {
-        env: 'config-only'
-    },
-    extensions: { env: 'config-only' },
-    disableAutoFullBuild: { env: 'config-only' },
-    includeAssetsImportedByServer: { env: 'config-only' },
-    baseAssets: { env: 'config-only' },
-    baseServer: { env: 'config-only' },
-    redirects: { env: 'server-only' },
-    trailingSlash: { env: 'server-only' },
-    disableUrlNormalization: { env: 'server-only' }
+        env: { config: true }
+    },
+    extensions: { env: { config: true } },
+    disableAutoFullBuild: { env: { config: true } },
+    includeAssetsImportedByServer: { env: { config: true } },
+    baseAssets: { env: { config: true } },
+    baseServer: { env: { config: true } },
+    redirects: { env: { server: true } },
+    trailingSlash: { env: { server: true } },
+    disableUrlNormalization: { env: { server: true } }
 };
 exports.configDefinitionsBuiltInGlobal = configDefinitionsBuiltInGlobal;
+function getConfigEnv(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
+    if (!configValueSource)
+        return null;
+    return configValueSource.configEnv;
+}
+function isConfigSet(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
+    // Enable users to suppress global config values by overriding the config's value to null
+    if (configValueSource?.value === null)
+        return false;
+    return !!configValueSource;
+}
+function getConfigValueSource(configValueSources, configName) {
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    (0, utils_js_1.assert)(configValueSource);
+    return configValueSource;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crawlPlusFiles = void 0;
+const utils_js_1 = require("../../../../utils.js");
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execA = (0, util_1.promisify)(child_process_1.exec);
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPosixPath)(outDirAbsoluteFilesystem);
+    (0, utils_js_1.assert)(outDirAbsoluteFilesystem.startsWith(userRootDir));
+    const outDir = path_1.default.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    (0, utils_js_1.assert)(!outDir.startsWith('.'));
+    const timeBase = new Date().getTime();
+    let files = [];
+    const res = await gitLsFiles(userRootDir, outDir);
+    if (res &&
+        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        res.length > 0) {
+        files = res;
+    }
+    else {
+        files = await fastGlob(userRootDir, outDir);
+    }
+    {
+        const time = new Date().getTime() - timeBase;
+        if (isDev) {
+            // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+            (0, utils_js_1.assertWarning)(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
+                onlyOnce: 'slow-page-files-search'
+            });
+        }
+    }
+    const plusFiles = files.map((p) => {
+        p = (0, utils_js_1.toPosixPath)(p);
+        (0, utils_js_1.assert)(!p.startsWith(userRootDir));
+        const filePathRelativeToUserRootDir = path_1.default.posix.join('/', p);
+        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, p);
+        return {
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem
+        };
+    });
+    return plusFiles;
+}
+exports.crawlPlusFiles = crawlPlusFiles;
+// Same as fastGlob() but using `$ git ls-files`
+async function gitLsFiles(userRootDir, outDir) {
+    const cmd = [
+        'git ls-files',
+        ...utils_js_1.scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        ...getIgnorePatterns(outDir).map((pattern) => `--exclude="${pattern}"`),
+        // --others lists untracked files only (but using .gitignore because --exclude-standard)
+        // --cached adds the tracked files to the output
+        '--others --cached --exclude-standard'
+    ].join(' ');
+    let stdout;
+    try {
+        const res = await execA(cmd, { cwd: userRootDir });
+        stdout = res.stdout;
+    }
+    catch (err) {
+        if (err.message.includes('not a git repository'))
+            return null;
+        throw err;
+    }
+    let files = stdout.split('\n').filter(Boolean);
+    (0, utils_js_1.assert)(!outDir.startsWith('/'));
+    files = files.filter(
+    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+    (file) => getIgnoreFilter(file, outDir));
+    return files;
+}
+// Same as gitLsFiles() but using fast-glob
+async function fastGlob(userRootDir, outDir) {
+    const files = await (0, fast_glob_1.default)(`**/+*.${utils_js_1.scriptFileExtensions}`, {
+        ignore: getIgnorePatterns(outDir),
+        cwd: userRootDir,
+        dot: false
+    });
+    return files;
+}
+// Same as getIgnoreFilter() but as glob pattern
+function getIgnorePatterns(outDir) {
+    return [
+        '**/node_modules/**',
+        `${outDir}/**`,
+        // Allow:
+        // ```
+        // +Page.js
+        // +Page.telefunc.js
+        // ```
+        '**/*.telefunc.*'
+    ];
+}
+// Same as getIgnorePatterns() but for Array.filter()
+function getIgnoreFilter(file, outDir) {
+    return !file.includes('node_modules/') && !file.includes('.telefunc.') && !file.startsWith(`${outDir}/`);
+}

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

@@ -7,7 +7,6 @@ exports.isVikeConfigFile = exports.vikeConfigDependencies = exports.reloadVikeCo
 const utils_js_1 = require("../../../utils.js");
 const path_1 = __importDefault(require("path"));
 const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
-const fast_glob_1 = __importDefault(require("fast-glob"));
 const filesystemRouting_js_1 = require("./getVikeConfig/filesystemRouting.js");
 const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
 const replaceImportStatements_js_1 = require("./replaceImportStatements.js");
@@ -18,8 +17,9 @@ const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/remove
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
 const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
-const getVirtualFilePageConfigs_js_1 = require("./getVirtualFilePageConfigs.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
+const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
+const crawlPlusFiles_js_1 = require("./getVikeConfig/crawlPlusFiles.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -75,7 +75,7 @@ async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, exten
 }
 exports.getVikeConfig = getVikeConfig;
 async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
-    const plusFiles = await findPlusFiles(userRootDir, [outDirRoot], isDev, extensions);
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, extensions);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -156,12 +156,12 @@ async function loadImportedFile(filePath, userRootDir, importedFilesLoaded) {
     return fileExports;
 }
 function isConfigEnv(configDef, configName) {
-    if (configDef.cumulative)
-        return true;
-    if (configDef.env === 'config-only')
-        return true;
-    // TODO: replace with proper `env: { config: boolean }` implementation
-    return configName === 'clientRouting';
+    const configEnv = configDef.env;
+    if (configDef.cumulative) {
+        // In principle we could lift that requirement (but it requires non-trivial modifications)
+        (0, utils_js_1.assertUsage)(configEnv.config, `Config ${picocolors_1.default.cyan(configName)} needs its ${picocolors_1.default.cyan('env')} to have ${picocolors_1.default.cyan('{ config: true }')} (because ${picocolors_1.default.cyan(configName)} is a ${picocolors_1.default.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
@@ -514,6 +514,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     else if (interfaceFile.isValueFile) {
         const valueAlreadyLoaded = 'configValue' in conf;
+        (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
@@ -528,9 +529,6 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         if (valueAlreadyLoaded) {
             configValueSource.value = conf.configValue;
         }
-        else {
-            (0, utils_js_1.assert)(configEnv !== 'config-only');
-        }
         return configValueSource;
     }
     (0, utils_js_1.assert)(false);
@@ -542,12 +540,12 @@ function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
     }
     const fileEnv = filesEnv.get(filePathForEnvCheck);
     fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => c.configEnv !== configEnv)[0];
+    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
     if (configDifferentEnv) {
         (0, utils_js_1.assertUsage)(false, [
             `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(c.configEnv)}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file/import-from-same-file'
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(JSON.stringify(c.configEnv))}`),
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
         ].join('\n'));
     }
 }
@@ -683,30 +681,17 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
             (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}`)} to a value with an invalid type ${picocolors_1.default.cyan(typeof def)}: it should be an object instead.`);
         }
         // env
+        let configEnv;
         {
-            const envValues = [
-                'client-only',
-                'server-only',
-                'server-and-client',
-                'config-only'
-            ];
-            const fix = [
-                `Set the value of ${picocolors_1.default.cyan(`meta.${configName}.env`)} to `,
-                (0, utils_js_1.joinEnglish)(envValues.map((s) => picocolors_1.default.cyan(`'${s}'`)), 'or'),
-                '.'
-            ].join('');
+            (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
             if (!('env' in def)) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} doesn't set ${picocolors_1.default.cyan(`meta.${configName}.env`)} but it's required. ${fix}`);
-            }
-            if (!(0, utils_js_1.hasProp)(def, 'env', 'string')) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to an invalid type ${picocolors_1.default.cyan(typeof def.env)}. ${fix}`);
-            }
-            if (!envValues.includes(def.env)) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to an unknown value ${picocolors_1.default.cyan(`'${def.env}'`)}. ${fix}`);
+                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} doesn't set ${picocolors_1.default.cyan(`meta.${configName}.env`)} but it's required.`);
             }
+            configEnv = getConfigEnvValue(def.env, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to`);
+            // Overwrite deprecated value with valid value
+            // TODO/v1-release: remove once support for the deprecated values is removed
+            if (typeof def.env === 'string')
+                def.env = configEnv;
         }
         // effect
         if ('effect' in def) {
@@ -714,9 +699,9 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
                 (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
                 (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} to an invalid type ${picocolors_1.default.cyan(typeof def.effect)}: it should be a function instead`);
             }
-            if (def.env !== 'config-only') {
+            if (!configEnv.config) {
                 (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env is ${picocolors_1.default.cyan('config-only')} (but it's ${picocolors_1.default.cyan(def.env)} instead)`);
+                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${picocolors_1.default.cyan('{ config: true }')} (but it's ${picocolors_1.default.cyan(JSON.stringify(configEnv))} instead)`);
             }
         }
     });
@@ -727,8 +712,8 @@ function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
             return;
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
         // (We could support effect for non config-only by always loading its value at config time, regardless of the config's `env` value.)
-        (0, utils_js_1.assertUsage)(configDef.env === 'config-only', [
-            `Cannot add effect to ${picocolors_1.default.cyan(configName)} because its ${picocolors_1.default.cyan('env')} is ${picocolors_1.default.cyan(configDef.env)}: effects can only be added to configs with an ${picocolors_1.default.cyan('env')} value of ${picocolors_1.default.cyan('config-only')}.`
+        (0, utils_js_1.assertUsage)(configDef.env.config, [
+            `Cannot add effect to ${picocolors_1.default.cyan(configName)} because its ${picocolors_1.default.cyan('env')} is ${picocolors_1.default.cyan(JSON.stringify(configDef.env))}: effects can only be added to configs with an ${picocolors_1.default.cyan('env')} with ${picocolors_1.default.cyan('{ config: true }')}.`
         ].join(' '));
         const source = configValueSources[configName]?.[0];
         if (!source)
@@ -796,39 +781,9 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
-    const timeBase = new Date().getTime();
-    (0, utils_js_1.assertPosixPath)(userRootDir);
-    const ignorePatterns = [];
-    for (const dir of ignoreDirs) {
-        (0, utils_js_1.assertPosixPath)(dir);
-        ignorePatterns.push(`${path_1.default.posix.relative(userRootDir, dir)}/**`);
-    }
-    const result = await (0, fast_glob_1.default)(`**/+*.${utils_js_1.scriptFileExtensions}`, {
-        ignore: [
-            '**/node_modules/**',
-            // Allow:
-            // ```
-            // +Page.js
-            // +Page.telefunc.js
-            // ```
-            '**/*.telefunc.*',
-            ...ignorePatterns
-        ],
-        cwd: userRootDir,
-        dot: false
-    });
-    const time = new Date().getTime() - timeBase;
-    if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-        (0, utils_js_1.assertWarning)(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
-            onlyOnce: 'slow-page-files-search'
-        });
-    }
-    const plusFiles = result.map((p) => {
-        p = (0, utils_js_1.toPosixPath)(p);
-        const filePathRelativeToUserRootDir = path_1.default.posix.join('/', p);
-        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, p);
+async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
+    const files = await (0, crawlPlusFiles_js_1.crawlPlusFiles)(userRootDir, outDirRoot, isDev);
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
         return {
             filePathRelativeToUserRootDir,
             filePathAbsoluteVite: filePathRelativeToUserRootDir,
@@ -1046,7 +1001,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
-    (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv === 'config-only');
+    (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv.config);
     // Eagerly loaded since it's config-only
     (0, utils_js_1.assert)('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
@@ -1143,7 +1098,7 @@ function mergeCumulative(configName, configValueSources) {
         // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
         (0, utils_js_1.assert)('value' in configValueSource);
         // Make sure configValueSource.value is serializable
-        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, getDefinedAt(configValueSource));
+        (0, getConfigValuesSerialized_js_1.assertConfigValueIsSerializable)(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1184,3 +1139,35 @@ function mergeCumulative(configName, configValueSources) {
     }
     (0, utils_js_1.assert)(false);
 }
+function getConfigEnvValue(val, errMsgIntro) {
+    const errInvalidValue = `${errMsgIntro} an invalid value ${picocolors_1.default.cyan(JSON.stringify(val))}`;
+    // Legacy outdated values
+    if (typeof val === 'string') {
+        const valConverted = (() => {
+            if (val === 'client-only')
+                return { client: true };
+            if (val === 'server-only')
+                return { server: true };
+            if (val === 'server-and-client')
+                return { server: true, client: true };
+            if (val === 'config-only')
+                return { config: true };
+            if (val === '_routing-lazy')
+                return { server: true, client: 'if-client-routing' };
+            if (val === '_routing-eager')
+                return { server: true, client: 'if-client-routing', eager: true };
+            (0, utils_js_1.assertUsage)(false, errInvalidValue);
+        })();
+        (0, utils_js_1.assertWarning)(false, `${errMsgIntro} ${picocolors_1.default.cyan(val)} which is deprecated and will be removed in the next major release`, { onlyOnce: true });
+        return valConverted;
+    }
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(val), `${errMsgIntro} an invalid type ${picocolors_1.default.cyan(typeof val)}`);
+    (0, utils_js_1.assertKeys)(val, ['config', 'server', 'client'], `${errInvalidValue}:`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(val, 'config', 'undefined') || (0, utils_js_1.hasProp)(val, 'config', 'boolean'), errInvalidValue);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(val, 'server', 'undefined') || (0, utils_js_1.hasProp)(val, 'server', 'boolean'), errInvalidValue);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(val, 'client', 'undefined') || (0, utils_js_1.hasProp)(val, 'client', 'boolean'), errInvalidValue);
+    /* Uncomment to allow users to set an eager config. Same for `{ client: 'if-client-routing' }`.
+    assertUsage(hasProp(val, 'eager', 'undefined') || hasProp(val, 'eager', 'boolean'), errInvalidValue)
+    */
+    return val;
+}