vike 0.4.259 → 0.4.260

package/dist/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -3,6 +3,7 @@ export { resolveOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert } from '../../../../utils/assert.js';
 import { createDebug } from '../../../../utils/debug.js';
+import { deepEqual } from '../../../../utils/deepEqual.js';
 import { isArray } from '../../../../utils/isArray.js';
 import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { assertImportIsNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
@@ -24,8 +25,12 @@ const LATE_DISCOVERED = [
     // Workaround for https://github.com/vikejs/vike/issues/2823#issuecomment-3514325487
     '@compiled/react/runtime',
 ];
-// TO-DO/eventually: remove this.
-// Avoid following warning for older vike-photon versions:
+// TO-DO/eventually: remove this workaround using following plan:
+// 1. Remove `include: ["vike > @brillout/require-shim"]` from vike-photon
+//    https://github.com/vikejs/vike-photon/blob/e11edb617ae44da6c1748222c387b10bf3fa5495/packages/vike-photon/src/plugin/plugins/configPlugin.ts#L16-L17
+// 2. Release new vike-photon version
+// 2. Remove this workaround
+// Even though Vike doesn't use @brillout/require-shim anymore, it's still needed because vike-photon adds @brillout/require-shim to optimizeDeps.include which leads to this error:
 // ```
 // [11:32:49.768][/test/photon-vercel/.test-dev.test.ts][pnpm run dev][stderr] Failed to resolve dependency: vike > @brillout/require-shim, present in ssr 'optimizeDeps.include'
 // ```
@@ -70,9 +75,9 @@ const optimizeDeps = {
 // - Make server environments inherit from ssr.optimizeDeps (it isn't the case by default)
 async function resolveOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
-    const { _pageConfigs: pageConfigs } = vikeConfig;
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
     // Retrieve user's + files (i.e. Vike entries)
-    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs, pageConfigGlobal);
     // Add late discovered dependencies, if they exist
     LATE_DISCOVERED.forEach((dep) => {
         const userRootDir = config.root;
@@ -114,18 +119,19 @@ async function resolveOptimizeDeps(config) {
         env.optimizeDeps.entries = remove(env.optimizeDeps.entries ?? []);
     }
     // Debug
-    if (debug.isActivated)
-        debug('optimizeDeps', {
-            'config.optimizeDeps.entries': config.optimizeDeps.entries,
-            'config.optimizeDeps.include': config.optimizeDeps.include,
-            'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
-            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
-            'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
-            'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
-            'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
-        });
+    if (debug.isActivated) {
+        const envs = {};
+        for (const envName in config.environments) {
+            const env = config.environments[envName];
+            envs[`config.environments.${envName}.optimizeDeps.entries`] = env.optimizeDeps.entries;
+            envs[`config.environments.${envName}.optimizeDeps.include`] = env.optimizeDeps.include;
+            envs[`config.environments.${envName}.optimizeDeps.exclude`] = env.optimizeDeps.exclude;
+        }
+        debug('optimizeDeps', envs);
+        assertEnvsInSyncWithLegacy(config);
+    }
 }
-async function getPageDeps(config, pageConfigs) {
+async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
     let entriesClient = [];
     let entriesServer = [];
     let includeClient = [];
@@ -158,6 +164,14 @@ async function getPageDeps(config, pageConfigs) {
             includeServer.push(e);
         }
     };
+    const addEntryOrInclude = (filePath, isForClientSide, definedAt) => {
+        if (filePath.filePathAbsoluteUserRootDir !== null) {
+            addEntry(filePath.filePathAbsoluteFilesystem, isForClientSide, definedAt);
+        }
+        else {
+            addInclude(filePath.importPathAbsolute, isForClientSide, definedAt);
+        }
+    };
     const isExcluded = (e, isForClientSide, definedAt) => {
         const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
         if (!exclude)
@@ -173,7 +187,8 @@ async function getPageDeps(config, pageConfigs) {
     {
         ;
         [true, false].forEach((isForClientSide) => {
-            pageConfigs.forEach((pageConfig) => {
+            ;
+            [...pageConfigs, pageConfigGlobal].forEach((pageConfig) => {
                 Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
                     const runtimeEnv = {
                         isForClientSide,
@@ -188,16 +203,7 @@ async function getPageDeps(config, pageConfigs) {
                         const { definedAt } = configValueSource;
                         if (definedAt.definedBy)
                             return;
-                        if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                            addEntry(
-                            // optimizeDeps.entries expects filesystem absolute paths
-                            definedAt.filePathAbsoluteFilesystem, isForClientSide, definedAt);
-                        }
-                        else {
-                            addInclude(
-                            // optimizeDeps.include expects npm packages
-                            definedAt.importPathAbsolute, isForClientSide, definedAt);
-                        }
+                        addEntryOrInclude(definedAt, isForClientSide, definedAt);
                     });
                 });
             });
@@ -214,13 +220,26 @@ async function getPageDeps(config, pageConfigs) {
         });
     }
     // Add virtual files.
-    // - This doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
-    //   - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
-    //   - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
-    //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    // - Vite 8+ (Rolldown-based dep scanner) crawls virtual IDs natively — its scanner routes
+    //   through `environment.pluginContainer.resolveId()`, so Vike's resolveId/load handlers
+    //   run during the scan and the virtual file's transitive deps are seen.
+    // - Vite ≤7 (esbuild-based dep scanner) cannot crawl virtual IDs — those virtuals' deps
+    //   surface lazily and trigger "✨ new dependencies optimized" reload cycles. As a
+    //   workaround we could materialize each virtual to a real file under
+    //   `node_modules/.vike/optimizeDeps-virtuals/`; an implementation lives in the reverted
+    //   commit https://github.com/vikejs/vike/commit/b068009c3 (re-apply if Vite ≤7 support
+    //   matters).
     {
         const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
-        Object.values(clientEntries).forEach((e) => addEntry(e, true));
+        Object.values(clientEntries).forEach(({ entryTarget, entryFilePath }) => {
+            if (entryFilePath) {
+                addEntryOrInclude(entryFilePath, true);
+            }
+            else {
+                // Page-entry virtual IDs have no file path.
+                addEntry(entryTarget, true);
+            }
+        });
         if (hasClientRouting)
             addEntry(virtualFileIdGlobalEntryClientCR, true);
         if (hasServerRouting)
@@ -258,3 +277,20 @@ function remove(input) {
     list = list.filter((e) => !ALWAYS_REMOVE.includes(e));
     return list;
 }
+// Sanity-check that the legacy `config.optimizeDeps` and `config.ssr.optimizeDeps` slots
+// stay in sync with the corresponding environment values — so logging only the env values
+// (above) isn't hiding anything.
+function assertEnvsInSyncWithLegacy(config) {
+    const client = config.environments.client?.optimizeDeps;
+    assert(client);
+    assert(deepEqual(config.optimizeDeps.entries, client.entries));
+    assert(deepEqual(config.optimizeDeps.include, client.include));
+    assert(deepEqual(config.optimizeDeps.exclude, client.exclude));
+    const ssr = config.environments.ssr?.optimizeDeps;
+    assert(ssr);
+    /* Vite doesn't seem to support config.ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+    assert(deepEqual(config.ssr.optimizeDeps.entries, ssr.entries))
+    */
+    assert(deepEqual(config.ssr.optimizeDeps.include, ssr.include));
+    assert(deepEqual(config.ssr.optimizeDeps.exclude, ssr.exclude));
+}

package/dist/node/vite/plugins/pluginStripPointerImportAttribute.js

@@ -1,4 +1,5 @@
 export { pluginStripPointerImportAttribute };
+import { getImportStatements } from '../shared/parseEsModule.js';
 import { getMagicString } from '../shared/getMagicString.js';
 import '../assertEnvVite.js';
 // Match `with { type: 'vike:pointer' }` (with optional whitespace variations)
@@ -14,18 +15,38 @@ function pluginStripPointerImportAttribute() {
                     },
                 },
                 handler(code, id) {
-                    runtimeAttrRE.lastIndex = 0;
-                    if (!runtimeAttrRE.test(code))
-                        return;
-                    const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    runtimeAttrRE.lastIndex = 0;
-                    let match;
-                    while ((match = runtimeAttrRE.exec(code)) !== null) {
-                        magicString.remove(match.index, match.index + match[0].length);
-                    }
-                    return getMagicStringResult();
+                    return stripPointerImportAttributes(code, id);
                 },
             },
         },
     ];
 }
