vike 0.4.237 → 0.4.238-commit-3c1a09d

package/dist/esm/node/shared/virtualFileId.js

@@ -0,0 +1,107 @@
+export { parseVirtualFileId };
+export { generateVirtualFileId };
+export { virtualFileIdGlobalEntryServer };
+export { virtualFileIdGlobalEntryClientSR };
+export { virtualFileIdGlobalEntryClientCR };
+import { extractAssetsRemoveQuery } from './extractAssetsQuery.js';
+import { assert, assertIsNotBrowser, removeVirtualFileIdPrefix } from './utils.js';
+assertIsNotBrowser();
+// Global entries
+const virtualFileIdGlobalEntryServer = 
+//
+'virtual:vike:global-entry:server';
+const virtualFileIdGlobalEntryClientSR = 
+//
+'virtual:vike:global-entry:client:server-routing';
+const virtualFileIdGlobalEntryClientCR = 
+//
+'virtual:vike:global-entry:client:client-routing';
+// Page entries
+const virtualFileIdPageEntryClient = 
+//
+'virtual:vike:page-entry:client:'; // ${pageId}
+const virtualFileIdPageEntryServer = 
+//
+'virtual:vike:page-entry:server:'; //  ${pageId}
+// Virtual ID prefixes
+const virtualFileIdPageEntryPrefix = 
+//
+'virtual:vike:page-entry:';
+const virtualFileIdGlobalEntryPrefix = 
+//
+'virtual:vike:global-entry:';
+const virtualFileIdGlobalEntries = [
+    virtualFileIdGlobalEntryServer,
+    virtualFileIdGlobalEntryClientCR,
+    virtualFileIdGlobalEntryClientSR,
+];
+assert(virtualFileIdGlobalEntries.every((v) => 
+//
+v.startsWith(virtualFileIdGlobalEntryPrefix)));
+assert([virtualFileIdPageEntryClient, virtualFileIdPageEntryServer].every((v) => 
+//
+v.startsWith(virtualFileIdPageEntryPrefix)));
+function parseVirtualFileId(id) {
+    id = removeVirtualFileIdPrefix(id);
+    if (!id.startsWith(virtualFileIdGlobalEntryPrefix) && !id.startsWith(virtualFileIdPageEntryPrefix))
+        return false;
+    // Global entry
+    if (id.includes(virtualFileIdGlobalEntryPrefix)) {
+        assert(virtualFileIdGlobalEntries.includes(id));
+        const isForClientSide = id !== virtualFileIdGlobalEntryServer;
+        const isClientRouting = id === virtualFileIdGlobalEntryClientCR;
+        return {
+            type: 'global-entry',
+            isForClientSide,
+            isClientRouting,
+        };
+    }
+    // Page entry
+    if (id.includes(virtualFileIdPageEntryPrefix)) {
+        assert(id.startsWith(virtualFileIdPageEntryPrefix));
+        const idOriginal = id;
+        id = extractAssetsRemoveQuery(id);
+        const isExtractAssets = idOriginal !== id;
+        if (id.startsWith(virtualFileIdPageEntryClient)) {
+            assert(isExtractAssets === false);
+            return {
+                type: 'page-entry',
+                pageId: id.slice(virtualFileIdPageEntryClient.length),
+                isForClientSide: true,
+                isExtractAssets,
+            };
+        }
+        if (id.startsWith(virtualFileIdPageEntryServer)) {
+            return {
+                type: 'page-entry',
+                pageId: id.slice(virtualFileIdPageEntryServer.length),
+                isForClientSide: false,
+                isExtractAssets,
+            };
+        }
+        assert(false);
+    }
+    return false;
+}
+function generateVirtualFileId(args) {
+    if (args.type === 'global-entry') {
+        const { isForClientSide, isClientRouting } = args;
+        assert(typeof isClientRouting === 'boolean');
+        if (!isForClientSide) {
+            return virtualFileIdGlobalEntryServer;
+        }
+        else if (isClientRouting) {
+            return virtualFileIdGlobalEntryClientCR;
+        }
+        else {
+            return virtualFileIdGlobalEntryClientSR;
+        }
+    }
+    if (args.type === 'page-entry') {
+        const { pageId, isForClientSide } = args;
+        assert(typeof pageId === 'string');
+        const id = `${isForClientSide ? virtualFileIdPageEntryClient : virtualFileIdPageEntryServer}${pageId}`;
+        return id;
+    }
+    assert(false);
+}

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

@@ -17,14 +17,14 @@ import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
 import { pluginEnvVars } from './plugins/pluginEnvVars.js';
 import pc from '@brillout/picocolors';
 import { pluginFileEnv } from './plugins/pluginFileEnv.js';
