vike 0.4.238 → 0.4.239-commit-33e55d4

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

@@ -8,73 +8,100 @@ import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
 import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+const skipNodeModules = '/node_modules/'; // Only apply `.server.js` and `.client.js` to user files
+const filterRolldown = {
+    id: {
+        include: ['client', 'server'].map((env) => `**/*${getSuffix(env)}*`),
+        exclude: [`**${skipNodeModules}**`],
+    },
+};
+const filterFunction = (id) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!id.includes(getSuffix('client')) && !id.includes(getSuffix('server')))
+        return false;
+    return true;
+};
 function pluginFileEnv() {
     let config;
     let viteDevServer;
     return {
         name: 'vike:pluginFileEnv',
-        load(id, options) {
-            // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
-            if (!viteDevServer)
-                return;
-            if (!isV1Design())
-                return;
-            if (skip(id))
-                return;
-            // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
-            if (id.endsWith('?direct'))
-                id = id.slice(0, -1 * '?direct'.length);
-            const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
-            assert(moduleInfo);
-            const importers = Array.from(moduleInfo.importers)
-                .map((m) => m.id)
-                .filter((id) => id !== null);
-            assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
-            // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
-            true);
+        load: {
+            filter: filterRolldown,
+            handler(id, options) {
+                // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+                if (!viteDevServer)
+                    return;
+                if (!isV1Design())
+                    return;
+                if (skip(id, config.root))
+                    return;
+                // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
+                if (id.endsWith('?direct'))
+                    id = id.slice(0, -1 * '?direct'.length);
+                const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
+                assert(moduleInfo);
+                const importers = Array.from(moduleInfo.importers)
+                    .map((m) => m.id)
+                    .filter((id) => id !== null);
+                assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
+                // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
+                true);
+            },
         },
         // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
-        async transform(code, id, options) {
-            id = normalizeId(id);
-            // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
-            if (viteDevServer)
-                return;
-            if (skip(id))
-                return;
-            const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
-            if (!isWrongEnv(id, isServerSide))
-                return;
-            const { importers } = this.getModuleInfo(id);
-            // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
-            const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
-            // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
-            const { exportNames } = await getExportNames(code);
-            return rollupSourceMapRemove([
-                `throw new Error(${JSON.stringify(errMsg)});`,
-                ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
-            ].join('\n'));
-        },
-        generateBundle() {
-            Array.from(this.getModuleIds())
-                .filter((id) => !skip(id))
-                .forEach((moduleId) => {
-                const mod = this.getModuleInfo(moduleId);
-                const { importers } = mod;
-                if (importers.length === 0) {
-                    // Dynamic imports can only be verified at runtime
-                    /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
-                    assert(dynamicImporters.length > 0)
-                    */
+        transform: {
+            filter: filterRolldown,
+            async handler(code, id, options) {
+                id = normalizeId(id);
+                // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+                if (viteDevServer)
+                    return;
+                if (skip(id, config.root))
+                    return;
+                const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
+                if (!isWrongEnv(id, isServerSide))
                     return;
-                }
-                assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
-            });
+                const { importers } = this.getModuleInfo(id);
+                // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
+                const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+                // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+                const { exportNames } = await getExportNames(code);
+                return rollupSourceMapRemove([
+                    `throw new Error(${JSON.stringify(errMsg)});`,
+                    ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
+                ].join('\n'));
+            },
         },
-        configResolved(config_) {
-            config = config_;
+        generateBundle: {
+            handler() {
+                Array.from(this.getModuleIds())
+                    .filter(filterFunction)
+                    .filter((id) => !skip(id, config.root))
+                    .forEach((moduleId) => {
+                    const mod = this.getModuleInfo(moduleId);
+                    const { importers } = mod;
+                    if (importers.length === 0) {
+                        // Dynamic imports can only be verified at runtime
+                        /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
+                      assert(dynamicImporters.length > 0)
+                      */
+                        return;
+                    }
+                    assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
+                });
+            },
         },
-        configureServer(viteDevServer_) {
-            viteDevServer = viteDevServer_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
+        },
+        configureServer: {
+            handler(viteDevServer_) {
+                viteDevServer = viteDevServer_;
+            },
         },
     };
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
@@ -114,31 +141,27 @@ function pluginFileEnv() {
         }
         return errMsg;
     }
-    function isWrongEnv(moduleId, isServerSide) {
-        const modulePath = getModulePath(moduleId);
-        const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
-        return modulePath.includes(suffixWrong);
-    }
-    function skip(id) {
-        // TO-DO/next-major-release: remove
-        if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
-            return true;
-        if (!id.includes(getSuffix('client')) && !id.includes(getSuffix('server')))
-            return true;
-        if (getModulePath(id).endsWith('.css'))
-            return true;
-        // Apply `.server.js` and `.client.js` only to user files
-        if (id.includes('/node_modules/'))
-            return true;
-        // Only user files
-        if (!id.startsWith(config.root))
-            return true;
-        return false;
-    }
-    function getSuffix(env) {
-        return `.${env}.`;
-    }
-    function getModulePath(moduleId) {
-        return moduleId.split('?')[0];
-    }
+}
+function isWrongEnv(moduleId, isServerSide) {
+    const modulePath = getModulePath(moduleId);
+    const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
+    return modulePath.includes(suffixWrong);
+}
+function skip(id, userRootDir) {
+    assert(filterFunction(id));
+    // TO-DO/next-major-release: remove
+    if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
+        return true;
+    if (getModulePath(id).endsWith('.css'))
+        return true;
+    // Skip linked dependencies
+    if (!id.startsWith(userRootDir))
+        return true;
+    return false;
+}
+function getSuffix(env) {
+    return `.${env}.`;
+}
+function getModulePath(moduleId) {
+    return moduleId.split('?')[0];
 }

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

