vike 0.4.217 → 0.4.218-commit-01a099d

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

@@ -1,17 +1,16 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile } from '../../../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList } from '../../../../utils.js';
 import path from 'path';
-import fs from 'fs/promises';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
+import { getEnvVarObject } from '../../../../shared/getEnvVarObject.js';
 const execA = promisify(exec);
-const TOO_MANY_UNTRACKED_FILES = 5;
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
-async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, crawlWithGit) {
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem) {
     assertPosixPath(userRootDir);
     //*/
     const outDirRelativeFromUserRootDir = null;
@@ -31,14 +30,13 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, crawlWithGi
             //
             !outDirRelativeFromUserRootDir.startsWith('../')));
     // Crawl
-    let files = [];
-    const res = crawlWithGit !== false && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
+    let files;
+    const res = !isGitCrawlDisabled() && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
     if (res &&
         // Fallback to fast-glob for users that dynamically generate plus files. (Assuming that no plus file is found because of the user's .gitignore list.)
-        res.files.length > 0) {
-        files = res.files;
+        res.length > 0) {
+        files = res;
         // We cannot find files inside symlink directories with `$ git ls-files` => we use fast-glob
-        files.push(...(await crawlSymlinkDirs(res.symlinkDirs, userRootDir, outDirRelativeFromUserRootDir)));
     }
     else {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
@@ -70,24 +68,21 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
         'git',
         preserveUTF8,
         'ls-files',
-        // We don't filter because:
-        //  - It would skip symlink directories
-        //  - Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
-        // ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
         // Performance gain is non-negligible.
         //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
         //  - When node_modules/ is untracked the performance gain could be significant?
         ...ignoreAsPatterns.map((pattern) => `--exclude="${pattern}"`),
         // --others --exclude-standard => list untracked files (--others) while using .gitignore (--exclude-standard)
         // --cached => list tracked files
-        // --stage => get file modes which we use to find symlink directories
-        '--others --exclude-standard --cached --stage'
+        '--others --exclude-standard --cached'
     ].join(' ');