+async function stripPointerImportAttributes(code, id) {
+    // Fast path: skip parsing when there is nothing to strip
+    runtimeAttrRE.lastIndex = 0;
+    if (!runtimeAttrRE.test(code))
+        return;
+    // Restrict stripping to genuine `import` statements, so that we don't touch occurrences
+    // inside string literals/comments (e.g. documentation code examples).
+    // https://github.com/brillout/docpress/issues/167
+    let importStatements;
+    try {
+        importStatements = await getImportStatements(code);
+    }
+    catch {
+        // Not parsable as an ES module (e.g. a raw Markdown file) => leave it untouched
+        return;
+    }
+    const { magicString, getMagicStringResult } = getMagicString(code, id);
+    for (const { ss, se } of importStatements)
+        stripAttribute(magicString, code, ss, se);
+    return getMagicStringResult();
+}
+function stripAttribute(magicString, code, start, end) {
+    const region = code.slice(start, end);
+    runtimeAttrRE.lastIndex = 0;
+    let match;
+    while ((match = runtimeAttrRE.exec(region)) !== null) {
+        magicString.remove(start + match.index, start + match.index + match[0].length);
+    }
+}

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFilePageEntry.js

@@ -1,5 +1,5 @@
 export { generateVirtualFilePageEntry };
