vike 0.4.236 → 0.4.237-commit-8749e81

package/dist/esm/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -1,74 +1,113 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, unique, } from '../../utils.js';
-import { getVikeConfigInternal, isOverridden } from '../../shared/resolveVikeConfigInternal.js';
+import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, } from '../../utils.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { analyzeClientEntries } from '../pluginBuild/pluginBuildConfig.js';
-import { virtualFileIdEntryClientCR, virtualFileIdEntryClientSR, } from '../../../shared/virtualFiles/virtualFileEntry.js';
+import { virtualFileIdGlobalEntryClientCR, virtualFileIdGlobalEntryClientSR } from '../../../shared/virtualFileId.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
+import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const debug = createDebugger('vike:optimizeDeps');
 async function determineOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
     const { _pageConfigs: pageConfigs } = vikeConfig;
-    const { entries, include } = await getPageDeps(config, pageConfigs);
-    {
-        // This actually 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?)
-        const entriesVirtualFiles = getVirtualFiles(config, pageConfigs);
-        entries.push(...entriesVirtualFiles);
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
+    config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
+    // Workaround until https://github.com/vitejs/vite-plugin-react/issues/650
+    // - TODO/soon: remove workaround once https://github.com/vitejs/vite/pull/20495 is released
+    includeServer.push('react/jsx-dev-runtime');
+    for (const envName in config.environments) {
+        const env = config.environments[envName];
+        if (env.consumer === 'server' && env.optimizeDeps.noDiscovery === false) {
+            env.optimizeDeps.include = add(env.optimizeDeps.include, includeServer);
+            env.optimizeDeps.entries = add(env.optimizeDeps.entries, entriesServer);
+        }
     }
-    /* Other Vite plugins may populate optimizeDeps, e.g. Cypress: https://github.com/vikejs/vike/issues/386
-    assert(config.optimizeDeps.entries === undefined)
-    */
-    config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
-    config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
     if (debug.isActivated)
-        debug('config.optimizeDeps', {
+        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,
         });
 }
 async function getPageDeps(config, pageConfigs) {
-    let entries = [];
-    let include = [];
-    const addEntry = (e) => {
+    let entriesClient = [];
+    let entriesServer = [];
+    let includeClient = [];
+    let includeServer = [];
+    const addEntry = (e, isForClientSide, definedAt) => {
         assert(e);
-        entries.push(e);
+        // optimizeDeps.entries expects filesystem absolute paths
+        assert(isVirtualFileId(e) || isFilePathAbsoluteFilesystem(e));
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
+            entriesClient.push(e);
+        }
+        else {
+            entriesServer.push(e);
+        }
     };
-    const addInclude = (e) => {
+    const addInclude = (e, isForClientSide, definedAt) => {
         assert(e);
-        // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
+        // optimizeDeps.include expects npm packages
+        assert(!e.startsWith('/'));
+        // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
         assertIsImportPathNpmPackage(e);
-        include.push(e);
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
+            includeClient.push(e);
+        }
+        else {
+            includeServer.push(e);
+        }
+    };
+    const isExcluded = (e, isForClientSide, definedAt) => {
+        const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
+        if (!exclude)
+            return false;
+        if (definedAt?.importPathAbsolute) {
+            const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
+            if (npmPackageName && exclude.includes(npmPackageName))
+                return true;
+        }
+        return exclude.includes(e);
     };
     // V1 design
     {
-        pageConfigs.forEach((pageConfig) => {
-            Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-                sources
-                    .filter((source) => !isOverridden(source, configName, pageConfig))
-                    .forEach((configValueSource) => {
-                    if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
-                        return;
-                    const { definedAt, configEnv } = configValueSource;
-                    if (!configEnv.client)
-                        return;
-                    if (definedAt.definedBy)
-                        return;
-                    if (definedAt.importPathAbsolute) {
-                        const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
-                        if (npmPackageName && config.optimizeDeps.exclude?.includes(npmPackageName))
+        ;
+        [true, false].forEach((isForClientSide) => {
+            pageConfigs.forEach((pageConfig) => {
+                Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
+                    const runtimeEnv = {
+                        isForClientSide,
+                        isDev: true,
+                        // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                        isClientRouting: true,
+                    };
+                    const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
+                    sourcesRelevant.forEach((configValueSource) => {
+                        if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
                             return;
-                    }
-                    if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                        // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                        addEntry(definedAt.filePathAbsoluteFilesystem);
-                    }
-                    else {
-                        // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                        addInclude(definedAt.importPathAbsolute);
-                    }
+                        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);
+                        }
+                    });
                 });
             });
         });
@@ -80,35 +119,42 @@ async function getPageDeps(config, pageConfigs) {
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
             const { filePathAbsoluteFilesystem } = entry;
-            addEntry(filePathAbsoluteFilesystem);
+            addEntry(filePathAbsoluteFilesystem, true);
         });
     }
