vike 0.4.230 → 0.4.231-commit-a0ca5e4

package/dist/esm/node/{plugin/plugins/importUserCode/index.js → vite/plugins/pluginVirtualFiles.js}

@@ -1,27 +1,27 @@
-export { importUserCode };
+export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
-import { getVirtualFilePageConfigValuesAll } from './v1-design/virtual-files/getVirtualFilePageConfigValuesAll.js';
-import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-import { assert, assertPosixPath } from '../../utils.js';
-import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../../shared/virtual-files.js';
-import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { reloadVikeConfig, isV1Design, getVikeConfig, getVikeConfigOptional } from './v1-design/getVikeConfig.js';
+import { getVirtualFilePageConfigLazy } from './pluginVirtualFiles/getVirtualFilePageConfigLazy.js';
+import { getVirtualFileEntry } from './pluginVirtualFiles/getVirtualFileEntry.js';
+import { assert, assertPosixPath, isScriptFile } from '../utils.js';
+import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
+import { isVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { isVirtualFileIdEntry } from '../../shared/virtualFiles/virtualFileEntry.js';
+import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
 import pc from '@brillout/picocolors';
-import { logConfigInfo } from '../../shared/loggerNotProd.js';
-import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
-import { updateUserFiles } from '../../../runtime/globalContext.js';
-import { isPlusFile } from './v1-design/getVikeConfig/crawlPlusFiles.js';
-function importUserCode() {
+import { logConfigInfo } from '../shared/loggerNotProd.js';
+import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { updateUserFiles } from '../../runtime/globalContext.js';
+import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
+import { vikeConfigHasError } from '../../runtime/renderPage.js';
+import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
+function pluginVirtualFiles() {
     let config;
-    let vikeConfig;
     return {
-        name: 'vike:importUserCode',
+        name: 'vike:pluginVirtualFiles',
         async configResolved(config_) {
-            vikeConfig = await getVikeConfig(config_);
             config = config_;
             // TODO/v1-release: remove
-            if (!isV1Design(config))
+            if (!isV1Design())
                 config.experimental.importGlobRestoreExtension = true;
         },
         resolveId(id) {
@@ -45,12 +45,12 @@ function importUserCode() {
             id = getVirtualFileId(id);
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
-            if (isVirtualFileIdPageConfigValuesAll(id)) {
-                const code = await getVirtualFilePageConfigValuesAll(id, isDev, config);
+            if (isVirtualFileIdPageConfigLazy(id)) {
+                const code = await getVirtualFilePageConfigLazy(id, isDev, config);
                 return code;
             }
-            if (isVirtualFileIdImportUserCode(id)) {
-                const code = await getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev);
+            if (isVirtualFileIdEntry(id)) {
+                const code = await getVirtualFileEntry(id, options, config, isDev);
                 return code;
             }
         },
@@ -65,9 +65,31 @@ function handleFileAddRemove(server, config) {
     return;
     async function listener(file, isRemove) {
         file = normalizePath(file);
-        if (isPlusFile(file) || (await isVikeConfigDependency(file, server.moduleGraph))?.modifiesVikeVirtualFiles) {
-            invalidateVikeVirtualFiles(server);
-            reloadConfig(file, config, isRemove ? 'removed' : 'created');
+        if (isTemporaryBuildFile(file))
+            return;
+        const { moduleGraph } = server;
+        const isVikeConfig = await isVikeConfigDependency(file, moduleGraph);
+        const reload = () => reloadConfig(file, config, isRemove ? 'removed' : 'created', server);
+        if (isVikeConfig) {
+            if (isVikeConfig.isNotProcessedByVite) {
+                reload();
+            }
+            else {
+                // Let Vite handle it
+                assert(existsInViteModuleGraph(file, moduleGraph));
+            }
+        }
+        else {
+            // Trick: when importing a file that doesn't exist => we don't know whether `file` is that missing file => we take a leap of faith when the conditions below are met.
+            // - Not sure how reliable that trick is.
+            // - Reloading Vike's config is cheap and file creation/removal is rare => the trick is worth it.
+            // - Reproduction:
+            //   ```bash
+            //   rm someDep.js && sleep 2 && git checkout someDep.js
+            //   ```
+            if (isScriptFile(file) && vikeConfigHasError() && !existsInViteModuleGraph(file, moduleGraph)) {
+                reload();
+            }
         }
     }
 }
@@ -77,60 +99,67 @@ function invalidateVikeVirtualFiles(server) {
         server.moduleGraph.invalidateModule(mod);
     });
 }
+// Vite calls its hook handleHotUpdate() whenever *any file* is modified — including files that aren't in Vite's module graph such as `pages/+config.js`
 async function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
     const isVikeConfig = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
-        if (isVikeConfig.modifiesVikeVirtualFiles) {
+        if (isVikeConfig.isNotProcessedByVite) {
             /* 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');
+            reloadConfig(file, config, 'modified', server);
+            // Files such as `pages/+config.js` can potentially modify Vike's virtual files.
             // 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()
+            // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
             updateUserFiles();
         }
     }
 }
 async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
-    // Check config-only files, for example all pages/+config.js dependencies. (There aren't part of Vite's module graph.)
+    // Non-runtime Vike config files such as `pages/+config.js` which aren't processed by Vite.
+    // - They're missing in Vite's module graph.
+    // - Potentially modifies Vike's virtual files.
+    // - Same for all `pages/+config.js` dependencies.
     assertPosixPath(filePathAbsoluteFilesystem);
-    const vikeConfigObject = await getVikeConfigOptional();
+    const vikeConfigObject = await getVikeConfigInternalOptional();
     if (vikeConfigObject) {
-        const { vikeConfigDependencies } = vikeConfigObject;
+        const { _vikeConfigDependencies: vikeConfigDependencies } = vikeConfigObject;
         vikeConfigDependencies.forEach((f) => assertPosixPath(f));
         if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
-            return { modifiesVikeVirtualFiles: true };
+            return { isNotProcessedByVite: true };
     }
-    // Check using Vite's module graph, for example all +htmlAttributes dependencies.
-    // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
+    // Runtime Vike config files such as +data.js which are processed by Vite.
+    // - They're included in Vite's module graph.
+    // - They never modify Vike's virtual files.
+    // - Same for all `+data.js` dependencies.
     const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
     const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
     if (isPlusValueFileDependency)
-        return { modifiesVikeVirtualFiles: false };
+        return { isNotProcessedByVite: false };
     return null;
 }
-function reloadConfig(filePath, config, op) {
+function reloadConfig(filePath, config, op, server) {
+    // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
+    invalidateVikeVirtualFiles(server);
     {
         const filePathToShowToUserResolved = getModuleFilePathAbsolute(filePath, config);
         const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config);
+    reloadVikeConfig();
     updateUserFiles();
 }
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
-        .filter((url) => isVirtualFileIdPageConfigValuesAll(url) || isVirtualFileIdImportUserCode(url))
+        .filter((url) => isVirtualFileIdPageConfigLazy(url) || isVirtualFileIdEntry(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);
@@ -170,3 +199,6 @@ function getModuleImporters(mod, seen = new Set()) {
     }
     return importers;
 }
+function existsInViteModuleGraph(file, moduleGraph) {
+    return !!moduleGraph.getModulesByFile(file);
+}

package/dist/esm/node/vite/plugins/pluginWorkaroundCssModuleHmr.d.ts

@@ -0,0 +1,3 @@
+export { pluginWorkaroundCssModuleHmr };
+import type { Plugin } from 'vite';
+declare function pluginWorkaroundCssModuleHmr(): Plugin;

package/dist/esm/node/{plugin/plugins/workaroundCssModuleHmr.js → vite/plugins/pluginWorkaroundCssModuleHmr.js}

@@ -1,7 +1,7 @@
-export { workaroundCssModuleHmr };
-function workaroundCssModuleHmr() {
+export { pluginWorkaroundCssModuleHmr };
+function pluginWorkaroundCssModuleHmr() {
     return {
-        name: 'vike:workaroundCssModuleHmr',
+        name: 'vike:pluginWorkaroundCssModuleHmr',
         handleHotUpdate(ctx) {
             // prevent full reload due to non self-accepting css module.
             // here only "?direct" module should be filtered out as it doesn't have a parent module.

package/dist/esm/node/vite/plugins/pluginWorkaroundVite6HmrRegression.d.ts

@@ -0,0 +1,3 @@
+export { pluginWorkaroundVite6HmrRegression };
+import type { Plugin } from 'vite';
+declare function pluginWorkaroundVite6HmrRegression(): Plugin;

package/dist/esm/node/{plugin/plugins/workaroundVite6HmrRegression.js → vite/plugins/pluginWorkaroundVite6HmrRegression.js}

@@ -1,11 +1,11 @@
-export { workaroundVite6HmrRegression };
+export { pluginWorkaroundVite6HmrRegression };
 // https://vite.dev/guide/migration (will be 404 after vite@7 release) > search for `hmrReload()`
 // https://v6.vite.dev/guide/migration (will exist after vite@7 release) > search for `hmrReload()`
 // Workaround seems to work for docs page /banner (which is HTML-only)
 // But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
-function workaroundVite6HmrRegression() {
+function pluginWorkaroundVite6HmrRegression() {
     return {
-        name: 'vike:workaroundVite6HmrRegression',
+        name: 'vike:pluginWorkaroundVite6HmrRegression',
         enforce: 'post',
         hotUpdate: {
             order: 'post',

package/dist/esm/node/{plugin → vite}/shared/getFilePath.d.ts

@@ -6,7 +6,7 @@ export { getModuleFilePathAbsolute };
 export { getModuleFilePathRelative };
 export { cleanFilePathUnkown };
 export { assertModuleId };
-import type { FilePathResolved, FilePathUnresolved } from '../../../shared/page-configs/FilePath.js';
+import type { FilePathResolved, FilePathUnresolved } from '../../../types/FilePath.js';
 import type { ResolvedConfig } from 'vite';
 declare function getFilePathResolved(args: {
     userRootDir: string;

package/dist/esm/node/{plugin → vite}/shared/getHttpRequestAsyncStore.js

@@ -10,7 +10,7 @@ export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
 import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
 import { assert, assertIsNotProductionRuntime, isObject, unique } from '../utils.js';
-import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
+import { getConfigBuildErrorFormatted } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
 import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 import { isDeepStrictEqual } from 'node:util';

package/dist/esm/node/{plugin → vite}/shared/loggerNotProd.d.ts

@@ -16,7 +16,7 @@ type LogInfo = (...args: LogInfoArgs) => void;
 type LogInfoArgs = Parameters<typeof logRuntimeInfo>;
 type LogError = (...args: LogErrorArgs) => void;
 type LogErrorArgs = Parameters<typeof logRuntimeError>;
-declare function logRuntimeInfo(msg: string, httpRequestId: number, logType: LogType): void;
+declare function logRuntimeInfo(msg: string, httpRequestId: number | null, logType: LogType): void;
 declare function logViteAny(msg: string, logType: LogType, httpRequestId: number | null, prependViteTag: boolean): void;
 declare function logConfigInfo(msg: string, logType: LogType): void;
 declare function logConfigErrorRecover(): void;

package/dist/esm/node/{plugin → vite}/shared/loggerNotProd.js

@@ -11,13 +11,13 @@ export { logConfigError };
 export { logConfigErrorRecover };
 export { logErrorDebugNote };
 import { isAbortError } from '../../../shared/route/abort.js';
-import { getViteConfig } from '../../runtime/globalContext.js';
-import { overwriteRuntimeProductionLogger } from '../../runtime/renderPage/loggerRuntime.js';
+import { getViteConfig, vikeConfigErrorRecoverMsg } from '../../runtime/globalContext.js';
+import { overwriteRuntimeProductionLogger } from '../../runtime/loggerRuntime.js';
 import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from '../../shared/isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
+import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { logWithVikeTag, logWithViteTag, logDirectly, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';
 import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
@@ -28,7 +28,6 @@ overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
 overwriteAssertProductionLogger(assertLogger);
 function logRuntimeInfo(msg, httpRequestId, logType) {
     const category = getCategory(httpRequestId);
-    assert(category);
     logWithVikeTag(msg, logType, category);
 }
 function logViteAny(msg, logType, httpRequestId, prependViteTag) {
@@ -45,9 +44,8 @@ function logConfigInfo(msg, logType) {
     logWithVikeTag(msg, logType, category);
 }
 function logConfigErrorRecover() {
-    const msg = pc.bold(pc.green('Configuration successfully loaded'));
     const category = getConfigCategory();
-    logWithVikeTag(msg, 'error-recover', category);
+    logWithVikeTag(vikeConfigErrorRecoverMsg, 'error-recover', category);
 }
 function logRuntimeError(err, 
 // httpRequestId is `null` when pre-rendering

package/dist/esm/node/{plugin → vite}/shared/loggerVite.js

@@ -31,7 +31,7 @@ function intercept(logType, config) {
             // We swallow Vite's message: we didn't see it add any value so far.
             //  - It can even be confusing, such as the following:
             //    ```
-            //    Error when evaluating SSR module virtual:vike:pageConfigValuesAll:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    Error when evaluating SSR module virtual:vike:pageConfigLazy:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
             //    ```
             assert(!isErrorDebug());
             return;

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/assertExtensions.d.ts

@@ -1,6 +1,5 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
 import type { PlusFile } from './getPlusFilesAll.js';
-import { PageConfigBuildTime } from '../../../../../../shared/page-configs/PageConfig.js';
 declare function assertExtensionsConventions(plusFile: PlusFile): void;
-declare function assertExtensionsRequire(pageConfig: PageConfigBuildTime): void;
+declare function assertExtensionsRequire(plusFiles: PlusFile[]): void;

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/assertExtensions.js

@@ -1,9 +1,8 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
 import pc from '@brillout/picocolors';
-import { isObjectOfStrings } from '../../../../../../utils/isObjectOfStrings.js';
-import { PROJECT_VERSION, assert, assertUsage, assertWarning, findPackageJson } from '../../../../utils.js';
-import { getConfVal } from '../getVikeConfig.js';
+import { PROJECT_VERSION, assert, assertUsage, assertWarning, findPackageJson, isObject } from '../../utils.js';
+import { getConfVal } from '../resolveVikeConfigInternal.js';
 import path from 'path';
 import semver from 'semver';
 function assertExtensionsConventions(plusFile) {
@@ -28,8 +27,8 @@ function assertExtensionName(plusFile) {
     const name = getNameValue(plusFile);
     assertUsage(name, `Vike extension name missing: the config ${filePathToShowToUser} must define the setting ${pc.cyan('name')}`);
 }
-function assertExtensionsRequire(pageConfig) {
-    const plusFilesRelevantList = pageConfig.plusFiles;
+function assertExtensionsRequire(plusFiles) {
+    const plusFilesRelevantList = plusFiles;
     // Collect extensions
     const extensions = {};
     plusFilesRelevantList.forEach((plusFile) => {
@@ -41,34 +40,57 @@ function assertExtensionsRequire(pageConfig) {
     });
     // Enforce `require`
     plusFilesRelevantList.forEach((plusFile) => {
-        const require = getConfigRequireValue(plusFile);
+        const require = resolveRequireSetting(plusFile);
         if (!require)
             return;
         const name = getNameValue(plusFile);
         const filePathToShowToUser = getFilePathToShowToUser(plusFile);
         assertUsage(name, `Setting ${pc.bold('name')} is required for being able to use setting ${pc.bold('require')} in ${filePathToShowToUser}.`);
-        Object.entries(require).forEach(([reqName, reqVersion]) => {
+        Object.entries(require).forEach(([reqName, req]) => {
             const errBase = `${pc.bold(name)} requires ${pc.bold(reqName)}`;
             if (reqName === 'vike') {
-                assertUsage(isVersionRange(PROJECT_VERSION, reqVersion), `${errBase} version ${pc.bold(reqVersion)}, but ${pc.bold(PROJECT_VERSION)} is installed.`);
+                let errMsg = `${errBase} version ${pc.bold(req.version)}, but ${pc.bold(PROJECT_VERSION)} is installed.`;
+                if (req.optional) {
+                    errMsg += " Either update it, or remove it (it's an optional peer dependency).";
+                }
+                assertUsage(isVersionRange(PROJECT_VERSION, req.version), errMsg);
                 return;
             }
             const extensionVersion = extensions[reqName];
-            assertUsage(extensionVersion, `${errBase}.`);
-            assertUsage(isVersionRange(extensionVersion, reqVersion), `${errBase} version ${pc.bold(reqVersion)}, but ${pc.bold(extensionVersion)} is installed.`);
+            if (!extensionVersion) {
+                if (req.optional) {
+                    return;
+                }
+                else {
+                    assertUsage(false, `${errBase}.`);
+                }
+            }
+            assertUsage(isVersionRange(extensionVersion, req.version), `${errBase} version ${pc.bold(req.version)}, but ${pc.bold(extensionVersion)} is installed.`);
         });
     });
 }
-function getConfigRequireValue(plusFile) {
+function resolveRequireSetting(plusFile) {
     const confVal = getConfVal(plusFile, 'require');
     if (!confVal)
         return null;
     assert(confVal.valueIsLoaded);
-    const require = confVal.value;
+    const requireValue = confVal.value;
     const { filePathToShowToUserResolved } = plusFile.filePath;
     assert(filePathToShowToUserResolved);
-    assertUsage(isObjectOfStrings(require), `The setting ${pc.bold('require')} defined at ${filePathToShowToUserResolved} should be an object with string values (${pc.bold('Record<string, string>')}).`);
-    return require;
+    assertUsage(isObject(requireValue), `The setting ${pc.bold('+require')} defined at ${filePathToShowToUserResolved} should be an object`);
+    const requireSetting = {};
+    Object.entries(requireValue).forEach(([reqName, req]) => {
+        if (typeof req === 'string') {
+            requireSetting[reqName] = { version: req, optional: false };
+            return;
+        }
+        if (isObject(req)) {
+            requireSetting[reqName] = req;
+            return;
+        }
+        assertUsage(false, `Invalid +require[${JSON.stringify(reqName)}] value ${pc.cyan(JSON.stringify(req))}`);
+    });
+    return requireSetting;
 }
 function getNameValue(plusFile) {
     const confVal = getConfVal(plusFile, 'name');

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/configDefinitionsBuiltIn.d.ts

@@ -1,16 +1,18 @@
 export { configDefinitionsBuiltIn };
 export type { ConfigDefinition };
 export type { ConfigDefinitions };
+export type { ConfigDefinitionsInternal };
 export type { ConfigDefinitionInternal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
-import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../../../shared/page-configs/Config.js';
-import { type ConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
+import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFilePath } from '../../../../types/PageConfig.js';
+import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
+import { type ConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
 /** The meta definition of a config.
  *
  * https://vike.dev/meta
  */
-type ConfigDefinition = {
+type ConfigDefinition = ConfigDefinition_ | ConfigDefinitionDefinedByPeerDependency;
+type ConfigDefinition_ = {
     /** In what environment(s) the config value is loaded.
      *
      * https://vike.dev/meta
@@ -47,7 +49,12 @@ type ConfigDefinition = {
     global?: boolean | ((value: unknown, moreInfo: {
         isGlobalLocation: boolean;
     }) => boolean);
-    type?: string | string[];
+};
+type ConfigDefinitionDefinedByPeerDependency = {
+    /**
+     * Omit the "unknown config" error without defining the config — useful for optional peer dependencies: for example, vike-server sets +stream.require which is defined by vike-{react,vue,solid} but some users don't use vike-{react,vue,solid}
+     */
+    isDefinedByPeerDependency: true;
 };
 /**
  * Function called when the config value is defined.
@@ -67,13 +74,15 @@ type ConfigEffect = (config: {
     configDefinedAt: ConfigDefinedAt;
 }) => Config | undefined;
 /** For Vike internal use */
-type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
+type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
     _computed?: (configValueSources: ConfigValueSources) => unknown;
     _valueIsFilePath?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;
 };
 type ConfigDefinitions = Record<string, // configName
+ConfigDefinition>;
+type ConfigDefinitionsInternal = Record<string, // configName
 ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameGlobal, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/configDefinitionsBuiltIn.js

@@ -1,6 +1,6 @@
 export { configDefinitionsBuiltIn };
-import { assert, assertUsage } from '../../../../utils.js';
-import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
+import { assert, assertUsage } from '../../utils.js';
+import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true }
@@ -176,54 +176,41 @@ const configDefinitionsBuiltIn = {
     prerender: {
         env: { config: true },
         global: (value, { isGlobalLocation }) => typeof value === 'object' || isGlobalLocation,
-        type: ['boolean', 'object'],
         cumulative: true
     },
-    vite: { env: { config: true }, global: true, cumulative: true, type: 'object' },
+    vite: { env: { config: true }, global: true, cumulative: true },
     disableAutoFullBuild: {
         env: { config: true },
-        global: true,
-        type: [
-            'boolean',
-            // Can be 'prerender'
-            'string'
-        ]
+        global: true
     },
     vite6BuilderApp: {
         env: { config: true },
-        global: true,
-        type: 'boolean'
+        global: true
     },
     includeAssetsImportedByServer: {
         env: { config: true },
-        global: true,
-        type: 'boolean'
+        global: true
     },
     baseAssets: {
         env: { config: true, server: true },
-        global: true,
-        type: 'string'
+        global: true
     },
     baseServer: {
         env: { config: true, server: true },
-        global: true,
-        type: 'string'
+        global: true
     },
     redirects: {
         env: { server: true },
         global: true,
-        type: 'string{}',
         cumulative: true
     },
     trailingSlash: {
         env: { server: true },
-        global: true,
-        type: 'boolean'
+        global: true
     },
     disableUrlNormalization: {
         env: { server: true },
-        global: true,
-        type: 'boolean'
+        global: true
     }
 };
 function getConfigEnv(configValueSources, configName) {

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/crawlPlusFiles.js

@@ -1,13 +1,13 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish } from '../../../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish } from '../../utils.js';
 import path from 'path';
 import { glob } from 'tinyglobby';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
-import { getEnvVarObject } from '../../../../shared/getEnvVarObject.js';
+import { getEnvVarObject } from '../getEnvVarObject.js';
 import pc from '@brillout/picocolors';
 import picomatch from 'picomatch';
 import { ignorePatternsBuiltIn } from './crawlPlusFiles/ignorePatternsBuiltIn.js';

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/filesystemRouting.js

@@ -7,7 +7,7 @@ export { applyFilesystemRoutingRootEffect };
 // For ./filesystemRouting.spec.ts
 export { getLogicalPath };
 import pc from '@brillout/picocolors';
-import { assert, assertIsNotProductionRuntime, assertPosixPath, assertWarning, higherFirst } from '../../../../utils.js';
+import { assert, assertIsNotProductionRuntime, assertPosixPath, assertWarning, higherFirst } from '../../utils.js';
 assertIsNotProductionRuntime();
 /**
  * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/getConfigFileExport.js

@@ -1,7 +1,7 @@
 export { getConfigFileExport };
 import pc from '@brillout/picocolors';
-import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
-import { assertUsage, isObject } from '../../../../utils.js';
+import { assertPlusFileExport } from '../../../../shared/page-configs/assertPlusFileExport.js';
+import { assertUsage, isObject } from '../../utils.js';
 function getConfigFileExport(fileExports, filePathToShowToUser) {
     assertPlusFileExport(fileExports, filePathToShowToUser, 'config');
     const usesNamedExport = !!fileExports.config;

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/getPlusFilesAll.d.ts

@@ -5,7 +5,7 @@ export type { PlusFilesByLocationId };
 import { type LocationId } from './filesystemRouting.js';
 import { type EsbuildCache } from './transpileAndExecuteFile.js';
 import { PointerImportLoaded } from './loadFileAtConfigTime.js';
-import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
+import type { FilePathResolved } from '../../../../types/FilePath.js';
 type PlusFile = PlusFileConfig | PlusFileValue;
 type PlusFileCommons = {
     locationId: LocationId;

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig → vite/shared/resolveVikeConfigInternal}/getPlusFilesAll.js

@@ -1,13 +1,13 @@
 export { getPlusFilesAll };
-import { assert } from '../../../../utils.js';
+import { assert } from '../../utils.js';
 import { configDefinitionsBuiltIn } from './configDefinitionsBuiltIn.js';
 import { getLocationId } from './filesystemRouting.js';
 import { crawlPlusFiles, getPlusFileValueConfigName } from './crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadValueFile } from './loadFileAtConfigTime.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
-import { getFilePathResolved } from '../../../../shared/getFilePath.js';
-import { assertExtensionsConventions } from './assertExtensions.js';
+import { getFilePathResolved } from '../getFilePath.js';
+import { assertExtensionsConventions, assertExtensionsRequire } from './assertExtensions.js';
 async function getPlusFilesAll(userRootDir, esbuildCache) {
     const plusFiles = await findPlusFiles(userRootDir);
     const configFiles = [];
@@ -80,8 +80,14 @@ async function getPlusFilesAll(userRootDir, esbuildCache) {
     Object.entries(plusFilesAll).forEach(([_locationId, plusFiles]) => {
         plusFiles.sort(sortMakeDeterministic);
     });
+    assertPlusFiles(plusFilesAll);
     return plusFilesAll;
 }
+function assertPlusFiles(plusFilesAll) {
+    const plusFiles = Object.values(plusFilesAll).flat();
+    // The earlier we call it the better, so that +require can be used by Vike extensions to depend on new Vike features
+    assertExtensionsRequire(plusFiles);
+}
 function getPlusFileFromConfigFile(configFile, isExtensionConfig, locationId, userRootDir) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const fileExportsByConfigName = {};