-import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
-import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
+import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstants } from './plugins/pluginReplaceConstants.js';
 import { pluginNonRunnableDev } from './plugins/pluginNonRunnableDev.js';
+import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
-setResolveClientEntriesDev(resolveClientEntriesDev);
+setGetClientEntrySrcDev(getClientEntrySrcDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [

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

@@ -9,9 +9,11 @@ function onLoad() {
     assertIsNotBrowser();
     assertNodeVersion();
     // package.json#peerDependencies isn't enough as users often ignore it
-    // This assertion isn't reliable: the user may still use a Vite version older than 5.1.0 — see https://github.com/vitejs/vite/pull/19355
-    // TO-DO/eventually: let's also use this.meta.viteVersion https://github.com/vitejs/vite/pull/20088
-    assertVersion('Vite', version, '5.1.0');
+    // This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
+    // TO-DO/eventually: let's also use this.meta.viteVersion
+    // - https://github.com/vitejs/vite/pull/20088
+    // - https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
+    assertVersion('Vite', version, '6.0.0');
     // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
     assertIsNotProductionRuntime();
 }

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

@@ -3,17 +3,16 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
+import type { Environment, ResolvedConfig, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
-declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
+declare function handleAssetsManifest_isFixEnabled(): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
-declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig): void;
-declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promise<{
+declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig, env: Environment): void;
+declare function handleAssetsManifest_getBuildConfig(): Promise<{
     readonly ssrEmitAssets: true | undefined;
     readonly cssMinify: "esbuild" | undefined;
     readonly manifest: true;
-    readonly copyPublicDir: boolean | undefined;
 }>;
-declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: {
+declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment, options: {
     dir: string | undefined;
 }, bundle: Bundle): Promise<void>;

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

@@ -7,20 +7,21 @@ import fs from 'node:fs/promises';
 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 { assert, assertWarning, getGlobalObject, isEqualStringList, isObject, pLimit, unique } from '../../utils.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 { isV1Design } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
+import { isViteServerSide_onlySsrEnv, isViteServerSide } from '../../shared/isViteServerSide.js';
+import { set_macro_ASSETS_MANIFEST } from './pluginProdBuildEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
-assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
-let assetsJsonFilePath;
+const globalObject = getGlobalObject('build/handleAssetsManifest.ts', {
+    assetsJsonFilePath: undefined,
+});
 // true  => use workaround config.build.ssrEmitAssets
 // false => use workaround extractAssets plugin
-function handleAssetsManifest_isFixEnabled(config) {
+function handleAssetsManifest_isFixEnabled() {
     // Allow user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
     return isV1Design();
 }
@@ -33,7 +34,7 @@ async function fixServerAssets(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))
@@ -165,13 +166,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 = [];
@@ -211,15 +212,15 @@ function getHash(src) {
 }
 // https://github.com/vikejs/vike/issues/1993
 function handleAssetsManifest_assertUsageCssCodeSplit(config) {
-    if (!handleAssetsManifest_isFixEnabled(config))
+    if (!handleAssetsManifest_isFixEnabled())
         return;
     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) {
-    if (!handleAssetsManifest_isFixEnabled(config))
+function handleAssetsManifest_assertUsageCssTarget(config, env) {
+    if (!handleAssetsManifest_isFixEnabled())
         return;
-    const isServerSide = isViteServerBuild(config);
+    const isServerSide = isViteServerSide(config, env);
     assert(typeof isServerSide === 'boolean');
     assert(config.build.target !== undefined);
     targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
@@ -278,43 +279,41 @@ async function writeManifestFile(manifest, manifestFilePath) {
     const manifestFileContent = JSON.stringify(manifest, null, 2);
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
-async function handleAssetsManifest_getBuildConfig(config) {
-    const vikeConfig = await getVikeConfigInternal();
-    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+async function handleAssetsManifest_getBuildConfig() {
+    const isFixEnabled = handleAssetsManifest_isFixEnabled();
     return {
         // https://github.com/vikejs/vike/issues/1339
         ssrEmitAssets: isFixEnabled ? true : undefined,
         // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
         cssMinify: isFixEnabled ? 'esbuild' : undefined,
         manifest: true,
-        copyPublicDir: vikeConfig.config.vite6BuilderApp
-            ? // Already set by vike:build:pluginBuildApp
-                undefined
-            : !isViteServerBuild(config),
+        /* Already set by vike:build:pluginBuildApp
+        copyPublicDir: !isViteServerSide_viteEnvOptional(config),
+        */
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
-    const isSsrEnv = isViteServerBuild_onlySsrEnv(config, viteEnv);
+    const isSsrEnv = isViteServerSide_onlySsrEnv(config, viteEnv);
     if (isSsrEnv) {
-        assert(!assetsJsonFilePath);
+        assert(!globalObject.assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
-        assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-        await writeAssetsManifestFile(assetsJsonFilePath, config);
+        globalObject.assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+        await writeAssetsManifestFile(globalObject.assetsJsonFilePath, config);
     }
-    if (isViteServerBuild(config, viteEnv)) {
+    if (isViteServerSide(config, viteEnv)) {
         const outDir = options.dir;
         assert(outDir);
         // Replace __VITE_ASSETS_MANIFEST__ in server builds
         // - Always replace it in dist/server/
         // - 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);
+        const noop = await set_macro_ASSETS_MANIFEST(globalObject.assetsJsonFilePath, bundle, outDir);
         if (isSsrEnv)
             assert(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }
 }
 async function writeAssetsManifestFile(assetsJsonFilePath, config) {
-    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+    const isFixEnabled = handleAssetsManifest_isFixEnabled();
     const clientManifestFilePath = getManifestFilePath(config, true);
     const serverManifestFilePath = getManifestFilePath(config, false);
     if (!isFixEnabled) {
@@ -328,7 +327,7 @@ async function writeAssetsManifestFile(assetsJsonFilePath, config) {
     await fs.rm(serverManifestFilePath);
 }
 function getManifestFilePath(config, client) {
-    const outDirs = getOutDirs(config);
+    const outDirs = getOutDirs(config, undefined);
     const outDir = client ? outDirs.outDirClient : outDirs.outDirServer;
     const env = client ? config.environments.client : config.environments.ssr;
     assert(env);

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

@@ -1,10 +1,22 @@
 export { pluginBuildApp };
 import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
-import { assert } from '../../utils.js';
-import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
+import { assert, assertWarning, getGlobalObject, onSetupBuild } from '../../utils.js';
+import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
+import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
+import pc from '@brillout/picocolors';
+import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { isVikeCliOrApi } from '../../../api/context.js';
+import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
+import { isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
+import { runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
+const globalObject = getGlobalObject('build/pluginBuildApp.ts', {
+    forceExit: false,
+});
 function pluginBuildApp() {
+    let config;
     return [
         {
             name: 'vike:build:pluginBuildApp:pre',
@@ -12,10 +24,7 @@ function pluginBuildApp() {
             enforce: 'pre',
             config: {
                 order: 'pre',
-                async handler(_config) {
-                    const vikeConfig = await getVikeConfigInternal();
-                    if (!vikeConfig.config.vite6BuilderApp)
-                        return;
+                handler(_config) {
                     return {
                         builder: {
                             // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
@@ -37,10 +46,7 @@ function pluginBuildApp() {
         {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
-            async config(config) {
-                const vikeConfig = await getVikeConfigInternal();
-                if (!vikeConfig.config.vite6BuilderApp)
-                    return;
+            config(config) {
                 return {
                     environments: {
                         ssr: {
@@ -53,6 +59,7 @@ function pluginBuildApp() {
                         client: {
                             consumer: 'client',
                             build: {
+                                outDir: resolveOutDir(config, false),
                                 copyPublicDir: true,
                                 ssr: false,
                             },
@@ -61,5 +68,107 @@ function pluginBuildApp() {
                 };
             },
         },
+        {
+            name: 'vike:build:pluginBuildApp:autoFullBuild:pre',
+            apply: 'build',
+            enforce: 'pre',
+            async configResolved(config_) {
+                config = config_;
+                await abortViteBuildSsr();
+            },
+            // TO-DO/eventually: stop using this writeBundle() hack and, instead, use the buildApp() implementation above.
+            // - Could it cause issues if a tool uses the writeBundle() hack together with getVikeConfig() ?
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(options, bundle) {
+                    try {
+                        await handleAssetsManifest(config, this.environment, options, bundle);
+                        await triggerPrerendering(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginBuildApp], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        logErrorHint(err);
+                        process.exit(1);
+                    }
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginBuildApp:autoFullBuild:post',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    onSetupBuild();
+                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
+                    /* Let vike:build:pluginBuildApp force exit
+                    runPrerender_forceExit()
+                    */
+                },
+            },
+        },
     ];
 }
+async function triggerPrerendering(config, viteEnv, bundle) {
+    const vikeConfig = await getVikeConfigInternal();
+    if (!isViteServerSide_onlySsrEnv(config, viteEnv))
+        return;
+    if (isDisabled(vikeConfig))
+        return;
+    // Workaround for @vitejs/plugin-legacy
+    //  - 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[getManifestFilePathRelative(config.build.manifest)])
+        return;
+    if (!isPrerenderAutoRunEnabled(vikeConfig))
+        return;
+    const configInline = getFullBuildInlineConfig(config);
+    const res = await runPrerenderFromAutoRun(configInline);
+    globalObject.forceExit = res.forceExit;
+    assert(wasPrerenderRun());
+}
+async function abortViteBuildSsr() {
+    const vikeConfig = await getVikeConfigInternal();
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+        assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
+        process.exit(0);
+    }
+}
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isUserUsingViteApi;
+    }
+    else {
+        return disableAutoFullBuild;
+    }
+}
+function isPrerenderForceExit() {
+    return globalObject.forceExit;
+}
+function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build,
+            },
+        };
+    }
+}

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

@@ -1,18 +1,17 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile, } from '../../utils.js';
+import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveDistFile, } 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 { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 function pluginBuildConfig() {
     let config;
     return [
@@ -35,14 +34,10 @@ function pluginBuildConfig() {
             },
             config: {
                 order: 'post',
-                async handler(config) {
+                async handler() {
                     onSetupBuild();
-                    return {
-                        build: {
-                            outDir: resolveOutDir(config),
-                            ...(await handleAssetsManifest_getBuildConfig(config)),
-                        },
-                    };
+                    const build = await handleAssetsManifest_getBuildConfig();
+                    return { build };
                 },
             },
             buildStart() {
@@ -57,7 +52,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 (isViteServerSide_viteEnvOptional(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
@@ -76,8 +71,8 @@ async function getEntries(config) {
             ...clientEntries,
             ...pageFileEntries,
         };
-        const clientRoutingEntry = requireResolveVikeDistFile('dist/esm/client/runtime-client-routing/entry.js');
-        const serverRoutingEntry = requireResolveVikeDistFile('dist/esm/client/runtime-server-routing/entry.js');
+        const clientRoutingEntry = requireResolveDistFile('dist/esm/client/runtime-client-routing/entry.js');
+        const serverRoutingEntry = requireResolveDistFile('dist/esm/client/runtime-server-routing/entry.js');
         if (hasClientRouting) {
             entries['entries/entry-client-routing'] = clientRoutingEntry;
         }
@@ -130,7 +125,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 = !isViteServerSide_viteEnvOptional(config);
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');
@@ -174,7 +169,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/pluginDistPackageJsonFile.js

@@ -1,14 +1,6 @@
-/*
- * We create a file `dist/server/package.json` to support ESM users.
- * Otherwise, following error is thrown:
- *   Must use import to load ES Module: dist/server/pageFiles.js
- *   require() of ES modules is not supported.
- *   require() of dist/server/pageFiles.js from node_modules/vike/dist/esm/node/runtime/page-files/setup.js is an ES module file as it is a .js file whose nearest parent package.json contains "type": "module" which defines all .js files in that package scope as ES modules.
- * Reproduction: https://github.com/brillout/vite-plugin-ssr-server-import-syntax
- */
 export { pluginDistPackageJsonFile };
 import { rollupIsEsm } from '../../shared/rollupIsEsm.js';
-import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
+import { isViteServerSide } from '../../shared/isViteServerSide.js';
 function pluginDistPackageJsonFile() {
     let config;
     return {
@@ -18,7 +10,7 @@ function pluginDistPackageJsonFile() {
             config = config_;
         },
         generateBundle(options, bundle) {
-            if (!isViteServerBuild(config))
+            if (!isViteServerSide(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 { removeVirtualFileIdPrefix } from '../../utils.js';
-import { isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+import { isViteServerSide_extraSafe } from '../../shared/isViteServerSide.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,7 +16,7 @@ function pluginModuleBanner() {
         transform: {
             order: 'post',
             handler(code, id, options) {
-                if (!isViteServerBuild_safe(config, options) &&
+                if (!isViteServerSide_extraSafe(config, this.environment, options) &&
                     // Inject module banners if user sets `build.minify` to `false` for inspecting dist/client/
                     config.build.minify) {
                     return;
@@ -27,15 +27,12 @@ function pluginModuleBanner() {
                 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/pluginBuild/{pluginBuildEntry.d.ts → pluginProdBuildEntry.d.ts}

@@ -1,6 +1,6 @@
-export { pluginBuildEntry };
+export { pluginProdBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
-declare function pluginBuildEntry(): Plugin[];
+declare function pluginProdBuildEntry(): Plugin[];
 declare function set_macro_ASSETS_MANIFEST(assetsJsonFilePath: string | undefined, bundle: Bundle, outDir: string): Promise<boolean>;