vike 0.4.240 → 0.4.241-commit-60b0676

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

@@ -7,7 +7,7 @@ import { parseVirtualFileId } from '../../shared/virtualFileId.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 { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
 import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
@@ -176,7 +176,7 @@ 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 filePathToShowToUserResolved = getFilePathToShowToUserModule(filePath, config);
         const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }

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

@@ -0,0 +1,3 @@
+export { pluginViteConfigVikeExtensions };
+import type { Plugin } from 'vite';
+declare function pluginViteConfigVikeExtensions(): Promise<Plugin[]>;

package/dist/esm/node/vite/plugins/pluginViteConfigVikeExtensions.js

@@ -0,0 +1,32 @@
+export { pluginViteConfigVikeExtensions };
+import { mergeConfig } from 'vite';
+import { assertUsage, isObject } from '../utils.js';
+import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+async function pluginViteConfigVikeExtensions() {
+    const vikeConfig = await getVikeConfigInternalEarly();
+    if (vikeConfig === null)
+        return [];
+    let viteConfigFromExtensions = {};
+    const viteConfigsExtensions = vikeConfig._from.configsCumulative.vite;
+    if (!viteConfigsExtensions)
+        return [];
+    viteConfigsExtensions.values.forEach((v) => {
+        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
+        viteConfigFromExtensions = mergeConfig(viteConfigFromExtensions, v.value);
+    });
+    const pluginsFromExtensions = (viteConfigFromExtensions.plugins ?? []);
+    delete viteConfigFromExtensions.plugins;
+    return [
+        ...pluginsFromExtensions,
+        {
+            name: 'vike:pluginViteConfigVikeExtensions',
+            config: {
+                handler(_config) {
+                    return viteConfigFromExtensions;
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/shared/getFilePath.d.ts

@@ -1,9 +1,8 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
 export { getFilePathAbsoluteUserRootDir };
-export { getFilePathToShowToUserFromUnknown };
-export { getModuleFilePathAbsolute };
-export { getModuleFilePathRelative };
+export { getFilePathToShowToUserUnknown };
+export { getFilePathToShowToUserModule };
 export { cleanFilePathUnknown };
 export { assertModuleId };
 import type { FilePathResolved, FilePathUnresolved } from '../../../types/FilePath.js';
@@ -24,8 +23,7 @@ declare function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, us
     filePathAbsoluteFilesystem: string;
     userRootDir: string;
 }): string | null;
-declare function getModuleFilePathAbsolute(moduleId: string, config: ResolvedConfig): string;
-declare function getModuleFilePathRelative(moduleId: string, config: ResolvedConfig): string;
+declare function getFilePathToShowToUserModule(moduleId: string, config: ResolvedConfig): string;
 declare function assertModuleId(moduleId: string): void;
-declare function getFilePathToShowToUserFromUnknown(filePathUnknown: string, userRootDir: string): string;
+declare function getFilePathToShowToUserUnknown(filePathUnknown: string, userRootDir: string): string;
 declare function cleanFilePathUnknown(filePathUnknown: string): string;

package/dist/esm/node/vite/shared/getFilePath.js

@@ -1,9 +1,8 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
 export { getFilePathAbsoluteUserRootDir };
-export { getFilePathToShowToUserFromUnknown };
-export { getModuleFilePathAbsolute };
-export { getModuleFilePathRelative };
+export { getFilePathToShowToUserUnknown };
+export { getFilePathToShowToUserModule };
 export { cleanFilePathUnknown };
 export { assertModuleId };
 import path from 'node:path';
@@ -107,15 +106,11 @@ function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir, }) {
         return { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
     }
 }
-function getModuleFilePathAbsolute(moduleId, config) {
-    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getModuleFilePath(moduleId, config);
+function getFilePathToShowToUserModule(moduleId, config) {
+    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getFilePathModule(moduleId, config);
     return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
 }
-function getModuleFilePathRelative(moduleId, config) {
-    const { filePathRelativeUserRootDir } = getModuleFilePath(moduleId, config);
-    return filePathRelativeUserRootDir;
-}
-function getModuleFilePath(moduleId, config) {
+function getFilePathModule(moduleId, config) {
     const userRootDir = config.root;
     assertModuleId(moduleId);
     assertPosixPath(userRootDir);
@@ -132,7 +127,7 @@ function assertModuleId(moduleId) {
     assertPosixPath(moduleId);
     assertFilePathAbsoluteFilesystem(moduleId); // Can moduleId be something else than the filesystem absolute path?
 }
-function getFilePathToShowToUserFromUnknown(
+function getFilePathToShowToUserUnknown(
 // We don't have any guarantee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
 filePathUnknown, userRootDir) {
     assertPosixPath(userRootDir);

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

@@ -0,0 +1,13 @@
+export { isViteCli };
+export { getViteConfigForBuildFromCli };
+export { getViteCommandFromCli };
+declare function isViteCli(): boolean;
+type ConfigFromCli = {
+    root: undefined | string;
+    configFile: undefined | string;
+} & Record<string, unknown> & {
+    build: Record<string, unknown>;
+};
+type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
+declare function getViteCommandFromCli(): ViteCommand | null;
+declare function getViteConfigForBuildFromCli(): null | ConfigFromCli;

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

@@ -0,0 +1,143 @@
+export { isViteCli };
+export { getViteConfigForBuildFromCli };
+export { getViteCommandFromCli };
+import { assert, isObject, toPosixPath } from '../utils.js';
+import { cac } from 'cac';
+const desc = 'vike:vite-cli-simulation';
+function isViteCli() {
+    let execPath = process.argv[1];
+    assert(execPath);
+    execPath = toPosixPath(execPath);
+    return (
+    // pnpm
+    execPath.endsWith('/bin/vite.js') ||
+        // npm & yarn
+        execPath.endsWith('/.bin/vite') ||
+        // Global install
+        execPath.endsWith('/bin/vite'));
+}
+function getViteCommandFromCli() {
+    if (!isViteCli())
+        return null;
+    let command;
+    const setCommand = (cmd) => {
+        assert(command === undefined);
+        command = cmd;
+    };
+    // Copied & adapted from Vite
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L186-L188
+    const cli = cac(desc);
+    // dev
+    cli
+        .command('[root]', desc)
+        .alias('serve')
+        .alias('dev')
+        .action(() => {
+        setCommand('dev');
+    });
+    // build
+    cli.command('build [root]', desc).action(() => {
+        setCommand('build');
+    });
+    // optimize
+    cli.command('optimize [root]', desc).action(() => {
+        setCommand('optimize');
+    });
+    // preview
+    cli.command('preview [root]', desc).action(() => {
+        setCommand('preview');
+    });
+    cli.parse();
+    assert(command);
+    return command;
+}
+function getViteConfigForBuildFromCli() {
+    if (!isViteCli())
+        return null;
+    // Copied & adapted from Vite
+    const cli = cac(desc);
+    // Common configs
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L169-L182
+    cli
+        .option('-c, --config <file>', desc)
+        .option('--base <path>', desc)
+        .option('-l, --logLevel <level>', desc)
+        .option('--clearScreen', desc)
+        .option('--configLoader <loader>', desc)
+        .option('-d, --debug [feat]', desc)
+        .option('-f, --filter <filter>', desc)
+        .option('-m, --mode <mode>', desc);
+    // Build configs
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L286-L322
+    cli
+        .command('build [root]', desc)
+        .option('--target <target>', desc)
+        .option('--outDir <dir>', desc)
+        .option('--assetsDir <dir>', desc)
+        .option('--assetsInlineLimit <number>', desc)
+        .option('--ssr [entry]', desc)
+        .option('--sourcemap', desc)
+        .option('--minify [minifier]', desc)
+        .option('--manifest [name]', desc)
+        .option('--ssrManifest [name]', desc)
+        .option('--emptyOutDir', desc)
+        .option('-w, --watch', desc)
+        .option('--app', desc)
+        .action((root, options) => {
+        assert(isObject(options));
+        assert(root === undefined || typeof root === 'string');
+        assert(options.config === undefined || typeof options.config === 'string');
+        // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L331-L346
+        const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
+        configFromCli = {
+            root,
+            base: options.base,
+            mode: options.mode,
+            configFile: options.config,
+            configLoader: options.configLoader,
+            logLevel: options.logLevel,
+            clearScreen: options.clearScreen,
+            build: buildOptions,
+            ...(options.app ? { builder: {} } : {}),
+        };
+    });
+    let configFromCli = null;
+    cli.parse();
+    return configFromCli;
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L99
+    function cleanGlobalCLIOptions(options) {
+        const ret = { ...options };
+        delete ret['--'];
+        delete ret.c;
+        delete ret.config;
+        delete ret.base;
+        delete ret.l;
+        delete ret.logLevel;
+        delete ret.clearScreen;
+        delete ret.configLoader;
+        delete ret.d;
+        delete ret.debug;
+        delete ret.f;
+        delete ret.filter;
+        delete ret.m;
+        delete ret.mode;
+        delete ret.force;
+        delete ret.w;
+        // convert the sourcemap option to a boolean if necessary
+        if ('sourcemap' in ret) {
+            const sourcemap = ret.sourcemap;
+            ret.sourcemap = sourcemap === 'true' ? true : sourcemap === 'false' ? false : ret.sourcemap;
+        }
+        if ('watch' in ret) {
+            const watch = ret.watch;
+            ret.watch = watch ? {} : undefined;
+        }
+        return ret;
+    }
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L141
+    function cleanBuilderCLIOptions(options) {
+        const ret = { ...options };
+        delete ret.app;
+        return ret;
+    }
+}

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -1,18 +1,21 @@
 export { isViteServerSide };
-export { isViteClientSide };
 export { isViteServerSide_viteEnvOptional };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
 export type { ViteEnv };
-import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
+import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig, Plugin } from 'vite';
 type ViteEnv = {
     name?: string;
     config: EnvironmentOptions | Environment['config'];
 };
 declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_viteEnvOptional(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
-declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_extraSafe(config: ResolvedConfig, viteEnv: ViteEnv, options: {
     ssr?: boolean;
 } | undefined): boolean;
+type PartialEnvironment = Parameters<NonNullable<Plugin['applyToEnvironment']>>[0];
+declare function isViteServerSide_applyToEnvironment(env: PartialEnvironment): boolean;
+declare function isViteServerSide_configEnvironment(name: string, config: EnvironmentOptions): boolean;

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -1,8 +1,9 @@
 export { isViteServerSide };
-export { isViteClientSide };
 export { isViteServerSide_viteEnvOptional };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
 import { assert } from '../../../utils/assert.js';
 function isViteServerSide_impl(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
@@ -42,9 +43,6 @@ function isViteServerSide(configGlobal, viteEnv) {
 function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
     return isViteServerSide_impl(configGlobal, viteEnv);
 }
-function isViteClientSide(configGlobal, viteEnv) {
-    return !isViteServerSide(configGlobal, viteEnv);
-}
 // Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
 function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
     return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
@@ -64,3 +62,14 @@ function isViteServerSide_extraSafe(config, viteEnv, options) {
     assert(options.ssr === isServerSide, debug);
     return isServerSide;
 }
+function isViteServerSide_applyToEnvironment(env) {
+    const { consumer } = env.config;
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_configEnvironment(name, config) {
+    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_consumer(consumer) {
+    return consumer !== 'client';
+}

package/dist/esm/node/vite/shared/loggerNotProd/errorWithCodeSnippet.js

@@ -8,7 +8,7 @@ export { getPrettyErrMessage };
 // Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
 import pc from '@brillout/picocolors';
 import { assert, escapeRegex, isObject, removeEmptyLines, stripAnsi } from '../../utils.js';
-import { cleanFilePathUnknown, getFilePathToShowToUserFromUnknown } from '../getFilePath.js';
+import { cleanFilePathUnknown, getFilePathToShowToUserUnknown } from '../getFilePath.js';
 function isErrorWithCodeSnippet(err) {
     if (!isObject(err)) {
         return false;
@@ -47,7 +47,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathToShowToUserFromUnknown(id, userRootDir))),
+        pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir))),
         pc.red('because:'),
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);

package/dist/esm/node/vite/shared/loggerNotProd/log.js

@@ -6,6 +6,7 @@ import { assert, stripAnsi, hasProp, assertIsNotProductionRuntime, PROJECT_VERSI
 import pc from '@brillout/picocolors';
 import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { getViteDevServer } from '../../../runtime/globalContext.js';
+import { logErrorServer } from '../../../runtime/logErrorServer.js';
 assertIsNotProductionRuntime();
 function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
     const projectTag = getProjectTag(showVikeVersion);
@@ -39,10 +40,15 @@ function logDirectly(thing, logType) {
         console.warn(thing);
         return;
     }
-    if (logType === 'error') {
+    if (logType === 'error-note') {
         console.error(thing);
         return;
     }
+    if (logType === 'error-thrown') {
+        // console.error()
+        logErrorServer(thing);
+        return;
+    }
     if (logType === 'error-recover') {
         // stderr because user will most likely want to know about error recovering
         console.error(thing);
@@ -63,7 +69,7 @@ function applyViteSourceMapToStackTrace(thing) {
 }
 function prependTags(msg, projectTag, category, logType) {
     const color = (s) => {
-        if (logType === 'error' && !hasRed(msg))
+        if (logType === 'error-thrown' && !hasRed(msg))
             return pc.bold(pc.red(s));
         if (logType === 'error-recover' && !hasGreen(msg))
             return pc.bold(pc.green(s));

package/dist/esm/node/vite/shared/loggerNotProd.d.ts

@@ -10,7 +10,7 @@ export type { LogError };
 export type { LogErrorArgs };
 export type { LogType };
 export type { LogCategory };
-type LogType = 'info' | 'warn' | 'error' | 'error-recover';
+type LogType = 'info' | 'warn' | 'error-thrown' | 'error-recover' | 'error-note';
 type LogCategory = 'config' | `request(${number})`;
 type LogInfo = (...args: LogInfoArgs) => void;
 type LogInfoArgs = Parameters<typeof logRuntimeInfo>;

package/dist/esm/node/vite/shared/loggerNotProd.js

@@ -89,7 +89,7 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
             assert(viteConfig);
             const prettyErr = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
             assert(stripAnsi(prettyErr).startsWith('Failed to transpile'));
-            logWithViteTag(prettyErr, 'error', category);
+            logWithViteTag(prettyErr, 'error-thrown', category);
             logErrorDebugNote();
             return;
         }
@@ -103,12 +103,12 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
     const hook = isUserHookError(err);
     if (hook) {
         const { hookName, hookFilePath } = hook;
-        logWithVikeTag(pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);
+        logWithVikeTag(pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error-note', category);
     }
     else if (category) {
         logFallbackErrIntro(category, errorComesFromVite);
     }
-    logDirectly(err, 'error');
+    logDirectly(err, 'error-thrown');
     // Needs to be called after logging the error.
     onRuntimeError(err);
 }
@@ -119,8 +119,8 @@ function logConfigError(err) {
         const errIntroMsg = getConfigExecutionErrorIntroMsg(err);
         if (errIntroMsg) {
             assert(stripAnsi(errIntroMsg).startsWith('Failed to execute'));
-            logWithVikeTag(errIntroMsg, 'error', category);
-            logDirectly(err, 'error');
+            logWithVikeTag(errIntroMsg, 'error-note', category);
+            logDirectly(err, 'error-thrown');
             return;
         }
     }
@@ -129,10 +129,10 @@ function logConfigError(err) {
         if (errMsgFormatted) {
             assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
             if (!isErrorDebug()) {
-                logWithVikeTag(errMsgFormatted, 'error', category);
+                logWithVikeTag(errMsgFormatted, 'error-thrown', category);
             }
             else {
-                logDirectly(err, 'error');
+                logDirectly(err, 'error-thrown');
             }
             return;
         }
@@ -144,11 +144,11 @@ function logConfigError(err) {
     }
     if (category)
         logFallbackErrIntro(category, false);
-    logDirectly(err, 'error');
+    logDirectly(err, 'error-thrown');
 }
 function logFallbackErrIntro(category, errorComesFromVite) {
     const msg = errorComesFromVite ? 'Transpilation error' : 'An error was thrown';
-    logWithVikeTag(pc.bold(pc.red(`[Error] ${msg}:`)), 'error', category);
+    logWithVikeTag(pc.bold(pc.red(`[Error] ${msg}:`)), 'error-note', category);
 }
 function getConfigCategory() {
     const category = getCategory() ?? 'config';
@@ -159,7 +159,7 @@ function handleAssertMsg(err, category) {
     if (!res)
         return false;
     const { assertMsg, showVikeVersion } = res;
-    logWithVikeTag(assertMsg, 'error', category, showVikeVersion);
+    logWithVikeTag(assertMsg, 'error-thrown', category, showVikeVersion);
     return true;
 }
 function assertLogger(thing, logType) {
@@ -189,7 +189,7 @@ function logErrorDebugNote() {
         store.errorDebugNoteAlreadyShown = true;
     }
     const msg = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
-    logDirectly(msg, 'error');
+    logDirectly(msg, 'error-note');
 }
 function getCategory(httpRequestId = null) {
     const store = getHttpRequestAsyncStore();

package/dist/esm/node/vite/shared/loggerVite.js

@@ -9,8 +9,8 @@ function improveViteLogs(config) {
     intercept('warn', config);
     intercept('error', config);
 }
-function intercept(logType, config) {
-    config.logger[logType] = (msg, options = {}) => {
+function intercept(loggerType, config) {
+    config.logger[loggerType] = (msg, options = {}) => {
         assert(!isErrorDebug());
         if (removeSuperfluousViteLog(msg))
             return;
@@ -38,6 +38,8 @@ function intercept(logType, config) {
         }
         // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
         const prependViteTag = options.timestamp || !!store?.httpRequestId;
+        // If it's an actual error => options.error is set => it's handled with logViteError() above
+        const logType = loggerType === 'error' ? 'error-note' : loggerType;
         logViteAny(msg, logType, store?.httpRequestId ?? null, prependViteTag);
     };
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -27,6 +27,11 @@ const configDefinitionsBuiltIn = {
         global: true,
         cumulative: true,
     },
+    onError: {
+        env: { server: true },
+        global: true,
+        cumulative: true,
+    },
     onBeforeRender: {
         env: { server: true },
     },
@@ -96,11 +101,11 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true },
     },
-    serverOnlyHooks: {
+    hasServerOnlyHook: {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const sources = ['data', 'onBeforeRender', 'onCreatePageContext']
+            const sources = ['data', 'onBeforeRender', 'onCreatePageContext', 'guard']
                 .map((hookName) => getConfigValueSourcesRelevant(hookName, {
                 isForClientSide: false,
                 // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
@@ -171,6 +176,10 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    force: {
+        env: { config: true },
+        global: true,
+    },
     csp: {
         env: { server: true },
     },
@@ -207,6 +216,7 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    // This is deprecated (since Summer 2025). But don't remove this (yet) — otherwise it will break older Vike extensions that still use it.
     vite6BuilderApp: {
         env: { config: true },
         global: true,

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/transpileAndExecuteFile.js

@@ -141,6 +141,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         return resolved;
                     }
                     assert(resolved.path);
+                    // Built-in modules e.g. node:fs
+                    if (resolved.path === args.path) {
+                        const isPointerImport = false;
+                        pointerImports[args.path] = isPointerImport;
+                        if (debug.isActivated)
+                            debug('onResolve() [built-in module]', { args, resolved });
+                        assert(resolved.external);
+                        return resolved;
+                    }
                     const importPathResolved = toPosixPath(resolved.path);
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
@@ -185,7 +194,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         // User-land config code (i.e. not runtime code) => let esbuild transpile it
                         assert(!isPointerImport && !isNpmPkgImport);
                         if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                            debug('onResolve() [non-external]', { args, resolved, isPointerImport, isExternal });
                         return resolved;
                     }
                     let importPathTranspiled;
@@ -217,7 +226,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         }
                     }
                     if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
+                        debug('onResolve() [external]', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
                     assert(isExternal);
                     assert(
                     // Import of runtime code => handled by Vike
@@ -382,12 +391,7 @@ function triggerPrepareStackTrace(err) {
 }
 function getErrIntroMsg(operation, filePath) {
     const { filePathToShowToUserResolved } = filePath;
-    const msg = [
-        // prettier ignore
-        pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(filePathToShowToUserResolved)),
-        pc.red(`because:`),
-    ].join(' ');
+    const msg = `${pc.red(`Failed to ${operation}`)} ${pc.bold(pc.red(filePathToShowToUserResolved))} ${pc.red(`because:`)}`;
     return msg;
 }
 function cleanEsbuildErrors(errors) {

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

@@ -4,6 +4,7 @@ export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
+export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
@@ -45,6 +46,7 @@ declare function getVikeConfigInternalSync(): VikeConfigInternal;
 declare function getVikeConfig(config: ResolvedConfig | UserConfig): VikeConfig;
 type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContext'>;
 declare function setVikeConfigContext(vikeConfigCtx_: VikeConfigContext): void;
+declare function isVikeConfigContextSet(): boolean;
 declare function getVikeConfigInternalOptional(): Promise<null | VikeConfigInternal>;
 declare function isV1Design(): boolean;
 declare function getVikeConfigFromCliOrEnv(): {

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

@@ -5,6 +5,7 @@ export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
+export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
@@ -83,6 +84,9 @@ function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
     globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
+function isVikeConfigContextSet() {
+    return !!globalObject.vikeConfigCtx;
+}
 async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!globalObject.vikeConfigPromise) {
         resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);

package/dist/esm/node/vite/utils.d.ts

@@ -20,3 +20,4 @@ export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
 export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';

package/dist/esm/node/vite/utils.js

@@ -27,3 +27,4 @@ export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
 export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';