@@ -1,9 +1,20 @@
 export { pluginNonRunnableDev };
-import { createViteRPC, assertIsNotProductionRuntime, requireResolveDistFile, isRunnableDevEnvironment, } from '../utils.js';
+import { createViteRPC, assertIsNotProductionRuntime, requireResolveDistFile, isRunnableDevEnvironment, assert, escapeRegex, isDevCheck, } from '../utils.js';
 import { retrievePageAssetsDev } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
 import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
 import { getMagicString } from '../shared/getMagicString.js';
 assertIsNotProductionRuntime();
+const distFileIsNonRunnableDev = requireResolveDistFile('dist/esm/utils/isNonRunnableDev.js');
+const distFileGlobalContext = requireResolveDistFile('dist/esm/node/runtime/globalContext.js');
+const filterRolldown = {
+    id: {
+        include: [distFileIsNonRunnableDev, distFileGlobalContext].map((filePath) => new RegExp(`^${escapeRegex(filePath)}($|${escapeRegex('?')}.*)`)),
+    },
+};
+const filterFunction = (id) => {
+    const idWithoutQuery = getIdWithoutQuery(id);
+    return idWithoutQuery === distFileIsNonRunnableDev || idWithoutQuery === distFileGlobalContext;
+};
 function getViteRpcFunctions(viteDevServer) {
     return {
         async transformIndexHtmlRPC(html) {
@@ -18,32 +29,40 @@ function getViteRpcFunctions(viteDevServer) {
     };
 }
 function pluginNonRunnableDev() {
-    const distFileIsNonRunnableDev = requireResolveDistFile('dist/esm/utils/isNonRunnableDev.js');
-    const distFileGlobalContext = requireResolveDistFile('dist/esm/node/runtime/globalContext.js');
     let config;
     return {
         name: 'vike:pluginNonRunnableDev',
-        configureServer(viteDevServer) {
-            createViteRPC(viteDevServer, getViteRpcFunctions);
+        apply: (_, configEnv) => isDevCheck(configEnv),
+        configureServer: {
+            handler(viteDevServer) {
+                createViteRPC(viteDevServer, getViteRpcFunctions);
+            },
         },
-        configResolved(config_) {
-            config = config_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
         },
-        transform(code, id) {
-            if (!config._isDev)
-                return;
-            if (id !== distFileIsNonRunnableDev && id !== distFileGlobalContext)
-                return;
-            if (isRunnableDevEnvironment(this.environment))
-                return;
-            const { magicString, getMagicStringResult } = getMagicString(code, id);
-            if (id === distFileIsNonRunnableDev) {
-                magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
-            }
-            if (id === distFileGlobalContext) {
-                magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
-            }
-            return getMagicStringResult();
+        transform: {
+            filter: filterRolldown,
+            handler(code, id) {
+                assert(config._isDev);
+                assert(filterFunction(id));
+                const idWithoutQuery = getIdWithoutQuery(id);
+                if (isRunnableDevEnvironment(this.environment))
+                    return;
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                if (idWithoutQuery === distFileIsNonRunnableDev) {
+                    magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
+                }
+                if (idWithoutQuery === distFileGlobalContext) {
+                    magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+                }
+                return getMagicStringResult();
+            },
         },
     };
 }
+function getIdWithoutQuery(id) {
+    return id.split('?')[0];
+}

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

@@ -14,32 +14,38 @@ function pluginPreview() {
     return {
         name: 'vike:pluginPreview',
         apply: applyPreview,
-        config() {
-            return {
-                appType: 'custom',
-            };
+        config: {
+            handler() {
+                return {
+                    appType: 'custom',
+                };
+            },
         },
-        async configResolved(config_) {
-            config = config_;
-            vikeConfig = await getVikeConfigInternal();
-            logDockerHint(config.preview.host);
-            // vikeConfig = await getVikeConfig(config)
+        configResolved: {
+            async handler(config_) {
+                config = config_;
+                vikeConfig = await getVikeConfigInternal();
+                logDockerHint(config.preview.host);
+                // vikeConfig = await getVikeConfig(config)
+            },
         },
-        configurePreviewServer(server) {
-            /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
-               - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
-            config.appType = 'mpa'
-            */
-            return () => {
-                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
-                assertDist(isPrerenderingEnabledForAllPages);
-                // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
-                addStaticAssetsMiddleware(server.middlewares);
-                if (!isPrerenderingEnabledForAllPages) {
-                    addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
-                }
-                addStatic404Middleware(server.middlewares);
-            };
+        configurePreviewServer: {
+            handler(server) {
+                /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+                 - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+              config.appType = 'mpa'
+              */
+                return () => {
+                    const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
+                    assertDist(isPrerenderingEnabledForAllPages);
+                    // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
+                    addStaticAssetsMiddleware(server.middlewares);
+                    if (!isPrerenderingEnabledForAllPages) {
+                        addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
+                    }
+                    addStatic404Middleware(server.middlewares);
+                };
+            },
         },
     };
     function assertDist(isPrerenderingEnabledForAllPages) {

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

@@ -1,3 +1,14 @@
 export { pluginReplaceConstants };
+export { filterFunction };
+export { filterRolldown };
 import type { Plugin } from 'vite';
+declare const filterRolldown: {
+    id: {
+        exclude: string;
+    };
+    code: {
+        include: string;
+    };
+};
+declare const filterFunction: (id: string, code: string) => boolean;
 declare function pluginReplaceConstants(): Plugin;

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

@@ -1,49 +1,74 @@
 export { pluginReplaceConstants };
+export { filterFunction };
+export { filterRolldown };
 import { assert, assertPosixPath } from '../utils.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 import { getMagicString } from '../shared/getMagicString.js';
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'import.meta.env.';
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
 function pluginReplaceConstants() {
     let config;
     return {
         name: 'vike:pluginReplaceConstants',
         enforce: 'post',
         apply: 'build',
-        configResolved(config_) {
-            config = config_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
         },
-        transform(code, id, options) {
-            id = normalizeId(id);
-            assertPosixPath(id);
-            if (id.includes('/node_modules/'))
-                return;
-            assertPosixPath(config.root);
-            if (!id.startsWith(config.root))
-                return;
-            if (!code.includes('import.meta.env.'))
-                return;
-            const isBuild = config.command === 'build';
-            assert(isBuild);
-            // Used by vike.dev
-            // https://github.com/vikejs/vike/blob/08a1ff55c80ddca64ca6d4417fefd45fefeb4ffb/docs/vite.config.ts#L12
-            // @ts-expect-error
-            if (config._skipVikeReplaceConstants?.(id))
-                return;
-            const { magicString, getMagicStringResult } = getMagicString(code, id);
-            const constantsMap = [];
-            constantsMap.push({
-                constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
-                replacement: !isViteServerSide_extraSafe(config, this.environment, options),
-            });
-            constantsMap.forEach(({ constants, replacement }) => {
-                if (!constants.some((c) => code.includes(c)))
+        transform: {
+            filter: filterRolldown,
+            handler(code, id, options) {
+                id = normalizeId(id);
+                assertPosixPath(id);
+                assertPosixPath(config.root);
+                if (!id.startsWith(config.root))
+                    return; // skip linked dependencies
+                assert(filterFunction(id, code));
+                const isBuild = config.command === 'build';
+                assert(isBuild);
+                // Used by vike.dev
+                // https://github.com/vikejs/vike/blob/08a1ff55c80ddca64ca6d4417fefd45fefeb4ffb/docs/vite.config.ts#L12
+                // @ts-expect-error
+                if (config._skipVikeReplaceConstants?.(id))
                     return;
-                const regExp = getConstantRegExp(constants);
-                magicString.replaceAll(regExp, JSON.stringify(replacement));
-            });
-            if (!magicString.hasChanged())
-                return null;
-            return getMagicStringResult();
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                const constantsMap = [];
+                constantsMap.push({
+                    constants: [
+                        'pageContext.isClientSide',
+                        'globalContext.isClientSide',
+                        'pageContext.globalContext.isClientSide',
+                    ],
+                    replacement: !isViteServerSide_extraSafe(config, this.environment, options),
+                });
+                constantsMap.forEach(({ constants, replacement }) => {
+                    if (!constants.some((c) => code.includes(c)))
+                        return;
+                    const regExp = getConstantRegExp(constants);
+                    magicString.replaceAll(regExp, JSON.stringify(replacement));
+                });
+                if (!magicString.hasChanged())
+                    return null;
+                return getMagicStringResult();
+            },
         },
     };
 }

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

@@ -20,8 +20,10 @@ function pluginSetGlobalContext() {
                     markSetup_viteDevServer();
                 },
             },
-            configurePreviewServer() {
-                markSetup_vitePreviewServer();
+            configurePreviewServer: {
+                handler() {
+                    markSetup_vitePreviewServer();
+                },
             },
             config: {
                 order: 'pre',

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

@@ -1,5 +1,5 @@
 export { generateVirtualFileGlobalEntryWithOldDesign };
-import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning, } from '../../utils.js';
+import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionMatch, assertWarning, } from '../../utils.js';
 import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
@@ -139,7 +139,7 @@ function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
             const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
             const globOptions = { eager: isEager };
             if (query) {
-                const isNewViteInterface = isVersionOrAbove(viteVersion, '5.1.0');
+                const isNewViteInterface = isVersionMatch(viteVersion, ['5.1.0']);
                 if (isNewViteInterface &&
                     // When used for the old design, the new syntax breaks Vike's CI (surprinsigly so). I couldn't reproduce locally (I didn't dig much).
                     isV1Design) {

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

@@ -2,61 +2,77 @@ export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
 import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
 import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
-import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
+import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, escapeRegex, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../utils.js';
 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 { updateUserFiles } from '../../runtime/globalContext.js';
+import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { getVikeConfigError } from '../../shared/getVikeConfigError.js';
+const filterRolldown = {
+    id: {
+        include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
+    },
+};
+const filterFunction = (id) => isVirtualFileId(id);
 function pluginVirtualFiles() {
     let config;
     return {
         name: 'vike:pluginVirtualFiles',
-        async configResolved(config_) {
-            config = config_;
-            // TO-DO/next-major-release: remove
-            if (!isV1Design())
-                config.experimental.importGlobRestoreExtension = true;
+        configResolved: {
+            async handler(config_) {
+                config = config_;
+                // TO-DO/next-major-release: remove
+                if (!isV1Design())
+                    config.experimental.importGlobRestoreExtension = true;
+            },
         },
-        resolveId(id) {
-            if (isVirtualFileId(id)) {
+        resolveId: {
+            filter: filterRolldown,
+            handler(id) {
+                assert(filterFunction(id));
                 return addVirtualFileIdPrefix(id);
-            }
-        },
-        async handleHotUpdate(ctx) {
-            try {
-                return await handleHotUpdate(ctx, config);
-            }
-            catch (err) {
-                // Vite swallows errors thrown by handleHotUpdate()
-                console.error(err);
-                throw err;
-            }
+            },
         },
-        async load(id, options) {
-            if (!isVirtualFileId(id))
-                return undefined;
-            id = removeVirtualFileIdPrefix(id);
-            const isDev = config._isDev;
-            assert(typeof isDev === 'boolean');
-            const idParsed = parseVirtualFileId(id);
-            if (idParsed) {
-                if (idParsed.type === 'page-entry') {
-                    const code = await generateVirtualFilePageEntry(id, isDev);
-                    return code;
+        handleHotUpdate: {
+            async handler(ctx) {
+                try {
+                    return await handleHotUpdate(ctx, config);
                 }
-                if (idParsed.type === 'global-entry') {
-                    const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
-                    return code;
+                catch (err) {
+                    // Vite swallows errors thrown by handleHotUpdate()
+                    console.error(err);
+                    throw err;
                 }
-            }
+            },
+        },
+        load: {
+            filter: filterRolldown,
+            async handler(id, options) {
+                assert(filterFunction(id));
+                id = removeVirtualFileIdPrefix(id);
+                const isDev = config._isDev;
+                assert(typeof isDev === 'boolean');
+                const idParsed = parseVirtualFileId(id);
+                if (idParsed) {
+                    if (idParsed.type === 'page-entry') {
+                        const code = await generateVirtualFilePageEntry(id, isDev);
+                        return code;
+                    }
+                    if (idParsed.type === 'global-entry') {
+                        const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                        return code;
+                    }
+                }
+            },
         },
-        configureServer(server) {
-            handleFileAddRemove(server, config);
+        configureServer: {
+            handler(server) {
+                handleFileAddRemove(server, config);
+            },
         },
     };
 }
@@ -125,7 +141,9 @@ async function handleHotUpdate(ctx, config) {
             // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
             // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            updateUserFiles();
+            if (isRunnable(server)) {
+                await updateUserFiles();
+            }
         }
     }
 }