-    let resultLines;
+    let filesAll;
     let filesDeleted;
     try {
         ;
-        [resultLines, filesDeleted] = await Promise.all([
+        [filesAll, filesDeleted] = await Promise.all([
             // Main command
             runCmd1(cmd, userRootDir),
             // Get tracked but deleted files
@@ -101,40 +96,23 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
         }
         throw err;
     }
-    const filePaths = resultLines.map(parseGitLsResultLine);
-    // If there are too many files without mode we fallback to fast-glob
-    if (filePaths.filter((f) => !f.mode).length > TOO_MANY_UNTRACKED_FILES)
-        return null;
-    const symlinkDirs = [];
     const files = [];
-    for (const { filePath, mode } of filePaths) {
-        // Deleted?
-        if (filesDeleted.includes(filePath))
+    for (const filePath of filesAll) {
+        // + file?
+        if (!path.posix.basename(filePath).startsWith('+'))
             continue;
         // We have to repeat the same exclusion logic here because the option --exclude of `$ git ls-files` only applies to untracked files. (We use --exclude only to speed up the `$ git ls-files` command.)
         if (!ignoreAsFilterFn(filePath))
             continue;
-        // Symlink directory?
-        {
-            const isSymlinkDir = await isSymlinkDirectory(mode, filePath, userRootDir);
-            if (isSymlinkDir) {
-                symlinkDirs.push(filePath);
-                continue;
-            }
-            // Skip deleted files and non-symlink directories
-            if (isSymlinkDir === null) {
-                continue;
-            }
-        }
-        // + file?
-        if (!path.posix.basename(filePath).startsWith('+'))
-            continue;
         // JavaScript file?
         if (!isScriptFile(filePath))
             continue;
+        // Deleted?
+        if (filesDeleted.includes(filePath))
+            continue;
         files.push(filePath);
     }
-    return { files, symlinkDirs };
+    return files;
 }
 // Same as gitLsFiles() but using fast-glob
 async function fastGlob(userRootDir, outDirRelativeFromUserRootDir) {
@@ -204,77 +182,6 @@ async function isGitNotUsable(userRootDir) {
         return false;
     }
 }
-async function crawlSymlinkDirs(symlinkDirs, userRootDir, outDirRelativeFromUserRootDir) {
-    const filesInSymlinkDirs = (await Promise.all(symlinkDirs.map(async (symlinkDir) => (await fastGlob(path.posix.join(userRootDir, symlinkDir), outDirRelativeFromUserRootDir)).map((filePath) => path.posix.join(symlinkDir, filePath))))).flat();
-    return filesInSymlinkDirs;
-}
-// Parse:
-// ```
-// some/not/tracked/path
-// 100644 f6928073402b241b468b199893ff6f4aed0b7195 0\tpages/index/+Page.tsx
-// ```
-function parseGitLsResultLine(resultLine) {
-    const [part1, part2, ...rest] = resultLine.split('\t');
-    assert(part1);
-    assert(rest.length === 0);
-    // Git doesn't provide the mode for untracked paths.
-    // `resultLine` is:
-    // ```
-    // some/not/tracked/path
-    // ```
-    if (part2 === undefined) {
-        return { filePath: part1, mode: null };
-    }
-    assert(part2);
-    // `resultLine` is:
-    // ```
-    // 100644 f6928073402b241b468b199893ff6f4aed0b7195 0\tpages/index/+Page.tsx
-    // ```
-    const [mode, _, __, ...rest2] = part1.split(' ');
-    assert(mode && _ && __ && rest2.length === 0);
-    return { filePath: part2, mode };
-}
-async function isSymlinkDirectory(mode, filePath, userRootDir) {
-    const filePathAbsolute = path.posix.join(userRootDir, filePath);
-    let stats = null;
-    let isSymlink = false;
-    if (mode === '120000') {
-        isSymlink = true;
-    }
-    else if (mode === null) {
-        // `$ git ls-files` doesn't provide the mode when Git doesn't track the path
-        stats = await getFileStats(filePathAbsolute);
-        if (stats === null)
-            return null;
-        isSymlink = stats.isSymbolicLink();
-        if (!isSymlink && stats.isDirectory())
-            return null;
-    }
-    else {
-        assert(mode);
-    }
-    if (!isSymlink)
-        return false;
-    if (!stats)
-        stats = await getFileStats(filePathAbsolute);
-    if (stats === null)
-        return null;
-    const isDirectory = stats.isDirectory();
-    return isDirectory;
-}
-async function getFileStats(filePathAbsolute) {
-    let stats;
-    try {
-        stats = await fs.lstat(filePathAbsolute);
-    }
-    catch (err) {
-        // File was deleted, usually a temporary file such as +config.js.build-j95xb988fpln.mjs
-        // ENOENT: no such file or directory
-        assert(err.code === 'ENOENT');
-        return null;
-    }
-    return stats;
-}
 async function runCmd1(cmd, cwd) {
     const { stdout } = await execA(cmd, {
         cwd,
@@ -299,3 +206,7 @@ async function runCmd2(cmd, cwd) {
     stderr = stderr.toString().trim();
     return { stdout, stderr };
 }
+function isGitCrawlDisabled() {
+    const crawSettings = getEnvVarObject('VIKE_CRAWL');
+    return crawSettings?.git === false;
+}

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

@@ -8,11 +8,13 @@ export { getConfigValueInterfaceFile };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
 export type { InterfaceFile };
+export type { VikeConfigGlobal };
+export type { VikeVitePluginOptions };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
 import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
-import type { VikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
+import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 type InterfaceFile = InterfaceConfigFile | InterfaceValueFile;
 type InterfaceFileCommons = {
     locationId: LocationId;
@@ -37,6 +39,9 @@ type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
     vikeConfigGlobal: VikeConfigGlobal;
+    vikeConfigNew: {
+        global: ReturnType<typeof getPageConfigUserFriendlyNew>;
+    };
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(config: ResolvedConfig): void;
@@ -47,3 +52,96 @@ declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePlu
 declare function isV1Design(config: ResolvedConfig): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;
 declare function getConfigValueInterfaceFile(interfaceFile: InterfaceFile, configName: string): unknown;
+type VikeConfigGlobal = {
+    prerender: false | {
+        noExtraDir: boolean;
+        parallel: boolean | number;
+        partial: boolean;
+        disableAutoRun: boolean;
+    };
+    disableAutoFullBuild: boolean | 'prerender' | null;
+    includeAssetsImportedByServer: boolean;
+    baseAssets: string | null;
+    baseServer: string | null;
+    redirects: Record<string, string>;
+    trailingSlash: boolean;
+    disableUrlNormalization: boolean;
+};
+type VikeVitePluginOptions = {
+    /**
+     * Enable pre-rendering.
+     *
+     * https://vike.dev/pre-rendering
+     *
+     * @default false
+     */
+    prerender?: boolean | {
+        /**
+         * Don't create a new directory for each HTML file.
+         *
+         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+         *
+         * @default false
+         */
+        noExtraDir?: boolean;
+        /**
+         * Number of concurrent pre-render jobs.
+         *
+         * Set to `false` to disable concurrency.
+         *
+         * @default os.cpus().length
+         */
+        parallel?: boolean | number;
+        /**
+     * Allow only some of your pages to be pre-rendered.
+     *
+     * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+ 
+     * @default false
+     */
+        partial?: boolean;
+        /**
+         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
+         *
+         * Use this if you want to programmatically initiate the pre-rendering process instead.
+         *
+         * https://vike.dev/api#prerender
+         *
+         * @default false
+         */
+        disableAutoRun?: boolean;
+    };
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** The Base URL of your server.
+     *
+     * https://vike.dev/base-url
+     */
+    baseServer?: string;
+    /** The Base URL of your static assets.
+     *
+     * https://vike.dev/base-url
+     */
+    baseAssets?: string;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** Permanent redirections (HTTP status code 301)
+     *
+     * https://vike.dev/redirects
+     */
+    redirects?: Record<string, string>;
+    /** Whether URLs should end with a trailing slash.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /** Disable automatic URL normalization.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    disableUrlNormalization?: boolean;
+};

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

@@ -23,7 +23,8 @@ import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfC
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
-import { resolveVikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
+import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -78,6 +79,7 @@ async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError ?? false);
 }
 async function getVikeConfig2(userRootDir, isDev, vikeVitePluginOptions) {
+    assert(vikeVitePluginOptions);
     return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, false);
 }
 async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
@@ -92,8 +94,8 @@ async function isV1Design(config) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, crawlWithGit) {
-    const plusFiles = await findPlusFiles(userRootDir, null, crawlWithGit);
+async function loadInterfaceFiles(userRootDir) {
+    const plusFiles = await findPlusFiles(userRootDir, null);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -238,18 +240,19 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {})
+                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
+                vikeConfigNew: {
+                    global: getPageConfigUserFriendlyNew({ configValues: {} })
+                }
             };
             return dummyData;
         }
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const crawlWithGit = resolveVikeConfigGlobal(vikeVitePluginOptions, {}).crawl.git ?? null;
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, crawlWithGit);
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const { pageConfigGlobal, pageConfigGlobalValues } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    const { pageConfigGlobal, vikeConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -299,7 +302,37 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal };
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal, vikeConfigNew: { global } };
+}
+function getConfigValues(pageConfig) {
+    const configValues = {};
+    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            assert('value' in sourceRelevant);
+            const { value } = sourceRelevant;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const values = [];
+            sourcesRelevant.forEach((source) => {
+                assert('value' in source);
+                values.push(source.value);
+            });
+            configValues[configName] = { ...configValueBase, value: values };
+        }
+    });
+    return configValues;
 }
 // TODO/soon: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
@@ -377,7 +410,7 @@ function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
     const locationIds = objectKeys(interfaceFilesByLocationId);
     const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
@@ -432,7 +465,31 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             pageConfigGlobalValues[configName] = configValueSource.value;
         }
     }));
-    return { pageConfigGlobal, pageConfigGlobalValues };
+    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    {
+        assert(isObject(vikeVitePluginOptions));
+        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+            if (pageConfigGlobal.configValueSources[configName])
+                return;
+            pageConfigGlobal.configValueSources[configName] = [];
+            pageConfigGlobal.configValueSources[configName].push({
+                value,
+                configEnv: { config: true },
+                definedAtFilePath: {
+                    ...getFilePathResolved({
+                        userRootDir,
+                        filePathAbsoluteUserRootDir: '/vite.config.js'
+                    }),
+                    fileExportPathToShowToUser: null
+                },
+                locationId: '/',
+                isOverriden: false,
+                valueIsImportedAtRuntime: false,
+                valueIsDefinedByPlusFile: false
+            });
+        });
+    }
+    return { pageConfigGlobal, pageConfigGlobalValues, vikeConfigGlobal };
 }
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];
@@ -793,8 +850,8 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot, crawlWithGit) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot, crawlWithGit);
+async function findPlusFiles(userRootDir, outDirRoot) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot);
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
@@ -1010,3 +1067,121 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
 function getConfigValueInterfaceFile(interfaceFile, configName) {
     return interfaceFile.fileExportsByConfigName[configName]?.configValue;
 }
+// TODO: refactor code below
+function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
+    // TODO/v1-release: remove
+    assertVikeConfigGlobal(vikeVitePluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const configs = [vikeVitePluginOptions];
+    assertVikeConfigGlobal(pageConfigGlobalValues, ({ prop, errMsg }) => {
+        // Can we add the config file path ?
+        return `config ${pc.cyan(prop)} ${errMsg}`;
+    });
+    configs.push(pageConfigGlobalValues);
+    const vikeConfigGlobal = {
+        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+        prerender: resolvePrerenderOptions(configs),
+        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+        baseServer: pickFirst(configs.map((c) => c.baseServer)) ?? null,
+        baseAssets: pickFirst(configs.map((c) => c.baseAssets)) ?? null,
+        redirects: merge(configs.map((c) => c.redirects)) ?? {},
+        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
+    };
+    return vikeConfigGlobal;
+}
+function resolvePrerenderOptions(configs) {
+    if (!configs.some((c) => c.prerender)) {
+        return false;
+    }
+    const configsPrerender = configs.map((c) => c.prerender).filter(isObject2);
+    return {
+        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
+    };
+}
+function isObject2(p) {
+    return typeof p === 'object';
+}
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}
+function assertVikeConfigGlobal(vikeConfigGlobal, wrongUsageMsg) {
+    const wrongUsageError = check(vikeConfigGlobal);
+    if (wrongUsageError) {
+        assertUsage(false, wrongUsageMsg(wrongUsageError));
+    }
+}
+function check(vikeConfigGlobal) {
+    assert(isObject(vikeConfigGlobal));
+    {
+        const prop = 'disableUrlNormalization';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'trailingSlash';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'redirects';
+        const { redirects } = vikeConfigGlobal;
+        if (!(redirects === undefined ||
+            (isObject(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
+            return { prop, errMsg: 'should be an object of strings' };
+    }
+    {
+        const prop = 'disableAutoFullBuild';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined') &&
+            !(vikeConfigGlobal[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
+    }
+    {
+        const prop = 'includeAssetsImportedByServer';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'prerender';
+        if (!hasProp(vikeConfigGlobal, prop, 'object') &&
+            !hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be an object or a boolean' };
+    }
+    const configVikePrerender = vikeConfigGlobal.prerender;
+    if (typeof configVikePrerender === 'object') {
+        {
+            const p = 'partial';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(configVikePrerender, p, 'boolean') &&
+                !hasProp(configVikePrerender, p, 'number') &&
+                !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
+        }
+    }
+    return null;
+}

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

@@ -5,7 +5,8 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const { pageConfigs, pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {

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

@@ -33,7 +33,7 @@ function setGlobalContext() {
                 order: 'post',
                 async handler(config) {
                     const { outDirRoot } = getOutDirs(config);
-                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
                     const vikeConfig = await getVikeConfig(config);
                     setGlobalContext_vikeConfig(vikeConfig);

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

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

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

@@ -1,11 +1,11 @@
-export { vite6HmrRegressionWorkaround };
+export { workaroundVite6HmrRegression };
 // 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 vite6HmrRegressionWorkaround() {
+function workaroundVite6HmrRegression() {
     return {
-        name: 'vike:vite6HmrRegressionWorkaround',
+        name: 'vike:workaroundVite6HmrRegression',
         enforce: 'post',
         hotUpdate: {
             order: 'post',

package/dist/esm/node/plugin/shared/getEnvVarObject.d.ts

@@ -1,2 +1,2 @@
 export { getEnvVarObject };
-declare function getEnvVarObject(envVarName: 'VITE_CONFIG'): null | Record<string, unknown>;
+declare function getEnvVarObject(envVarName: 'VITE_CONFIG' | 'VIKE_CRAWL'): null | Record<string, unknown>;

package/dist/esm/node/prerender/isPrerenderEnabled.d.ts

@@ -0,0 +1,3 @@
+export { isPrerenderEnabled };
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function isPrerenderEnabled(vikeConfigGlobal: VikeConfigGlobal): boolean;

package/dist/esm/node/prerender/isPrerenderEnabled.js

@@ -0,0 +1,6 @@
+export { isPrerenderEnabled };
+function isPrerenderEnabled(vikeConfigGlobal) {
+    return (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender');
+}

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -3,7 +3,6 @@ export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
-import '../runtime/page-files/setup.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions } from '../api/types.js';
 type PrerenderOptions = APIOptions & {
@@ -30,5 +29,5 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig, forceExit: boolean): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, forceExit: boolean): Promise<void>;
 declare function runPrerender_forceExit(): void;