vike 0.4.236 → 0.4.237-commit-8749e81

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.js

@@ -8,14 +8,14 @@ import fs_sync from 'node:fs';
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique, } from '../../utils.js';
-import { isVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
-import { manifestTempFile } from './pluginBuildConfig.js';
+import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfigInternal, isV1Design } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
+import { isViteServerBuild_onlySsrEnv, isViteServerBuild, isViteServerBuild_withoutEnv, } from '../../shared/isViteServerBuild.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
 // true  => use workaround config.build.ssrEmitAssets
@@ -26,15 +26,14 @@ function handleAssetsManifest_isFixEnabled(config) {
 }
 /** https://github.com/vikejs/vike/issues/1339 */
 async function fixServerAssets(config) {
-    const outDirs = getOutDirs(config);
-    const clientManifest = await readManifestFile(outDirs.outDirClient);
-    const serverManifest = await readManifestFile(outDirs.outDirServer);
+    const clientManifest = await readManifestFile(config, true);
+    const serverManifest = await readManifestFile(config, false);
     const { clientManifestMod, serverManifestMod, filesToMove, filesToRemove } = addServerAssets(clientManifest, serverManifest);
     await copyAssets(filesToMove, filesToRemove, config);
     return { clientManifestMod, serverManifestMod };
 }
 async function copyAssets(filesToMove, filesToRemove, config) {
-    const { outDirClient, outDirServer } = getOutDirs(config);
+    const { outDirClient, outDirServer } = getOutDirs(config, undefined);
     const assetsDir = getAssetsDir(config);
     const assetsDirServer = path.posix.join(outDirServer, assetsDir);
     if (!filesToMove.length && !filesToRemove.length && !existsSync(assetsDirServer))
@@ -166,13 +165,13 @@ function addServerAssets(clientManifest, serverManifest) {
 }
 function getPageId(key) {
     // Normalize from:
-    //   ../../virtual:vike:pageConfigLazy:client:/pages/index
+    //   ../../virtual:vike:page-entry:client:/pages/index
     // to:
-    //   virtual:vike:pageConfigLazy:client:/pages/index
+    //   virtual:vike:page-entry:client:/pages/index
     // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
     key = key.substring(key.indexOf('virtual:vike'));
-    const result = isVirtualFileIdPageConfigLazy(key);
-    return result && result.pageId;
+    const result = parseVirtualFileId(key);
+    return result && result.type === 'page-entry' ? result.pageId : null;
 }
 function collectResources(entryRoot, manifest) {
     const css = [];
@@ -217,10 +216,10 @@ function handleAssetsManifest_assertUsageCssCodeSplit(config) {
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
 const targets = [];
-function handleAssetsManifest_assertUsageCssTarget(config) {
+function handleAssetsManifest_assertUsageCssTarget(config, env) {
     if (!handleAssetsManifest_isFixEnabled(config))
         return;
-    const isServerSide = isViteServerBuild(config);
+    const isServerSide = isViteServerBuild(config, env);
     assert(typeof isServerSide === 'boolean');
     assert(config.build.target !== undefined);
     targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
@@ -265,8 +264,8 @@ function removeEmptyDirectories(dirPath) {
         fs_sync.rmdirSync(dirPath);
     }
 }
-async function readManifestFile(outDir) {
-    const manifestFilePath = path.posix.join(outDir, manifestTempFile);
+async function readManifestFile(config, client) {
+    const manifestFilePath = getManifestFilePath(config, client);
     const manifestFileContent = await fs.readFile(manifestFilePath, 'utf-8');
     assert(manifestFileContent);
     const manifest = JSON.parse(manifestFileContent);
@@ -287,20 +286,20 @@ async function handleAssetsManifest_getBuildConfig(config) {
         ssrEmitAssets: isFixEnabled ? true : undefined,
         // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
         cssMinify: isFixEnabled ? 'esbuild' : undefined,
-        manifest: manifestTempFile,
+        manifest: true,
         copyPublicDir: vikeConfig.config.vite6BuilderApp
             ? // Already set by vike:build:pluginBuildApp
                 undefined
-            : !isViteServerBuild(config),
+            : !isViteServerBuild_withoutEnv(config),
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
-    const isSsREnv = isViteServerBuild_onlySsrEnv(config, viteEnv);
-    if (isSsREnv) {
+    const isSsrEnv = isViteServerBuild_onlySsrEnv(config, viteEnv);
+    if (isSsrEnv) {
         assert(!assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-        await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
+        await writeAssetsManifestFile(assetsJsonFilePath, config);
     }
     if (isViteServerBuild(config, viteEnv)) {
         const outDir = options.dir;
@@ -310,14 +309,14 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
         // - Also in some other server builds such as dist/vercel/ from vike-vercel
         // - Don't replace it in dist/rsc/ from vike-react-rsc since __VITE_ASSETS_MANIFEST__ doesn't exist there
         const noop = await set_macro_ASSETS_MANIFEST(assetsJsonFilePath, bundle, outDir);
-        if (isSsREnv)
+        if (isSsrEnv)
             assert(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }
 }
-async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
+async function writeAssetsManifestFile(assetsJsonFilePath, config) {
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
-    const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
-    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+    const clientManifestFilePath = getManifestFilePath(config, true);
+    const serverManifestFilePath = getManifestFilePath(config, false);
     if (!isFixEnabled) {
         await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
     }
@@ -328,3 +327,12 @@ async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
     await fs.rm(clientManifestFilePath);
     await fs.rm(serverManifestFilePath);
 }
+function getManifestFilePath(config, client) {
+    const outDirs = getOutDirs(config, undefined);
+    const outDir = client ? outDirs.outDirClient : outDirs.outDirServer;
+    const env = client ? config.environments.client : config.environments.ssr;
+    assert(env);
+    const manifestFilePathRelative = getManifestFilePathRelative(env.build.manifest);
+    const manifestFilePath = path.posix.join(outDir, manifestFilePathRelative);
+    return manifestFilePath;
+}

package/dist/esm/node/vite/plugins/pluginBuild/pluginAutoFullBuild.js

@@ -6,12 +6,12 @@ import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/c
 import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
-import { manifestTempFile } from './pluginBuildConfig.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { isVikeCliOrApi } from '../../../api/context.js';
 import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
 import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/isViteServerBuild.js';
 import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
@@ -55,7 +55,7 @@ function pluginAutoFullBuild() {
                 order: 'post',
                 async handler() {
                     onSetupBuild();
-                    handleAssetsManifest_assertUsageCssTarget(config);
+                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
                     const vikeConfig = await getVikeConfigInternal();
                     if (forceExit &&
                         // Let vike:build:pluginBuildApp force exit
@@ -82,7 +82,7 @@ async function triggerFullBuild(config, viteEnv, bundle) {
     //  - The legacy plugin triggers its own Rollup build for the client-side.
     //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
     //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
-    if (!bundle[manifestTempFile])
+    if (!bundle[getManifestFilePathRelative(config.build.manifest)])
         return;
     const configInline = getFullBuildInlineConfig(config);
     if (!isBuilderApp) {

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildApp.js

@@ -6,6 +6,34 @@ import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 function pluginBuildApp() {
     return [
+        {
+            name: 'vike:build:pluginBuildApp:pre',
+            apply: 'build',
+            enforce: 'pre',
+            config: {
+                order: 'pre',
+                async handler(_config) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    if (!vikeConfig.config.vite6BuilderApp)
+                        return;
+                    return {
+                        builder: {
+                            // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
+                            async buildApp(builder) {
+                                assert(builder.environments.client);
+                                assert(builder.environments.ssr);
+                                await builder.build(builder.environments.client);
+                                await builder.build(builder.environments.ssr);
+                                if (isPrerenderForceExit()) {
+                                    runPrerender_forceExit();
+                                    assert(false);
+                                }
+                            },
+                        },
+                    };
+                },
+            },
+        },
         {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
@@ -14,19 +42,6 @@ function pluginBuildApp() {
                 if (!vikeConfig.config.vite6BuilderApp)
                     return;
                 return {
-                    builder: {
-                        // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
-                        async buildApp(builder) {
-                            assert(builder.environments.client);
-                            assert(builder.environments.ssr);
-                            await builder.build(builder.environments.client);
-                            await builder.build(builder.environments.ssr);
-                            if (isPrerenderForceExit()) {
-                                runPrerender_forceExit();
-                                assert(false);
-                            }
-                        },
-                    },
                     environments: {
                         ssr: {
                             consumer: 'server',
@@ -38,6 +53,7 @@ function pluginBuildApp() {
                         client: {
                             consumer: 'client',
                             build: {
+                                outDir: resolveOutDir(config, false),
                                 copyPublicDir: true,
                                 ssr: false,
                             },

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.d.ts

@@ -1,10 +1,8 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
-declare const manifestTempFile = "_temp_manifest.json";
 declare function pluginBuildConfig(): Plugin[];
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
     hasClientRouting: boolean;

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -1,22 +1,21 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { manifestTempFile };
 import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { getVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { resolveOutDir } from '../../shared/getOutDirs.js';
+import { isViteServerBuild_withoutEnv } from '../../shared/isViteServerBuild.js';
+import { resolveOutDir_configEnvironment } from '../../shared/getOutDirs.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-const manifestTempFile = '_temp_manifest.json';
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 function pluginBuildConfig() {
     let config;
+    let configUnresolved;
     return [
         {
             name: 'vike:build:pluginBuildConfig',
@@ -35,18 +34,26 @@ function pluginBuildConfig() {
                     handleAssetsManifest_assertUsageCssCodeSplit(config);
                 },
             },
-            config: {
+            configEnvironment: {
                 order: 'post',
-                async handler(config) {
-                    onSetupBuild();
+                async handler(envName, configEnv) {
+                    assert(configUnresolved);
                     return {
                         build: {
-                            outDir: resolveOutDir(config),
-                            ...(await handleAssetsManifest_getBuildConfig(config)),
+                            outDir: resolveOutDir_configEnvironment(configUnresolved, envName, configEnv),
                         },
                     };
                 },
             },
+            config: {
+                order: 'post',
+                async handler(config) {
+                    configUnresolved = config;
+                    onSetupBuild();
+                    const build = await handleAssetsManifest_getBuildConfig(config);
+                    return { build };
+                },
+            },
             buildStart() {
                 onSetupBuild();
             },
@@ -59,7 +66,7 @@ async function getEntries(config) {
     // TO-DO/next-major-release: remove
     const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config));
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
-    if (isViteServerBuild(config)) {
+    if (isViteServerBuild_withoutEnv(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
@@ -132,7 +139,7 @@ function analyzeClientEntries(pageConfigs, config) {
 // Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
 // (Otherwise the page files may be missing in the client manifest.json)
 async function getPageFileEntries(config, includeAssetsImportedByServer) {
-    const isForClientSide = !isViteServerBuild(config);
+    const isForClientSide = !isViteServerBuild_withoutEnv(config);
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');
@@ -176,7 +183,7 @@ function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
 }
 function getEntryFromPageConfig(pageConfig, isForClientSide) {
     let { pageId } = pageConfig;
-    const entryTarget = getVirtualFileIdPageConfigLazy(pageId, isForClientSide);
+    const entryTarget = generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide });
     let entryName = pageId;
     // Avoid:
     // ```

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildEntry.js

@@ -1,7 +1,7 @@
 export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
-import { virtualFileIdEntryServer } from '../../../shared/virtualFiles/virtualFileEntry.js';
+import { virtualFileIdGlobalEntryServer } from '../../../shared/virtualFileId.js';
 import { assert, PROJECT_VERSION, requireResolveVikeDistFile } from '../../utils.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -40,14 +40,14 @@ function getServerProductionEntryCode(config) {
     // After the old design is removed, let's maybe simplify and move everything into a single virtual module
     const importerCode = [
         `  import { setGlobalContext_buildEntry } from '${importPath}';`,
-        `  import * as virtualFileExports from '${virtualFileIdEntryServer}';`,
+        `  import * as virtualFileExportsGlobalEntry from '${virtualFileIdGlobalEntryServer}';`,
         `  {`,
         // Because of a Rollup bug, we have to assign ASSETS_MANIFEST to a variable before passing it to setGlobalContext_buildEntry()
         // - This workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
         `    const assetsManifest = ${ASSETS_MANIFEST};`,
         `    const buildInfo = ${JSON.stringify(buildInfo, null, 2)};`,
         '    setGlobalContext_buildEntry({',
-        `      virtualFileExports,`,
+        `      virtualFileExportsGlobalEntry,`,
         `      assetsManifest,`,
         `      buildInfo,`,
         '    });',
@@ -97,7 +97,7 @@ function getImportPath(config) {
         return 'vike/__internal';
     }
     else {
-        const { outDirServer } = getOutDirs(config);
+        const { outDirServer } = getOutDirs(config, undefined);
         const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
         return filePathRelative;
     }

package/dist/esm/node/vite/plugins/pluginBuild/pluginDistFileNames.js

@@ -101,6 +101,7 @@ function getIdHash(id) {
     return crypto.createHash('md5').update(id).digest('hex').slice(0, 8);
 }
 function getAssetFileName(assetInfo, config) {
+    const userRootDir = config.root;
     const assetsDir = getAssetsDir(config);
     const dir = assetsDir + '/static';
     let { name } = assetInfo;
@@ -118,11 +119,11 @@ function getAssetFileName(assetInfo, config) {
         // Vite 3
         name?.endsWith('?extractAssets&lang.css')) {
         name = name.split('.').slice(0, -2).join('.');
-        name = clean(name);
+        name = clean(name, userRootDir);
         return `${dir}/${name}.[hash][extname]`;
     }
     name = name.split('.').slice(0, -1).join('.');
-    name = clean(name);
+    name = clean(name, userRootDir);
     return `${dir}/${name}.[hash][extname]`;
 }
 function getChunkFileName(_chunkInfo, config) {
@@ -135,11 +136,12 @@ function getChunkFileName(_chunkInfo, config) {
     return name;
 }
 function getEntryFileName(chunkInfo, config, isEntry) {
+    const userRootDir = config.root;
     const assetsDir = getAssetsDir(config);
     const isForClientSide = !config.build.ssr;
     let { name } = chunkInfo;
     assertPosixPath(name);
-    name = clean(name, true, 
+    name = clean(name, userRootDir, true, 
     // Not needed for client-side because dist/ filenames contain `.[hash].js`
     !isForClientSide);
     if (isForClientSide) {
@@ -151,7 +153,7 @@ function getEntryFileName(chunkInfo, config, isEntry) {
 }
 function removePathSeparators(name) {
     assertPosixPath(name);
-    assert(!name.startsWith('/'));
+    assert(!name.startsWith('/'), { name });
     const entryDir = 'entries/';
     const hasEntryDir = name.startsWith(entryDir);
     if (hasEntryDir) {
@@ -164,7 +166,17 @@ function removePathSeparators(name) {
     }
     return name;
 }
-function clean(name, removePathSep, fixGlob) {
+function removeUserRootDir(name, userRootDir) {
+    if (name.startsWith(userRootDir)) {
+        name = name.slice(userRootDir.length);
+        if (name.startsWith('/'))
+            name = name.slice(1);
+    }
+    assert(!name.startsWith('/'), { name });
+    return name;
+}
+function clean(name, userRootDir, removePathSep, fixGlob) {
+    name = removeUserRootDir(name, userRootDir);
     name = fixExtractAssetsQuery(name);
     if (fixGlob) {
         name = workaroundGlob(name);

package/dist/esm/node/vite/plugins/pluginBuild/pluginDistPackageJsonFile.js

@@ -18,7 +18,7 @@ function pluginDistPackageJsonFile() {
             config = config_;
         },
         generateBundle(options, bundle) {
-            if (!isViteServerBuild(config))
+            if (!isViteServerBuild(config, this.environment))
                 return;
             const isEsm = rollupIsEsm(options);
             const fileName = 'package.json';

package/dist/esm/node/vite/plugins/pluginBuild/pluginModuleBanner.js

@@ -1,7 +1,7 @@
 export { pluginModuleBanner };
-import MagicString from 'magic-string';
-import { removeVirtualIdTag } from '../../../shared/virtualFiles.js';
-import { isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
+import { removeVirtualFileIdPrefix } from '../../utils.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+import { isViteServerBuild_extraSafe } from '../../shared/isViteServerBuild.js';
 // Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
 function pluginModuleBanner() {
@@ -16,26 +16,23 @@ function pluginModuleBanner() {
         transform: {
             order: 'post',
             handler(code, id, options) {
-                if (!isViteServerBuild_safe(config, options) &&
+                if (!isViteServerBuild_extraSafe(config, options, this.environment) &&
                     // Inject module banners if user sets `build.minify` to `false` for inspecting dist/client/
                     config.build.minify) {
                     return;
                 }
                 if (id.startsWith('\0'))
                     id = id;
-                id = removeVirtualIdTag(id);
+                id = removeVirtualFileIdPrefix(id);
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
                 id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
-                const magicString = new MagicString(code);
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
                 // Use legal comment so that esbuild doesn't remove it.
                 // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
                 // - https://esbuild.github.io/api/#legal-comments
                 magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
-                return {
-                    code: magicString.toString(),
-                    map: magicString.generateMap({ hires: true, source: id }),
-                };
+                return getMagicStringResult();
             },
         },
     };

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

@@ -10,4 +10,7 @@ declare module 'vite' {
         _viteConfigFromUserEnhanced?: InlineConfig;
     }
 }
+declare global {
+    var __VIKE__IS_PROCESS_SHARED_WITH_VITE: undefined | true;
+}
 declare function pluginCommon(vikeVitePluginOptions: unknown): Plugin[];

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

@@ -11,6 +11,7 @@ import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVi
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:pluginCommon';
+globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
 function pluginCommon(vikeVitePluginOptions) {
     return [
         {