-    entries = unique(entries);
-    include = unique(include);
-    return { entries, include };
-}
-function getVirtualFiles(config, pageConfigs) {
-    const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
-    const entriesVirtualFiles = Object.values(clientEntries);
-    if (hasClientRouting)
-        entriesVirtualFiles.push(virtualFileIdEntryClientCR);
-    if (hasServerRouting)
-        entriesVirtualFiles.push(virtualFileIdEntryClientSR);
-    return entriesVirtualFiles;
+    // 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?)
+    {
+        const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        Object.values(clientEntries).forEach((e) => addEntry(e, true));
+        if (hasClientRouting)
+            addEntry(virtualFileIdGlobalEntryClientCR, true);
+        if (hasServerRouting)
+            addEntry(virtualFileIdGlobalEntryClientSR, true);
+    }
+    entriesClient = entriesClient;
+    entriesServer = entriesServer;
+    includeClient = includeClient;
+    includeServer = includeServer;
+    return {
+        entriesClient,
+        entriesServer,
+        includeClient,
+        includeServer,
+    };
 }
-function normalizeEntries(entries) {
-    if (isArray(entries))
-        return entries;
-    if (typeof entries === 'string')
-        return [entries];
-    if (entries === undefined)
-        return [];
-    assert(false);
+function add(input, listAddendum) {
+    const list = !input ? [] : isArray(input) ? unique(input) : [input];
+    listAddendum.forEach((e) => {
+        if (!list.includes(e))
+            list.push(e);
+    });
+    return list;
 }
-function normalizeInclude(include) {
-    if (isArray(include))
-        return include;
-    if (include === undefined)
-        return [];
-    assert(false);
+function unique(arr) {
+    const arrUnique = Array.from(new Set(arr));
+    return arr.length !== arrUnique.length ? arrUnique : arr;
 }

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

@@ -1,11 +1,10 @@
 export { pluginEnvVars };
-import MagicString from 'magic-string';
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
+import { getMagicString } from '../shared/getMagicString.js';
 // TO-DO/eventually:
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -37,8 +36,8 @@ function pluginEnvVars() {
             if (!code.includes('import.meta.env.'))
                 return;
             const isBuild = config.command === 'build';
-            const isClientSide = !isViteServerBuild_safe(config, options);
-            const magicString = new MagicString(code);
+            const isClientSide = !isViteServerBuild_extraSafe(config, options, this.environment);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
             // Find & check
             const replacements = Object.entries(envsAll)
                 .filter(([key]) => {
@@ -76,14 +75,11 @@ function pluginEnvVars() {
                 .filter(isNotNullish);
             // Apply
             replacements.forEach(({ regExpStr, replacement }) => {
-                applyRegExpWithMagicString(magicString, regExpStr, replacement);
+                magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
             });
             if (!magicString.hasChanged())
                 return null;
-            return {
-                code: magicString.toString(),
-                map: magicString.generateMap({ hires: true, source: id }),
-            };
+            return getMagicStringResult();
         },
     };
 }

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

@@ -6,8 +6,7 @@
 //  - This approach supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
 export { pluginExtractAssets };
 export { extractAssetsRE };
-import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove, } from '../utils.js';
-import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
+import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
@@ -16,8 +15,8 @@ import { handleAssetsManifest_isFixEnabled } from './pluginBuild/handleAssetsMan
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-import { resolveIncludeAssetsImportedByServer } from '../../runtime/renderPage/getPageAssets.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
+import { resolveIncludeAssetsImportedByServer } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -46,7 +45,7 @@ function pluginExtractAssets() {
                 }
                 const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
                 assert(includeAssetsImportedByServer);
-                assert(!isViteServerBuild_safe(config, options));
+                assert(!isViteServerBuild_extraSafe(config, options, this.environment));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
@@ -63,7 +62,7 @@ function pluginExtractAssets() {
             //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
             enforce: 'pre',
             async resolveId(source, importer, options) {
-                if (isViteServerBuild_safe(config, options)) {
+                if (isViteServerBuild_extraSafe(config, options, this.environment)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
                     assert(importer === undefined || !extractAssetsRE.test(importer));
@@ -124,7 +123,7 @@ function pluginExtractAssets() {
             load(id) {
                 if (!isVirtualFileId(id))
                     return undefined;
-                id = getVirtualFileId(id);
+                id = removeVirtualFileIdPrefix(id);
                 if (id === EMPTY_MODULE_ID) {
                     return '// Erased by vike:pluginExtractAssets';
                 }
@@ -151,7 +150,7 @@ function pluginExtractAssets() {
 }
 function emptyModule(file, importer) {
     debugOperation('NUKED', file, importer);
-    return resolveVirtualFileId(EMPTY_MODULE_ID);
+    return addVirtualFileIdPrefix(EMPTY_MODULE_ID);
 }
 function appendExtractAssetsQuery(file, importer) {
     debugOperation('TRANSFORMED', file, importer);

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

@@ -4,18 +4,19 @@ export { extractExportNamesRE };
 import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage, rollupSourceMapRemove, } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_options } from '../shared/isViteServerBuild.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebugger('vike:pluginExtractExportNames');
 const globalObject = getGlobalObject('plugins/pluginExtractExportNames.ts', {});
 function pluginExtractExportNames() {
     let isDev = false;
+    let config;
     return {
         name: 'vike:pluginExtractExportNames',
         enforce: 'post',
         async transform(src, id, options) {
             id = normalizeId(id);
-            const isClientSide = !isViteServerBuild_options(options);
+            const isClientSide = !isViteServerBuild_extraSafe(config, options, this.environment);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
                 debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
@@ -25,6 +26,9 @@ function pluginExtractExportNames() {
         configureServer() {
             isDev = true;
         },
+        configResolved(config_) {
+            config = config_;
+        },
         config() {
             if (debug.isActivated) {
                 return { logLevel: 'silent' };

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

@@ -0,0 +1,26 @@
+export { pluginNonRunnableDev };
+import type { Plugin, ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+export type ViteRPC = ReturnType<typeof getViteRpcFunctions>;
+declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
+    transformIndexHtmlRPC(html: string): Promise<string>;
+    retrievePageAssetsDevRPC(clientDependencies: ClientDependency[], clientEntries: string[]): Promise<{
+        clientEntriesSrc: string[];
+        assetUrls: string[];
+    }>;
+    getViteConfigRuntimeRPC(): Promise<{
+        root: string;
+        build: {
+            outDir: string;
+        };
+        _baseViteOriginal: string;
+        vitePluginServerEntry: {
+            inject: boolean | undefined;
+        };
+    }>;
+};
+declare global {
+    var __VIKE__DYNAMIC_IMPORT: (module: string) => Promise<Record<string, unknown>>;
+    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | boolean;
+}
+declare function pluginNonRunnableDev(): Plugin;

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

@@ -0,0 +1,45 @@
+export { pluginNonRunnableDev };
+import { createViteRPC, assertIsNotProductionRuntime, requireResolveVikeDistFile, isRunnableDevEnvironment, } from '../utils.js';
+import { retrievePageAssetsDev } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
+import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
+import { getMagicString } from '../shared/getMagicString.js';
+assertIsNotProductionRuntime();
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
+            return await retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries);
+        },
+        async getViteConfigRuntimeRPC() {
+            return getViteConfigRuntime(viteDevServer.config);
+        },
+    };
+}
+function pluginNonRunnableDev() {
+    const runtimeGlobalContextFilePath = requireResolveVikeDistFile('dist/esm/node/runtime/globalContext.js');
+    let config;
+    return {
+        name: 'vike:pluginNonRunnableDev',
+        configureServer(viteDevServer) {
+            createViteRPC(viteDevServer, getViteRpcFunctions);
+        },
+        configResolved(config_) {
+            config = config_;
+        },
+        transform(code, id) {
+            if (!config._isDev)
+                return;
+            if (id !== runtimeGlobalContextFilePath)
+                return;
+            const isNonRunnableDev = !isRunnableDevEnvironment(this.environment);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
+            if (isNonRunnableDev) {
+                magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+            }
+            magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(isNonRunnableDev));
+            return getMagicStringResult();
+        },
+    };
+}

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

@@ -1,24 +1,31 @@
 export { pluginPreview };
-import { assertUsage, applyPreview } from '../utils.js';
+import { assertUsage, applyPreview, assert } from '../utils.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
 import { logDockerHint } from './pluginDev.js';
-import { getOutDirs, resolveOutDir } from '../shared/getOutDirs.js';
+import { getOutDirs, resolveOutDir_configEnvironment } from '../shared/getOutDirs.js';
 import sirv from 'sirv';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
     let config;
+    let configUnresolved;
     let vikeConfig;
     return {
         name: 'vike:pluginPreview',
         apply: applyPreview,
         config(config) {
+            configUnresolved = config;
             return {
                 appType: 'custom',
+            };
+        },
+        configEnvironment(envName, configEnv) {
+            assert(configUnresolved);
+            return {
                 build: {
-                    outDir: resolveOutDir(config),
+                    outDir: resolveOutDir_configEnvironment(configUnresolved, envName, configEnv),
                 },
             };
         },
@@ -46,7 +53,7 @@ function pluginPreview() {
         },
     };
     function assertDist(isPrerenderingEnabledForAllPages) {
-        const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
+        const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config, undefined);
         const dirS = [outDirRoot, outDirClient];
         if (!isPrerenderingEnabledForAllPages)
             dirS.push(outDirServer);
@@ -55,11 +62,11 @@ function pluginPreview() {
         });
     }
     function addStaticAssetsMiddleware(middlewares) {
-        const { outDirClient } = getOutDirs(config);
+        const { outDirClient } = getOutDirs(config, undefined);
         middlewares.use(sirv(outDirClient));
     }
     function addStatic404Middleware(middlewares) {
-        const { outDirClient } = getOutDirs(config);
+        const { outDirClient } = getOutDirs(config, undefined);
         middlewares.use(config.base, (_, res, next) => {
             const file = path.posix.join(outDirClient, './404.html');
             if (fs.existsSync(file)) {

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

@@ -1,9 +1,8 @@
 export { pluginReplaceConstants };
-import MagicString from 'magic-string';
 import { assert, assertPosixPath } from '../utils.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
+import { isViteServerBuild_extraSafe } from '../shared/isViteServerBuild.js';
+import { getMagicString } from '../shared/getMagicString.js';
 function pluginReplaceConstants() {
     let config;
     return {
@@ -30,24 +29,21 @@ function pluginReplaceConstants() {
             // @ts-expect-error
             if (config._skipVikeReplaceConstants?.(id))
                 return;
-            const magicString = new MagicString(code);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
             const constantsMap = [];
             constantsMap.push({
                 constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
-                replacement: !isViteServerBuild_safe(config, options),
+                replacement: !isViteServerBuild_extraSafe(config, options, this.environment),
             });
             constantsMap.forEach(({ constants, replacement }) => {
                 if (!constants.some((c) => code.includes(c)))
                     return;
                 const regExp = getConstantRegExp(constants);
-                applyRegExpWithMagicString(magicString, regExp, replacement);
+                magicString.replaceAll(regExp, JSON.stringify(replacement));
             });
             if (!magicString.hasChanged())
                 return null;
-            return {
-                code: magicString.toString(),
-                map: magicString.generateMap({ hires: true, source: id }),
-            };
+            return getMagicStringResult();
         },
     };
 }

package/dist/esm/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.d.ts

@@ -0,0 +1,2 @@
+export { generateVirtualFileGlobalEntry };
+declare function generateVirtualFileGlobalEntry(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean): Promise<string>;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/{getVirtualFilePageConfigsEager.js → generateVirtualFileGlobalEntry.js}

@@ -1,10 +1,9 @@
-export { getVirtualFilePageConfigsEager };
-import { getVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+export { generateVirtualFileGlobalEntry };
+import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
 import { debug } from './debug.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
-async function getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting) {
+async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
     const vikeConfig = await getVikeConfigInternal(true);
     const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -19,6 +18,10 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     lines.push('export const pageConfigGlobalSerialized = {');
     lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('};');
+    if (!isForClientSide && isDev) {
+        // https://vite.dev/guide/api-environment-frameworks.html
+        lines.push('if (import.meta.hot) import.meta.hot.accept();');
+    }
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
@@ -31,11 +34,10 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigLazy(pageId, isForClientSide));
-        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
-        lines.push(`    loadConfigLazy: ${load},`);
+        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide }));
+        lines.push(`    loadVirtualFilePageEntry: () => ({ moduleId: ${virtualFileId}, moduleExportsPromise: import(${virtualFileId}) }),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -45,7 +47,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.d.ts

@@ -0,0 +1,6 @@
+export { generateVirtualFileGlobalEntryWithOldDesign };
+import type { ResolvedConfig } from 'vite';
+import type { Environment } from 'vite';
+declare function generateVirtualFileGlobalEntryWithOldDesign(id: string, options: {
+    ssr?: boolean;
+} | undefined, config: ResolvedConfig, env: Environment, isDev: boolean): Promise<string>;