vike 0.4.223 → 0.4.224-commit-f0d0f8a

package/dist/esm/node/plugin/plugins/{buildConfig/fixServerAssets.js → build/handleAssetsManifest.js}

@@ -1,56 +1,48 @@
-export { fixServerAssets };
-export { fixServerAssets_isEnabled };
-export { fixServerAssets_assertCssCodeSplit };
-export { fixServerAssets_assertCssTarget };
+export { handleAssetsManifest };
+export { handleAssetsManifest_getBuildConfig };
+export { handleAssetsManifest_isFixEnabled };
+export { handleAssetsManifest_assertUsageCssCodeSplit };
+export { handleAssetsManifest_assertUsageCssTarget };
 import fs from 'fs/promises';
 import fs_sync from 'fs';
 import path from 'path';
 import { existsSync } from 'fs';
-import { assert, assertWarning, isEqualStringList, pLimit, unique } from '../../utils.js';
+import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-import { manifestTempFile } from '../buildConfig.js';
+import { manifestTempFile } from './pluginBuildConfig.js';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
 import { isV1Design } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { viteIsSSR } from '../../shared/viteIsSSR.js';
-/**
- * true  => use workaround config.build.ssrEmitAssets
- * false => use workaround extractAssets plugin
- *
- * Only used by V1 design.
- */
-function fixServerAssets_isEnabled() {
-    // We currently apply the workaround iff V1 design.
-    // Shall we allow the user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
-    return true;
+import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
+import { getVikeConfigPublic } from '../commonConfig.js';
+import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
+assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
+let assetsJsonFilePath;
+// true  => use workaround config.build.ssrEmitAssets
+// false => use workaround extractAssets plugin
+function handleAssetsManifest_isFixEnabled(config) {
+    // Allow user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
+    return isV1Design(config);
 }
 /** https://github.com/vikejs/vike/issues/1339 */
 async function fixServerAssets(config) {
     const outDirs = getOutDirs(config);
-    const clientManifest = await loadManifest(outDirs.outDirClient);
-    const serverManifest = await loadManifest(outDirs.outDirServer);
-    const { clientManifestMod, serverManifestMod, filesToCopy, filesToRemove } = addServerAssets(clientManifest, serverManifest);
-    await copyAssets(filesToCopy, filesToRemove, config);
+    const clientManifest = await readManifestFile(outDirs.outDirClient);
+    const serverManifest = await readManifestFile(outDirs.outDirServer);
+    const { clientManifestMod, serverManifestMod, filesToMove, filesToRemove } = addServerAssets(clientManifest, serverManifest);
+    await copyAssets(filesToMove, filesToRemove, config);
     return { clientManifestMod, serverManifestMod };
 }
-async function loadManifest(outDir) {
-    const manifestFilePath = path.posix.join(outDir, manifestTempFile);
-    const manifestFileContent = await fs.readFile(manifestFilePath, 'utf-8');
-    assert(manifestFileContent);
-    const manifest = JSON.parse(manifestFileContent);
-    assert(manifest);
-    return manifest;
-}
-async function copyAssets(filesToCopy, filesToRemove, config) {
+async function copyAssets(filesToMove, filesToRemove, config) {
     const { outDirClient, outDirServer } = getOutDirs(config);
     const assetsDir = getAssetsDir(config);
     const assetsDirServer = path.posix.join(outDirServer, assetsDir);
-    if (!filesToCopy.length && !filesToRemove.length && !existsSync(assetsDirServer))
+    if (!filesToMove.length && !filesToRemove.length && !existsSync(assetsDirServer))
         return;
     assert(existsSync(assetsDirServer));
     const concurrencyLimit = pLimit(10);
-    await Promise.all(filesToCopy.map((file) => concurrencyLimit(async () => {
+    await Promise.all(filesToMove.map((file) => concurrencyLimit(async () => {
         const source = path.posix.join(outDirServer, file);
         const target = path.posix.join(outDirClient, file);
         await fs.mkdir(path.posix.dirname(target), { recursive: true });
@@ -86,19 +78,20 @@ function addServerAssets(clientManifest, serverManifest) {
         assert(!entriesServer.has(pageId));
         entriesServer.set(pageId, { key, ...resources });
     }
-    let filesToCopy = [];
+    let filesToMove = [];
     let filesToRemove = [];
+    // Copy page assets
     for (const [pageId, entryClient] of entriesClient.entries()) {
         const entryServer = entriesServer.get(pageId);
         if (!entryServer)
             continue;
-        const cssToAdd = [];
+        const cssToMove = [];
         const cssToRemove = [];
-        const assetsToAdd = [];
+        const assetsToMove = [];
         const assetsToRemove = [];
         entryServer.css.forEach((cssServer) => {
             if (!entryClient.css.some((cssClient) => cssServer.hash === cssClient.hash)) {
-                cssToAdd.push(cssServer.src);
+                cssToMove.push(cssServer.src);
             }
             else {
                 cssToRemove.push(cssServer.src);
@@ -106,17 +99,17 @@ function addServerAssets(clientManifest, serverManifest) {
         });
         entryServer.assets.forEach((assetServer) => {
             if (!entryClient.assets.some((assetClient) => assetServer.hash === assetClient.hash)) {
-                assetsToAdd.push(assetServer.src);
+                assetsToMove.push(assetServer.src);
             }
             else {
                 assetsToRemove.push(assetServer.src);
             }
         });
-        if (cssToAdd.length) {
+        if (cssToMove.length) {
             const { key } = entryClient;
-            filesToCopy.push(...cssToAdd);
+            filesToMove.push(...cssToMove);
             (_a = clientManifest[key]).css ?? (_a.css = []);
-            clientManifest[key].css?.push(...cssToAdd);
+            clientManifest[key].css?.push(...cssToMove);
         }
         if (cssToRemove.length) {
             const { key } = entryServer;
@@ -124,11 +117,11 @@ function addServerAssets(clientManifest, serverManifest) {
             (_b = serverManifest[key]).css ?? (_b.css = []);
             serverManifest[key].css = serverManifest[key].css.filter((entry) => !cssToRemove.includes(entry));
         }
-        if (assetsToAdd.length) {
+        if (assetsToMove.length) {
             const { key } = entryClient;
-            filesToCopy.push(...assetsToAdd);
+            filesToMove.push(...assetsToMove);
             (_c = clientManifest[key]).assets ?? (_c.assets = []);
-            clientManifest[key].assets?.push(...assetsToAdd);
+            clientManifest[key].assets?.push(...assetsToMove);
         }
         if (assetsToRemove.length) {
             const { key } = entryServer;
@@ -137,11 +130,40 @@ function addServerAssets(clientManifest, serverManifest) {
             serverManifest[key].assets = serverManifest[key].assets.filter((entry) => !assetsToRemove.includes(entry));
         }
     }
+    // Also copy assets of virtual:@brillout/vite-plugin-server-entry:serverEntry
+    {
+        const filesClientAll = [];
+        for (const key in clientManifest) {
+            const entry = clientManifest[key];
+            filesClientAll.push(entry.file);
+            filesClientAll.push(...(entry.assets ?? []));
+            filesClientAll.push(...(entry.css ?? []));
+        }
+        for (const key in serverManifest) {
+            const entry = serverManifest[key];
+            if (!entry.isEntry)
+                continue;
+            const resources = collectResources(entry, serverManifest);
+            const css = resources.css.map((css) => css.src).filter((file) => !filesClientAll.includes(file));
+            const assets = resources.assets.map((asset) => asset.src).filter((file) => !filesClientAll.includes(file));
+            filesToMove.push(...css, ...assets);
+            if (css.length > 0 || assets.length > 0) {
+                assert(!clientManifest[key]);
+                clientManifest[key] = {
+                    ...entry,
+                    css,
+                    assets,
+                    dynamicImports: undefined,
+                    imports: undefined
+                };
+            }
+        }
+    }
     const clientManifestMod = clientManifest;
     const serverManifestMod = serverManifest;
-    filesToCopy = unique(filesToCopy);
-    filesToRemove = unique(filesToRemove).filter((file) => !filesToCopy.includes(file));
-    return { clientManifestMod, serverManifestMod, filesToCopy, filesToRemove };
+    filesToMove = unique(filesToMove);
+    filesToRemove = unique(filesToRemove).filter((file) => !filesToMove.includes(file));
+    return { clientManifestMod, serverManifestMod, filesToMove, filesToRemove };
 }
 function getPageId(key) {
     // Normalize from:
@@ -184,22 +206,22 @@ function collectResources(entryRoot, manifest) {
 // </head>
 // ```
 function getHash(src) {
-    // src is guarenteed to end with `.[hash][extname]`, see distFileNames.ts
+    // src is guarenteed to end with `.[hash][extname]`, see pluginDistFileNames.ts
     const hash = src.split('.').at(-2);
     assert(hash);
     return hash;
 }
 // https://github.com/vikejs/vike/issues/1993
-function fixServerAssets_assertCssCodeSplit(config) {
+function handleAssetsManifest_assertUsageCssCodeSplit(config) {
+    if (!handleAssetsManifest_isFixEnabled(config))
+        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 = [];
-async function fixServerAssets_assertCssTarget(config) {
-    if (!fixServerAssets_isEnabled())
-        return;
-    if (!(await isV1Design(config)))
+function handleAssetsManifest_assertUsageCssTarget(config) {
+    if (!handleAssetsManifest_isFixEnabled(config))
         return;
-    const isServerSide = viteIsSSR(config);
+    const isServerSide = isViteServerBuild(config);
     assert(typeof isServerSide === 'boolean');
     assert(config.build.target !== undefined);
     targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
@@ -244,3 +266,59 @@ function removeEmptyDirectories(dirPath) {
         fs_sync.rmdirSync(dirPath);
     }
 }
+async function readManifestFile(outDir) {
+    const manifestFilePath = path.posix.join(outDir, manifestTempFile);
+    const manifestFileContent = await fs.readFile(manifestFilePath, 'utf-8');
+    assert(manifestFileContent);
+    const manifest = JSON.parse(manifestFileContent);
+    assert(manifest);
+    assert(isObject(manifest));
+    return manifest;
+}
+async function writeManifestFile(manifest, manifestFilePath) {
+    assert(isObject(manifest));
+    const manifestFileContent = JSON.stringify(manifest, null, 2);
+    await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
+}
+function handleAssetsManifest_getBuildConfig(config) {
+    const vike = getVikeConfigPublic(config);
+    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+    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: manifestTempFile,
+        copyPublicDir: vike.config.vite6BuilderApp
+            ? // Already set by vike:build:pluginBuildApp
+                undefined
+            : !isViteServerBuild(config)
+    };
+}
+async function handleAssetsManifest(config, viteEnv, options, bundle) {
+    if (isViteServerBuild_onlySsrEnv(config, viteEnv)) {
+        assert(!assetsJsonFilePath);
+        const outDirs = getOutDirs(config, viteEnv);
+        assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+        await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
+    }
+    if (isViteServerBuild(config, viteEnv)) {
+        assert(assetsJsonFilePath);
+        // Replace __VITE_ASSETS_MANIFEST__ in all server-side bundles
+        await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+    }
+}
+async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
+    const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
+    const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+    if (!isFixEnabled) {
+        await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+    }
+    else {
+        const { clientManifestMod } = await fixServerAssets(config);
+        await writeManifestFile(clientManifestMod, assetsJsonFilePath);
+    }
+    await fs.rm(clientManifestFilePath);
+    await fs.rm(serverManifestFilePath);
+}

package/dist/esm/node/plugin/plugins/build/pluginAutoFullBuild.d.ts

@@ -0,0 +1,5 @@
+export { pluginAutoFullBuild };
+export { isPrerenderForceExit };
+import type { Plugin } from 'vite';
+declare function pluginAutoFullBuild(): Plugin[];
+declare function isPrerenderForceExit(): boolean;

package/dist/esm/node/plugin/plugins/build/pluginAutoFullBuild.js

@@ -0,0 +1,140 @@
+export { pluginAutoFullBuild };
+export { isPrerenderForceExit };
+import { build } from 'vite';
+import { assert, assertIsSingleModuleInstance, assertWarning, onSetupBuild } from '../../utils.js';
+import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../../prerender/runPrerender.js';
+import { isPrerenderAutoRunEnabled } from '../../../prerender/context.js';
+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 { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
+import { isVikeCliOrApi } from '../../../api/context.js';
+import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
+import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/isViteServerBuild.js';
+assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
+let forceExit = false;
+function pluginAutoFullBuild() {
+    let config;
+    let vikeConfig;
+    return [
+        {
+            name: 'vike:build:pluginAutoFullBuild',
+            apply: 'build',
+            enforce: 'pre',
+            async configResolved(config_) {
+                vikeConfig = await getVikeConfig(config_);
+                config = config_;
+                abortViteBuildSsr(vikeConfig);
+            },
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TODO/eventually: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(options, bundle) {
+                    await handleAssetsManifest(config, this.environment, options, bundle);
+                    await triggerFullBuild(config, vikeConfig, this.environment, bundle);
+                }
+            }
+        },
+        {
+            name: 'vike:build:pluginAutoFullBuild:forceExit',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    onSetupBuild();
+                    handleAssetsManifest_assertUsageCssTarget(config);
+                    if (forceExit &&
+                        // Let vike:build:pluginBuildApp force exit
+                        !vikeConfig.global.config.vite6BuilderApp) {
+                        runPrerender_forceExit();
+                        assert(false);
+                    }
+                }
+            }
+        }
+    ];
+}
+async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
+    // Whether builder.buildApp() is being used, see plugin:build:pluginBuildApp
+    const isBuilderApp = vikeConfig.global.config.vite6BuilderApp;
+    // If builder.buildApp() => trigger at end of `this.environment.name === 'ssr'`.
+    // Else => trigger at end of client-side build.
+    if (isBuilderApp ? !isViteServerBuild_onlySsrEnv(config, viteEnv) : !isViteClientBuild(config, viteEnv))
+        return;
+    if (isEntirelyDisabled(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[manifestTempFile])
+        return;
+    const configInline = getFullBuildInlineConfig(config);
+    if (!isBuilderApp) {
+        try {
+            await build(setSSR(configInline));
+        }
+        catch (err) {
+            // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+            console.error(err);
+            logErrorHint(err);
+            process.exit(1);
+        }
+    }
+    else {
+        // The server bulid is already called by builder.buildApp()
+    }
+    if (isPrerenderAutoRunEnabled(vikeConfig)) {
+        const res = await runPrerenderFromAutoRun(configInline, config);
+        forceExit = res.forceExit;
+    }
+}
+function setSSR(configInline) {
+    return {
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    };
+}
+function abortViteBuildSsr(vikeConfig) {
+    if (vikeConfig.global.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 isEntirelyDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.global.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isUserUsingViteApi;
+    }
+    else {
+        return disableAutoFullBuild;
+    }
+}
+function isPrerenderForceExit() {
+    return forceExit;
+}
+function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    if (config._viteConfigEnhanced) {
+        return config._viteConfigEnhanced;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build
+            }
+        };
+    }
+}

package/dist/esm/node/plugin/plugins/build/pluginBuildApp.d.ts

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

package/dist/esm/node/plugin/plugins/build/pluginBuildApp.js

@@ -0,0 +1,50 @@
+export { pluginBuildApp };
+import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
+import { resolveOutDir } from '../../shared/getOutDirs.js';
+import { assert } from '../../utils.js';
+import { getVikeConfigPublic } from '../commonConfig.js';
+import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
+function pluginBuildApp() {
+    return [
+        {
+            name: 'vike:build:pluginBuildApp',
+            apply: 'build',
+            config(config) {
+                const vike = getVikeConfigPublic(config);
+                if (!vike.config.vite6BuilderApp)
+                    return;
+                return {
+                    builder: {
+                        // Can be overriden 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',
+                            build: {
+                                outDir: resolveOutDir(config, true),
+                                ssr: true
+                            }
+                        },
+                        client: {
+                            consumer: 'client',
+                            build: {
+                                copyPublicDir: true,
+                                ssr: false
+                            }
+                        }
+                    }
+                };
+            }
+        }
+    ];
+}

package/dist/esm/node/plugin/plugins/{buildConfig.d.ts → build/pluginBuildConfig.d.ts}

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

package/dist/esm/node/plugin/plugins/{buildConfig.js → build/pluginBuildConfig.js}

@@ -1,56 +1,41 @@
-export { buildConfig };
+export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsNpmPackageImport } from '../utils.js';
-import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
-import { findPageFiles } from '../shared/findPageFiles.js';
-import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
+import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsNpmPackageImport } from '../../utils.js';
+import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
+import { findPageFiles } from '../../shared/findPageFiles.js';
+import { getVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
-import fs from 'fs/promises';
-import path from 'path';
-import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { set_ASSETS_MANIFEST } from './buildEntry/index.js';
-import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
-import { getFilePathResolved } from '../shared/getFilePath.js';
-import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
-import { getOutDirs, resolveOutDir } from '../shared/getOutDirs.js';
-import { viteIsSSR } from '../shared/viteIsSSR.js';
-// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
+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 { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig } from './handleAssetsManifest.js';
+// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
-function buildConfig() {
-    let isServerAssetsFixEnabled;
-    let outDirs;
+function pluginBuildConfig() {
     let config;
     return [
         {
-            name: 'vike:buildConfig:post',
+            name: 'vike:build:pluginBuildConfig',
             apply: 'build',
             enforce: 'post',
             configResolved: {
                 order: 'post',
                 async handler(config_) {
-                    config = config_;
                     onSetupBuild();
+                    config = config_;
                     assertRollupInput(config);
                     const entries = await getEntries(config);
                     assert(Object.keys(entries).length > 0);
                     config.build.rollupOptions.input = injectRollupInputs(entries, config);
                     addLogHook();
-                    outDirs = getOutDirs(config);
-                    {
-                        isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config));
-                        if (isServerAssetsFixEnabled) {
-                            // https://github.com/vikejs/vike/issues/1339
-                            config.build.ssrEmitAssets = true;
-                            // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
-                            config.build.cssMinify = 'esbuild';
-                            fixServerAssets_assertCssCodeSplit(config);
-                        }
-                    }
+                    handleAssetsManifest_assertUsageCssCodeSplit(config);
                 }
             },
             config: {
@@ -60,56 +45,13 @@ function buildConfig() {
                     return {
                         build: {
                             outDir: resolveOutDir(config),
-                            manifest: manifestTempFile,
-                            copyPublicDir: config.vike.config.viteEnvironmentAPI
-                                ? // Already set by buildApp() plugin
-                                    undefined
-                                : !viteIsSSR(config)
+                            ...handleAssetsManifest_getBuildConfig(config)
                         }
                     };
                 }
             },
             buildStart() {
                 onSetupBuild();
-            },
-            async closeBundle() {
-                onSetupBuild();
-                await fixServerAssets_assertCssTarget(config);
-            }
-        },
-        {
-            name: 'vike:buildConfig:pre',
-            apply: 'build',
-            applyToEnvironment(env) {
-                return env.name === 'ssr';
-            },
-            // Make sure other writeBundle() hooks are called after this writeBundle() hook.
-            //  - set_ASSETS_MANIFEST() needs to be called before dist/server/ code is executed.
-            //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
-            enforce: 'pre',
-            writeBundle: {
-                order: 'pre',
-                sequential: true,
-                async handler(options, bundle) {
-                    if (viteIsSSR(config)) {
-                        // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
-                        //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
-                        //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                        const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-                        const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
-                        const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
-                        if (!isServerAssetsFixEnabled) {
-                            await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
-                        }
-                        else {
-                            const { clientManifestMod } = await fixServerAssets(config);
-                            await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
-                        }
-                        await fs.rm(clientManifestFilePath);
-                        await fs.rm(serverManifestFilePath);
-                        await set_ASSETS_MANIFEST(options, bundle);
-                    }
-                }
             }
         }
     ];
@@ -122,10 +64,9 @@ async function getEntries(config) {
     // TODO/now: add meta.default
     vikeConfig.global.config.includeAssetsImportedByServer ?? true);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
-    if (viteIsSSR(config)) {
+    if (isViteServerBuild(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            // buildEntry: resolve('dist/esm/node/buildEntry.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
             // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             ...pageEntries
@@ -196,7 +137,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 = !viteIsSSR(config);
+    const isForClientSide = !isViteServerBuild(config);
     const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
     if (isForClientSide && includeAssetsImportedByServer) {
         fileTypes.push('.page.server');
@@ -255,8 +196,8 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
 }
 function resolve(filePath) {
     assert(filePath.startsWith('dist/'));
-    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
-    return require_.resolve(`../../../../../${filePath}`);
+    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/build/
+    return require_.resolve(`../../../../../../${filePath}`);
 }
 function addLogHook() {
     const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27