vike 0.4.223 → 0.4.224

package/dist/cjs/utils/requireResolve.js

@@ -7,7 +7,7 @@ const assertSetup_js_1 = require("./assertSetup.js");
 const path_js_1 = require("./path.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
 const module_1 = require("module");
-// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore `file://${__filename}` is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
@@ -34,6 +34,13 @@ function requireResolve(importPath, cwd) {
     return importedFile;
 }
 function removeFileExtention(importPath) {
+    // Skip for Bun: https://github.com/vikejs/vike/issues/2204
+    //@ts-ignore
+    if (typeof Bun !== 'undefined') {
+        // https://bun.sh/guides/util/detect-bun
+        (0, assert_js_1.assert)(process.versions.bun);
+        return importPath;
+    }
     for (const ext of isScriptFile_js_1.scriptFileExtensionList) {
         const suffix = `.${ext}`;
         if (importPath.endsWith(suffix)) {
@@ -47,14 +54,14 @@ function addFileExtensionsToRequireResolve() {
     isScriptFile_js_1.scriptFileExtensionList.forEach((ext) => {
         (0, assert_js_1.assert)(!ext.includes('.'));
         ext = `.${ext}`;
-        if (!require.extensions[ext]) {
-            require.extensions[ext] = require.extensions['.js'];
+        if (!require_.extensions[ext]) {
+            require_.extensions[ext] = require_.extensions['.js'];
             added.push(ext);
         }
     });
     const clean = () => {
         added.forEach((ext) => {
-            delete require.extensions[ext];
+            delete require_.extensions[ext];
         });
     };
     return clean;

package/dist/cjs/utils/sorter.js

@@ -6,9 +6,6 @@ exports.makeFirst = makeFirst;
 exports.makeLast = makeLast;
 exports.reverse = reverse;
 const assert_js_1 = require("./assert.js");
-// -1 => element1 first (i.e. `indexOf(element1) < indexOf(element2)`)
-// +1 => element2 first (i.e. `indexOf(element2) < indexOf(element1)`)
-// 0 => keep original order of element1 and element2
 /**
  * ```js
  * let arr = [

package/dist/esm/client/client-routing-runtime/index.d.ts

@@ -1,5 +1,6 @@
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { getPageContextClient } from './renderPageClientSide.js';
 export { PROJECT_VERSION as version } from './utils.js';
 import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
 /** @deprecated

package/dist/esm/client/client-routing-runtime/index.js

@@ -5,4 +5,5 @@
 // Use package.json#exports to make the imports isomorphic.
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { getPageContextClient } from './renderPageClientSide.js';
 export { PROJECT_VERSION as version } from './utils.js';

package/dist/esm/client/client-routing-runtime/renderPageClientSide.d.ts

@@ -2,8 +2,10 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
+export { getPageContextClient };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
+import type { PageContextClient } from '../../shared/types.js';
 declare const firstRenderStartPromise: Promise<void>;
 type RenderArgs = {
     scrollTarget: ScrollTarget;
@@ -24,3 +26,9 @@ declare global {
 }
 declare function disableClientRouting(err: unknown, log: boolean): void;
 declare function getRenderCount(): number;
+/**
+ * Get the `pageContext` object on the client-side.
+ *
+ * https://vike.dev/getPageContextClient
+ */
+declare function getPageContextClient(): PageContextClient | null;

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -2,6 +2,7 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
+export { getPageContextClient };
 import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
@@ -23,7 +24,6 @@ import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 const globalObject = getGlobalObject('client-routing-runtime/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
-        previousPageContext: null,
         renderCounter: 0,
         firstRenderStartPromise,
         firstRenderStartPromiseResolve
@@ -484,6 +484,7 @@ async function renderPageClientSide(renderArgs) {
         // Add link prefetch handlers
         addLinkPrefetchHandlers_watch();
         addLinkPrefetchHandlers();
+        globalObject.renderedPageContext = pageContext;
         stampFinished(urlOriginal);
     }
 }
@@ -595,3 +596,11 @@ function areKeysEqual(key1, key2) {
         return false;
     return key1.length === key2.length && key1.every((_, i) => key1[i] === key2[i]);
 }
+/**
+ * Get the `pageContext` object on the client-side.
+ *
+ * https://vike.dev/getPageContextClient
+ */
+function getPageContextClient() {
+    return globalObject.renderedPageContext ?? null;
+}

package/dist/esm/node/api/build.js

@@ -1,6 +1,6 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { build as buildVite, version } from 'vite';
+import { build as buildVite, version, createBuilder } from 'vite';
 import assert from 'assert';
 import { isVikeCli } from '../cli/context.js';
 import { isPrerendering } from '../prerender/context.js';
@@ -12,13 +12,13 @@ import { assertVersion } from './utils.js';
  */
 async function build(options = {}) {
     const { viteConfigEnhanced, vikeConfig } = await prepareViteApiCall(options.viteConfig, 'build');
-    // Pass it to autoFullBuild()
+    // Pass it to pluginAutoFullBuild()
     if (viteConfigEnhanced)
         viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
-    if (vikeConfig.global.config.viteEnvironmentAPI) {
+    if (vikeConfig.global.config.vite6BuilderApp) {
         assertVersion('Vite', version, '6.0.0');
-        const { createBuilder } = await import('vite');
         const builder = await createBuilder(viteConfigEnhanced);
+        // See Vite plugin vike:build:pluginBuildApp
         await builder.buildApp();
     }
     else {

package/dist/esm/node/api/prepareViteApiCall.js

@@ -2,7 +2,6 @@ export { prepareViteApiCall };
 export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
-// TODO: enable Vike extensions to add Vite plugins
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextApiOperation, setContextApiOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
@@ -50,7 +49,10 @@ async function getViteRoot(operation) {
 }
 async function getInfoFromVite(viteConfigFromOptions, operation) {
     const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
-    const root = normalizeViteRoot(viteConfigFromUserViteFile?.root ?? viteConfigFromOptions?.root ?? process.cwd());
+    const root = normalizeViteRoot(
+    // `viteConfigFromOptions.root` before `viteConfigFromUserViteFile.root` replicates Vite's precedence:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
+    viteConfigFromOptions?.root ?? viteConfigFromUserViteFile?.root ?? process.cwd());
     globalObject.root = root;
     let vikeVitePluginOptions;
     let viteConfigEnhanced = viteConfigFromOptions;
@@ -116,7 +118,11 @@ function getResolveConfigArgs(viteConfig = {}, operation) {
     return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
 }
 function normalizeViteRoot(root) {
-    return toPosixPath(path.resolve(root));
+    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
+    return toPosixPath(
+    // Equivalent to `path.resolve(process.cwd(), root)`
+    path.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
 async function assertViteRoot2(root, viteConfigEnhanced, operation) {

package/dist/esm/node/plugin/index.d.ts

@@ -1,9 +1,10 @@
 export default plugin;
 export { plugin };
 export { plugin as ssr };
+export { getVikeConfigPublic as getVikeConfig } from './plugins/commonConfig.js';
+export { PROJECT_VERSION as version } from './utils.js';
 export type { VikeVitePluginOptions as UserConfig };
 export type { VikeVitePluginOptions };
-export { PROJECT_VERSION as version } from './utils.js';
 type PluginInterop = Record<string, unknown> & {
     name: string;
 };

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

@@ -2,21 +2,16 @@ export default plugin;
 export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
+export { getVikeConfigPublic as getVikeConfig } from './plugins/commonConfig.js';
 export { PROJECT_VERSION as version } from './utils.js';
 import { assertUsage } from './utils.js';
-import { buildConfig } from './plugins/buildConfig.js';
+import { build } from './plugins/build.js';
 import { previewConfig } from './plugins/previewConfig.js';
-import { autoFullBuild } from './plugins/autoFullBuild.js';
 import { devConfig } from './plugins/devConfig/index.js';
-import { packageJsonFile } from './plugins/packageJsonFile.js';
-import { removeRequireHookPlugin } from './plugins/removeRequireHookPlugin.js';
 import { importUserCode } from './plugins/importUserCode/index.js';
-import { distFileNames } from './plugins/distFileNames.js';
 import { extractAssetsPlugin } from './plugins/extractAssetsPlugin.js';
 import { extractExportNamesPlugin } from './plugins/extractExportNamesPlugin.js';
-import { suppressRollupWarning } from './plugins/suppressRollupWarning.js';
 import { setGlobalContext } from './plugins/setGlobalContext.js';
-import { buildEntry } from './plugins/buildEntry/index.js';
 import { commonConfig } from './plugins/commonConfig.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
@@ -26,7 +21,6 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
-import { buildApp } from './plugins/buildApp.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
@@ -35,18 +29,11 @@ function plugin(vikeVitePluginOptions = {}) {
         ...commonConfig(vikeVitePluginOptions),
         importUserCode(),
         ...devConfig(),
-        ...buildConfig(),
-        ...buildApp(),
+        ...build(),
         previewConfig(),
-        ...autoFullBuild(),
-        packageJsonFile(),
-        removeRequireHookPlugin(),
-        distFileNames(),
         ...extractAssetsPlugin(),
         extractExportNamesPlugin(),
-        suppressRollupWarning(),
         ...setGlobalContext(),
-        ...buildEntry(),
         baseUrls(),
         envVarsPlugin(),
         fileEnv(),
@@ -63,7 +50,7 @@ Object.defineProperty(plugin, 'apply', {
         assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
-// Ensures following works: `const vike = require('vike/plugin')` / `import vike from 'vike/plugin'`
+// CJS default export `const vike = require('vike/plugin')`
 //  - It needs to live at the end of this file, in order to ensure we do it after all assignments to `exports`.
 try {
     module.exports = Object.assign(exports.default, exports);

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -2,6 +2,7 @@ export { baseUrls };
 import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfigPublic } from './commonConfig.js';
 function baseUrls() {
     let basesResolved;
     return {
@@ -11,7 +12,8 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = resolveBase(baseViteOriginal, config.vike.config.baseServer ?? null, config.vike.config.baseAssets ?? null);
+            const vike = getVikeConfigPublic(config);
+            basesResolved = resolveBase(baseViteOriginal, vike.config.baseServer ?? null, vike.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;

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

@@ -0,0 +1,18 @@
+export { handleAssetsManifest };
+export { handleAssetsManifest_getBuildConfig };
+export { handleAssetsManifest_isFixEnabled };
+export { handleAssetsManifest_assertUsageCssCodeSplit };
+export { handleAssetsManifest_assertUsageCssTarget };
+import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
+type Bundle = Rollup.OutputBundle;
+type Options = Rollup.NormalizedOutputOptions;
+declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
+declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
+declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig): void;
+declare function handleAssetsManifest_getBuildConfig(config: UserConfig): {
+    readonly ssrEmitAssets: true | undefined;
+    readonly cssMinify: "esbuild" | undefined;
+    readonly manifest: "_temp_manifest.json";
+    readonly copyPublicDir: boolean | undefined;
+};
+declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: Options, bundle: Bundle): Promise<void>;

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;