-import { assert, getProjectError } from '../../../../utils/assert.js';
+import { assert, getDebugInfoStr, getProjectError } from '../../../../utils/assert.js';
 import { parseVirtualFileId, generateVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAssetsQuery.js';
@@ -26,12 +26,10 @@ async function generateVirtualFilePageEntry(id, isDev) {
         assert(pageConfig);
     }
     else {
-        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition. UPDATE: [December 2024] This just happened at test/@cloudflare_vite-plugin/ — it isn't blocking, reloading the page fixes the issue.
-        assert(pageConfig, { id, pageId })
-        /*/
-        if (!pageConfig)
-            throw getProjectError('Outdated request');
-        //*/
+        if (!pageConfig) {
+            // Happens very seldom and can't reproduce reliably. Some kind of HMR race condition? It still happens as of June 2026 with Cloudflare Workers in development — but it isn't blocking, reloading the page fixes the issue.
+            throw getProjectError(`Outdated request. Try again. ${getDebugInfoStr({ id, pageId })}`);
+        }
     }
     const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);

package/dist/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.d.ts

@@ -3,7 +3,7 @@ export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
 export { isConfigSourceValueNull };
 export type { RuntimeEnv };
-import type { ConfigEnvInternal, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
+import type { ConfigEnv, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
 import '../../assertEnvVite.js';
 type RuntimeEnv = {
     isForClientSide: boolean;
@@ -15,5 +15,5 @@ type RuntimeEnv = {
 type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;
 declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];
 declare function getConfigValueSourceRelevantAnyEnv(configName: string, pageConfig: PageConfigPartial): null | ConfigValueSource;
-declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtimeEnv: RuntimeEnv): boolean;
+declare function isRuntimeEnvMatch(configEnv: ConfigEnv, runtimeEnv: RuntimeEnv): boolean;
 declare function isConfigSourceValueNull(source: ConfigValueSource): boolean | null;

package/dist/node/vite/shared/addSsrMiddleware.js

@@ -14,7 +14,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const pageContextInit = {
             urlOriginal: url,
             headersOriginal: headers,
-            _reqDev: req,
+            _nodeDev: { req, res },
         };
         Object.defineProperty(pageContextInit, 'userAgent', {
             get() {

package/dist/node/vite/shared/isVite8OrAbove.d.ts

@@ -0,0 +1,4 @@
+export { isVite8OrAbove };
+import type { ResolvedConfig, UserConfig } from 'vite';
+import '../assertEnvVite.js';
+declare function isVite8OrAbove(config: UserConfig | ResolvedConfig): boolean;

package/dist/node/vite/shared/isVite8OrAbove.js

@@ -0,0 +1,9 @@
+export { isVite8OrAbove };
+import { assert } from '../../../utils/assert.js';
+import { isVersionMatch } from '../../../utils/assertVersion.js';
+import '../assertEnvVite.js';
+function isVite8OrAbove(config) {
+    const viteVersion = config._viteVersionResolved;
+    assert(viteVersion);
+    return isVersionMatch(viteVersion, ['8.0.0']);
+}

package/dist/node/vite/shared/isViteCli.d.ts

@@ -1,6 +1,7 @@
 export { isViteCli };
-export { getViteConfigForBuildFromCli };
-export { getViteCommandFromCli };
+export { getViteCliArgs };
+export { getViteBuildCliArgs };
+export { getViteCliCommand };
 import '../assertEnvVite.js';
 declare function isViteCli(): boolean;
 type ConfigFromCli = {
@@ -10,5 +11,9 @@ type ConfigFromCli = {
     build: Record<string, unknown>;
 };
 type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
-declare function getViteCommandFromCli(): ViteCommand | null;
-declare function getViteConfigForBuildFromCli(): null | ConfigFromCli;
+declare function getViteCliCommand(): ViteCommand | null;
+declare function getViteBuildCliArgs(): null | ConfigFromCli;
+declare function getViteCliArgs(): null | {
+    root: string | undefined;
+    configFile: string | undefined;
+};

package/dist/node/vite/shared/isViteCli.js

@@ -1,6 +1,7 @@
 export { isViteCli };
-export { getViteConfigForBuildFromCli };
-export { getViteCommandFromCli };
+export { getViteCliArgs };
+export { getViteBuildCliArgs };
+export { getViteCliCommand };
 import { assert } from '../../../utils/assert.js';
 import { isObject } from '../../../utils/isObject.js';
 import { isToolCli } from '../../../utils/isToolCli.js';
@@ -10,7 +11,7 @@ const desc = 'vike:vite-cli-simulation';
 function isViteCli() {
     return isToolCli('vite');
 }
-function getViteCommandFromCli() {
+function getViteCliCommand() {
     if (!isViteCli())
         return null;
     let command;
@@ -45,7 +46,7 @@ function getViteCommandFromCli() {
     assert(command);
     return command;
 }
-function getViteConfigForBuildFromCli() {
+function getViteBuildCliArgs() {
     if (!isViteCli())
         return null;
     // Copied & adapted from Vite
@@ -135,3 +136,22 @@ function getViteConfigForBuildFromCli() {
         return ret;
     }
 }
+function getViteCliArgs() {
+    if (!isViteCli())
+        return null;
+    const cli = cac(desc);
+    cli.option('-c, --config <file>', desc);
+    let result = null;
+    const setResult = (root, options) => {
+        assert(root === undefined || typeof root === 'string');
+        assert(isObject(options));
+        assert(options.config === undefined || typeof options.config === 'string');
+        result = { root, configFile: options.config };
+    };
+    cli.command('[root]', desc).alias('serve').alias('dev').action(setResult);
+    cli.command('build [root]', desc).action(setResult);
+    cli.command('optimize [root]', desc).action(setResult);
+    cli.command('preview [root]', desc).action(setResult);
+    cli.parse();
+    return result;
+}

package/dist/node/vite/shared/loggerDev.js

@@ -29,7 +29,6 @@ import { getBetterError } from '../../../utils/getBetterError.js';
 import { getRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
 import { getRequestTag } from '../../../server/runtime/renderPageServer.js';
 import '../assertEnvVite.js';
-import { isDeno } from '../../../utils/isDeno.js';
 assertIsNotProductionRuntime();
 setLogRuntimeDev(logErrorServerDev, logRuntimeInfoDev);
 setAssertOnBeforeErr((err) => {
@@ -139,14 +138,16 @@ function logDev(msg, logType, tagSource, tagTool, doNotAddTags) {
 }
 function getTagSource(requestId = null) {
     const requestIdFromStore = getRequestId_withAsyncHook();
-    if (requestIdFromStore !== null &&
-        // Workaround for Deno bug: https://github.com/vikejs/vike/issues/3240
-        !isDeno()) {
+    if (requestIdFromStore !== null) {
         if (requestId === null) {
             requestId = requestIdFromStore;
         }
         else {
-            assert(requestId === requestIdFromStore);
+            /* Surprisingly, this assert can fail:
+             *  - https://github.com/vikejs/vike/issues/3240
+             *  - https://github.com/vikejs/vike/issues/3289
+            assert(requestId === requestIdFromStore)
+            */
         }
     }
     if (requestId === null)

package/dist/node/vite/shared/resolveVikeConfigInternal/assertExtensions.d.ts

@@ -1,6 +1,8 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
+export { getExtensionName };
 import type { PlusFile } from './getPlusFilesByLocationId.js';
 import '../../assertEnvVite.js';
 declare function assertExtensionsConventions(plusFile: PlusFile): void;
 declare function assertExtensionsRequire(plusFiles: PlusFile[]): void;
+declare function getExtensionName(plusFile: PlusFile): null | string;

package/dist/node/vite/shared/resolveVikeConfigInternal/assertExtensions.js

@@ -1,5 +1,6 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
+export { getExtensionName };
 import pc from '@brillout/picocolors';
 import { PROJECT_VERSION } from '../../../../utils/PROJECT_VERSION.js';
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
@@ -21,14 +22,14 @@ function assertConfigExportPath(plusFile) {
         assert(!p.includes('node_modules'));
         return;
     }
-    const name = getNameValue(plusFile);
+    const name = getExtensionName(plusFile);
     assert(name); // already asserted in assertExtensionName()
     const importPathAbsoluteExpected = `${name}/config`;
     assertWarning(importPathAbsolute === importPathAbsoluteExpected, `The Vike configuration of ${pc.bold(name)} is exported at ${pc.bold(importPathAbsolute)}, but it should be exported at ${pc.bold(importPathAbsoluteExpected)} instead.`, { onlyOnce: true });
 }
 function assertExtensionName(plusFile) {
     const filePathToShowToUser = getFilePathToShowToUser(plusFile);
-    const name = getNameValue(plusFile);
+    const name = getExtensionName(plusFile);
     assertUsage(name, `Vike extension name missing: the config ${filePathToShowToUser} must define the setting ${pc.cyan('name')}`);
 }
 function assertExtensionsRequire(plusFiles) {
@@ -36,7 +37,7 @@ function assertExtensionsRequire(plusFiles) {
     // Collect extensions
     const extensions = {};
     plusFilesRelevantList.forEach((plusFile) => {
-        const name = getNameValue(plusFile);
+        const name = getExtensionName(plusFile);
         if (name) {
             const version = getExtensionVersion(name, plusFile);
             extensions[name] = version;
@@ -47,7 +48,7 @@ function assertExtensionsRequire(plusFiles) {
         const require = resolveRequireSetting(plusFile);
         if (!require)
             return;
-        const name = getNameValue(plusFile);
+        const name = getExtensionName(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, req]) => {
@@ -96,7 +97,7 @@ function resolveRequireSetting(plusFile) {
     });
     return requireSetting;
 }
-function getNameValue(plusFile) {
+function getExtensionName(plusFile) {
     const confVal = getConfVal(plusFile, 'name');
     if (!confVal)
         return null;

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFilePaths.js

@@ -28,6 +28,7 @@ assertIsNotProductionRuntime();
 const globalObject = getGlobalObject('getVikeConfig/crawlPlusFilePaths.ts', {
     gitIsNotUsable: false,
 });
+// TODO/after-PR-merge rename crawlPlusFilePaths crawlPlusFiles
 async function crawlPlusFilePaths(userRootDir) {
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);

package/dist/node/vite/shared/resolveVikeConfigInternal/getPlusFilesByLocationId.d.ts

@@ -1,10 +1,11 @@
 export { getPlusFilesByLocationId };
+export { getPlusFileFromConfigFile };
 export type { PlusFileValue };
 export type { PlusFile };
 export type { PlusFilesByLocationId };
 import { type LocationId } from './filesystemRouting.js';
 import { type EsbuildCache } from './transpileAndExecuteFile.js';
-import { PointerImportLoaded } from './loadFileAtConfigTime.js';
+import { type ConfigFile, PointerImportLoaded } from './loadFileAtConfigTime.js';
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 import '../../assertEnvVite.js';
 type PlusFile = PlusFileConfig | PlusFileValue;
@@ -40,3 +41,4 @@ type PlusFileValue = PlusFileCommon & {
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
 declare function getPlusFilesByLocationId(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
+declare function getPlusFileFromConfigFile(configFile: ConfigFile, isExtensionConfig: boolean, locationId: LocationId, userRootDir: string): PlusFileConfig;

package/dist/node/vite/shared/resolveVikeConfigInternal/getPlusFilesByLocationId.js

@@ -1,4 +1,5 @@
 export { getPlusFilesByLocationId };
+export { getPlusFileFromConfigFile };
 import { assert } from '../../../../utils/assert.js';
 import { metaBuiltIn } from './metaBuiltIn.js';
 import { getLocationId } from './filesystemRouting.js';
@@ -9,6 +10,7 @@ import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../getFilePath.js';
 import { assertExtensionsConventions, assertExtensionsRequire } from './assertExtensions.js';
 import '../../assertEnvVite.js';
+// TODO/after-PR-merge rename getPlusFilesByLocationId getPlusFiles
 async function getPlusFilesByLocationId(userRootDir, esbuildCache) {
     const plusFilePaths = (await crawlPlusFilePaths(userRootDir)).map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     const plusFilesByLocationId = {};
@@ -25,21 +27,21 @@ async function getPlusFilesByLocationId(userRootDir, esbuildCache) {
             plusFilesByLocationId[locationId].push(plusFile);
             extendsConfigs.forEach((extendsConfig) => {
                 /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
-              ```js
-              // /pages/admin/+config.js
+                ```js
+                // /pages/admin/+config.js
       
-              import vikeVue from 'vike-vue/config'
-              // Should only apply to /pages/admin/**
-              export default { extends: [vikeVue] }
-              ```
-              ```js
-              // /pages/marketing/+config.js
+                import vikeVue from 'vike-vue/config'
+                // Should only apply to /pages/admin/**
+                export default { extends: [vikeVue] }
+                ```
+                ```js
+                // /pages/marketing/+config.js
       
-              import vikeReact from 'vike-react/config'
-              // Should only apply to /pages/marketing/**
-              export default { extends: [vikeReact] }
-              ```
-              */
+                import vikeReact from 'vike-react/config'
+                // Should only apply to /pages/marketing/**
+                export default { extends: [vikeReact] }
+                ```
+                */
                 const plusFile = getPlusFileFromConfigFile(extendsConfig, true, locationId, userRootDir);
                 assertExtensionsConventions(plusFile);
                 plusFilesByLocationId[locationId].push(plusFile);

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.d.ts

@@ -4,8 +4,8 @@ export type { ConfigDefinitions };
 export type { ConfigDefinitionsInternal };
 export type { ConfigDefinitionInternal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
-import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
+import type { ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
+import type { Config, ConfigNameBuiltIn, ConfigNameBuiltInGlobal } from '../../../../types/Config.js';
 import { type ConfigDefinedAt } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
 import type { PageConfigBuildTimeBeforeComputed } from '../resolveVikeConfigInternal.js';
 import '../../assertEnvVite.js';
@@ -13,8 +13,7 @@ import '../../assertEnvVite.js';
  *
  * https://vike.dev/meta
  */
-type ConfigDefinition = ConfigDefinition_ | ConfigDefinitionDefinedByPeerDependency;
-type ConfigDefinition_ = {
+type ConfigDefinition = {
     /** In what environment(s) the config value is loaded.
      *
      * https://vike.dev/meta
@@ -57,7 +56,14 @@ type ConfigDefinition_ = {
     }) => boolean);
     /** Whether changes to the configuration should trigger a Vite restart. */
     vite?: boolean;
-};
+    /** @experimental */
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
+    /** @experimental */
+    _valueIsFilePath?: true;
+    /** @experimental */
+    _userEffectDefinedAtFilePath?: DefinedAtFilePath;
+    isDefinedByPeerDependency?: undefined;
+} | ConfigDefinitionDefinedByPeerDependency;
 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}
@@ -70,27 +76,21 @@ type ConfigDefinitionDefinedByPeerDependency = {
  * https://vike.dev/meta
  */
 type ConfigEffect = (config: {
-    /** The config value.
+    /** The config's value.
      *
      * https://vike.dev/meta
      */
     configValue: unknown;
-    /** Where the config value is defined.
+    /** Where the config's value is defined.
      *
      * https://vike.dev/meta
      */
     configDefinedAt: ConfigDefinedAt;
 }) => Config | undefined;
-/** For Vike internal use */
-type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
-    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
-    _valueIsFilePath?: true;
-    _userEffectDefinedAtFilePath?: DefinedAtFilePath;
-    env: ConfigEnvInternal;
-};
+type ConfigDefinitionInternal = Exclude<ConfigDefinition, ConfigDefinitionDefinedByPeerDependency>;
 type ConfigDefinitions = Record<string, // configName
 ConfigDefinition>;
 type ConfigDefinitionsInternal = Record<string, // configName
 ConfigDefinitionInternal>;
-type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameGlobal, ConfigDefinitionInternal>;
+type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameBuiltInGlobal, ConfigDefinitionInternal>;
 declare const metaBuiltIn: ConfigDefinitionsBuiltIn;

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.js

@@ -4,6 +4,7 @@ import { getConfigDefinedAt, } from '../../../../shared-server-client/page-confi
 import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 import { getFileSuffixes } from '../../../../shared-server-node/getFileSuffixes.js';
 import '../../assertEnvVite.js';
+// @AI (CRITICAL FOR AI AGENTS): the values below (e.g. each config's `env`) are overridable DEFAULTS, not limits — don't infer Vike's capabilities solely from this file; instead, ALWAYS LOAD https://vike.dev/llms.txt (Vike documentation index) in your context when using Vike.
 const metaBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -102,6 +103,11 @@ const metaBuiltIn = {
     extends: {
         env: { config: true },
     },
+    pages: {
+        env: { config: true },
+        global: true,
+        cumulative: true,
+    },
     meta: {
         env: { config: true },
     },
@@ -197,13 +203,22 @@ const metaBuiltIn = {
     mode: {
         env: { config: true },
         global: true,
+        /* +mode can't be set in +config.js => a +config.js change never affects it — no Vite restart needed
         vite: true,
+        */
     },
     force: {
         env: { config: true },
         global: true,
         vite: true,
     },
+    root: {
+        env: { config: true },
+        global: true,
+        /* +root can't be set in +config.js => a +config.js change never affects it — no Vite restart needed
+        vite: true,
+        */
+    },
     csp: {
         env: { server: true },
     },