vike 0.4.226 → 0.4.227

package/dist/cjs/node/cli/entry.js

@@ -62,14 +62,19 @@ async function cmdDev() {
     const startTime = performance.now();
     try {
         const { viteServer } = await (0, index_js_1.dev)();
-        await viteServer.listen();
-        const info = viteServer.config.logger.info;
-        const startupDurationString = picocolors_1.default.dim(`ready in ${picocolors_1.default.reset(picocolors_1.default.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
-        const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
-        info(`  ${picocolors_1.default.yellow(`${picocolors_1.default.bold('Vike')} v${utils_js_1.PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-            clear: !hasExistingLogs
-        });
-        viteServer.printUrls();
+        if (viteServer.httpServer) {
+            await viteServer.listen();
+            const info = viteServer.config.logger.info;
+            const startupDurationString = picocolors_1.default.dim(`ready in ${picocolors_1.default.reset(picocolors_1.default.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
+            const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
+            info(`  ${picocolors_1.default.yellow(`${picocolors_1.default.bold('Vike')} v${utils_js_1.PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
+                clear: !hasExistingLogs
+            });
+            viteServer.printUrls();
+        }
+        else {
+            // vike-server => middleware mode => `viteServer.httpServer === null`
+        }
         viteServer.bindCLIShortcuts({ print: true });
     }
     catch (err) {

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

@@ -95,7 +95,7 @@ async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
         // The server bulid is already called by builder.buildApp()
     }
     if ((0, context_js_1.isPrerenderAutoRunEnabled)(vikeConfig)) {
-        const res = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline, config);
+        const res = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline);
         forceExit = res.forceExit;
     }
 }

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -19,6 +19,8 @@ const context_js_2 = require("../../prerender/context.js");
 const resolvePrerenderConfig_js_1 = require("../../prerender/resolvePrerenderConfig.js");
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
+    // We cache it => makes sure we only generate one object => we can mutate it at runPrerender()
+    let prerenderContext;
     return [
         {
             name: `${pluginName}:pre`,
@@ -31,6 +33,15 @@ function commonConfig(vikeVitePluginOptions) {
                     const root = configFromUser.root ? (0, prepareViteApiCall_js_1.normalizeViteRoot)(configFromUser.root) : await (0, prepareViteApiCall_js_1.getViteRoot)(operation);
                     (0, utils_js_1.assert)(root);
                     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(root, isDev, vikeVitePluginOptions);
+                    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
+                    prerenderContext ?? (prerenderContext = {
+                        isPrerenderingEnabled,
+                        isPrerenderingEnabledForAllPages,
+                        output: null,
+                        pageContexts: null
+                    });
+                    (0, utils_js_1.assert)(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
+                    (0, utils_js_1.assert)(prerenderContext.isPrerenderingEnabledForAllPages === isPrerenderingEnabledForAllPages);
                     return {
                         _isDev: isDev,
                         _root: root,
@@ -38,11 +49,12 @@ function commonConfig(vikeVitePluginOptions) {
                         _vikeConfigObject: vikeConfig,
                         _vike: {
                             pages: vikeConfig.pages,
-                            config: vikeConfig.global.config
+                            config: vikeConfig.global.config,
+                            prerenderContext
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig).isPrerenderingEnabled
+                            prerender: isPrerenderingEnabled
                         })
                     };
                 }

package/dist/cjs/node/plugin/plugins/fileEnv.js

@@ -12,6 +12,7 @@ const getFilePath_js_1 = require("../shared/getFilePath.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
 const parseEsModule_js_1 = require("../shared/parseEsModule.js");
 const normalizeId_js_1 = require("../shared/normalizeId.js");
+const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -21,6 +22,8 @@ function fileEnv() {
             // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
             if (!viteDevServer)
                 return;
+            if (!(0, getVikeConfig_js_1.isV1Design)(config))
+                return;
             if (skip(id))
                 return;
             // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475

package/dist/cjs/node/plugin/plugins/previewConfig.js

@@ -38,20 +38,24 @@ function previewConfig() {
             config.appType = 'mpa'
             */
             return () => {
-                assertDist();
+                const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(config._vikeConfigObject);
+                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = prerenderConfigGlobal;
+                assertDist(isPrerenderingEnabledForAllPages);
                 // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
                 addStaticAssetsMiddleware(server.middlewares);
-                const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(config._vikeConfigObject);
-                if (!prerenderConfigGlobal.isPrerenderingEnabledForAllPages) {
-                    (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares, config, true, prerenderConfigGlobal.isPrerenderingEnabled);
+                if (!isPrerenderingEnabledForAllPages) {
+                    (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares, config, true, isPrerenderingEnabled);
                 }
                 addStatic404Middleware(server.middlewares);
             };
         }
     };
-    function assertDist() {
+    function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(config);
-        [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
+        const dirS = [outDirRoot, outDirClient];
+        if (!isPrerenderingEnabledForAllPages)
+            dirS.push(outDirServer);
+        dirS.forEach((outDirAny) => {
             (0, utils_js_1.assertUsage)(fs_1.default.existsSync(outDirAny), `Cannot run ${picocolors_1.default.cyan('$ vike preview')}: your app isn't built (the build directory ${picocolors_1.default.cyan(outDirAny)} is missing). Make sure to run ${picocolors_1.default.cyan('$ vike build')} before running ${picocolors_1.default.cyan('$ vike preview')}.`);
         });
     }

package/dist/cjs/node/prerender/resolvePrerenderConfig.js

@@ -12,6 +12,7 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderConfigGlobal = {
         partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
         noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        keepDistServer: pickFirst(prerenderSettings.map((c) => c.keepDistServer)) ?? false,
         parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
         disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
     };

package/dist/cjs/node/prerender/runPrerender.js

@@ -69,6 +69,7 @@ const getOutDirs_js_1 = require("../plugin/shared/getOutDirs.js");
 const context_js_2 = require("../cli/context.js");
 const isViteCliCall_js_1 = require("../plugin/shared/isViteCliCall.js");
 const commonConfig_js_1 = require("../plugin/plugins/commonConfig.js");
+const node_fs_1 = __importDefault(require("node:fs"));
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -88,11 +89,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
     (0, utils_js_1.assert)(false);
 }
-async function runPrerenderFromAutoRun(viteConfig, config) {
-    let prerenderContextPublic;
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
-        const ret = await runPrerender({ viteConfig });
-        prerenderContextPublic = ret.prerenderContextPublic;
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -100,8 +99,6 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
-    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(config);
-    vike.prerenderContext = prerenderContextPublic;
     const forceExit = (0, context_js_2.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
     return { forceExit };
 }
@@ -118,7 +115,9 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
-    const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
+    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(viteConfig);
+    (0, utils_js_1.assert)(vike.prerenderContext.isPrerenderingEnabled);
+    const { outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
     validatePrerenderConfig(prerenderConfigGlobal);
@@ -161,7 +160,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
-    return { viteConfig, prerenderContextPublic };
+    (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic);
+    if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
+        node_fs_1.default.rmSync(outDirServer, { recursive: true });
+    }
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
@@ -630,6 +633,12 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    (0, utils_js_1.objectAssign)(pageContext, {
+        _prerenderResult: {
+            filePath,
+            fileContent
+        }
+    });
     output.push({
         filePath,
         fileType,
@@ -637,15 +646,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
         pageContext
     });
     if (onPagePrerender) {
-        const prerenderPageContext = {};
-        (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
-        (0, utils_js_1.objectAssign)(prerenderPageContext, {
-            _prerenderResult: {
-                filePath,
-                fileContent
-            }
-        });
-        await onPagePrerender(prerenderPageContext);
+        await onPagePrerender(pageContext);
     }
     else {
         const { promises } = await Promise.resolve().then(() => __importStar(require('fs')));

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.226';
+exports.PROJECT_VERSION = '0.4.227';

package/dist/cjs/utils/assertSingleInstance.js

@@ -16,13 +16,24 @@ const PROJECT_VERSION_js_1 = require("./PROJECT_VERSION.js");
 /* Use original assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertWarning } from './assert.js'
 */
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertSingleInstance.ts', {
-    instances: [],
-    alreadyLogged: new Set()
-});
+let globalObject;
+// getGlobalObjectSafe() can be called before this line
+globalObject ?? (globalObject = genGlobalConfig());
+function genGlobalConfig() {
+    return (0, getGlobalObject_js_1.getGlobalObject)('utils/assertSingleInstance.ts', {
+        instances: [],
+        alreadyLogged: new Set()
+    });
+}
+// We need getGlobalObjectSafe() because globalObject is `undefined` when exported functions are called before globalObject is initialized
+function getGlobalObjectSafe() {
+    globalObject ?? (globalObject = genGlobalConfig());
+    return globalObject;
+}
 const clientRuntimesClonflict = 'Client runtime of both Server Routing and Client Routing loaded https://vike.dev/client-runtimes-conflict';
 const clientNotSingleInstance = 'Client runtime loaded twice https://vike.dev/client-runtime-duplicated';
 function assertSingleInstance() {
+    const globalObject = getGlobalObjectSafe();
     {
         const versions = (0, unique_js_1.unique)(globalObject.instances);
         assertWarning(versions.length <= 1, 
@@ -39,6 +50,7 @@ function assertSingleInstance() {
     }
 }
 function assertSingleInstance_onClientEntryServerRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== true, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -53,6 +65,7 @@ function assertSingleInstance_onClientEntryServerRouting(isProduction) {
     assertSingleInstance();
 }
 function assertSingleInstance_onClientEntryClientRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== false, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -68,10 +81,12 @@ function assertSingleInstance_onClientEntryClientRouting(isProduction) {
 }
 // Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
 function assertSingleInstance_onAssertModuleLoad() {
+    const globalObject = getGlobalObjectSafe();
     globalObject.instances.push(PROJECT_VERSION_js_1.PROJECT_VERSION);
     assertSingleInstance();
 }
 function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    const globalObject = getGlobalObjectSafe();
     if (condition) {
         return;
     }

package/dist/esm/node/cli/entry.js

@@ -24,14 +24,19 @@ async function cmdDev() {
     const startTime = performance.now();
     try {
         const { viteServer } = await dev();
-        await viteServer.listen();
-        const info = viteServer.config.logger.info;
-        const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
-        const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
-        info(`  ${pc.yellow(`${pc.bold('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-            clear: !hasExistingLogs
-        });
-        viteServer.printUrls();
+        if (viteServer.httpServer) {
+            await viteServer.listen();
+            const info = viteServer.config.logger.info;
+            const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
+            const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
+            info(`  ${pc.yellow(`${pc.bold('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
+                clear: !hasExistingLogs
+            });
+            viteServer.printUrls();
+        }
+        else {
+            // vike-server => middleware mode => `viteServer.httpServer === null`
+        }
         viteServer.bindCLIShortcuts({ print: true });
     }
     catch (err) {

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

@@ -90,7 +90,7 @@ async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
         // The server bulid is already called by builder.buildApp()
     }
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
-        const res = await runPrerenderFromAutoRun(configInline, config);
+        const res = await runPrerenderFromAutoRun(configInline);
         forceExit = res.forceExit;
     }
 }

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -20,8 +20,14 @@ declare module 'vite' {
 type VikeConfigPublic = {
     config: VikeConfigObject['global']['config'];
     pages: VikeConfigObject['pages'];
-    prerenderContext?: PrerenderContextPublic;
+    prerenderContext: PrerenderContext;
 };
+type PrerenderContext = {
+    isPrerenderingEnabled: boolean;
+    isPrerenderingEnabledForAllPages: boolean;
+} & ({
+    [K in keyof PrerenderContextPublic]: null;
+} | PrerenderContextPublic);
 declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];
 /**
  * Get all the information Vike knows about the app in your Vite plugin.

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

@@ -14,6 +14,8 @@ import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
+    // We cache it => makes sure we only generate one object => we can mutate it at runPrerender()
+    let prerenderContext;
     return [
         {
             name: `${pluginName}:pre`,
@@ -26,6 +28,15 @@ function commonConfig(vikeVitePluginOptions) {
                     const root = configFromUser.root ? normalizeViteRoot(configFromUser.root) : await getViteRoot(operation);
                     assert(root);
                     const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
+                    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
+                    prerenderContext ?? (prerenderContext = {
+                        isPrerenderingEnabled,
+                        isPrerenderingEnabledForAllPages,
+                        output: null,
+                        pageContexts: null
+                    });
+                    assert(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
+                    assert(prerenderContext.isPrerenderingEnabledForAllPages === isPrerenderingEnabledForAllPages);
                     return {
                         _isDev: isDev,
                         _root: root,
@@ -33,11 +44,12 @@ function commonConfig(vikeVitePluginOptions) {
                         _vikeConfigObject: vikeConfig,
                         _vike: {
                             pages: vikeConfig.pages,
-                            config: vikeConfig.global.config
+                            config: vikeConfig.global.config,
+                            prerenderContext
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: resolvePrerenderConfigGlobal(vikeConfig).isPrerenderingEnabled
+                            prerender: isPrerenderingEnabled
                         })
                     };
                 }

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

@@ -7,6 +7,7 @@ import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
+import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -16,6 +17,8 @@ function fileEnv() {
             // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
             if (!viteDevServer)
                 return;
+            if (!isV1Design(config))
+                return;
             if (skip(id))
                 return;
             // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475

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

@@ -33,20 +33,24 @@ function previewConfig() {
             config.appType = 'mpa'
             */
             return () => {
-                assertDist();
+                const prerenderConfigGlobal = resolvePrerenderConfigGlobal(config._vikeConfigObject);
+                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = prerenderConfigGlobal;
+                assertDist(isPrerenderingEnabledForAllPages);
                 // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
                 addStaticAssetsMiddleware(server.middlewares);
-                const prerenderConfigGlobal = resolvePrerenderConfigGlobal(config._vikeConfigObject);
-                if (!prerenderConfigGlobal.isPrerenderingEnabledForAllPages) {
-                    addSsrMiddleware(server.middlewares, config, true, prerenderConfigGlobal.isPrerenderingEnabled);
+                if (!isPrerenderingEnabledForAllPages) {
+                    addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
                 }
                 addStatic404Middleware(server.middlewares);
             };
         }
     };
-    function assertDist() {
+    function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
-        [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
+        const dirS = [outDirRoot, outDirClient];
+        if (!isPrerenderingEnabledForAllPages)
+            dirS.push(outDirServer);
+        dirS.forEach((outDirAny) => {
             assertUsage(fs.existsSync(outDirAny), `Cannot run ${pc.cyan('$ vike preview')}: your app isn't built (the build directory ${pc.cyan(outDirAny)} is missing). Make sure to run ${pc.cyan('$ vike build')} before running ${pc.cyan('$ vike preview')}.`);
         });
     }

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -5,6 +5,7 @@ import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.j
 declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
     partial: boolean;
     noExtraDir: boolean;
+    keepDistServer: boolean;
     parallel: number | boolean;
     disableAutoRun: boolean;
 } & {

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -10,6 +10,7 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderConfigGlobal = {
         partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
         noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        keepDistServer: pickFirst(prerenderSettings.map((c) => c.keepDistServer)) ?? false,
         parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
         disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
     };

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -46,7 +46,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, config: ResolvedConfig): Promise<{
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
     forceExit: boolean;
 }>;
 declare function runPrerender_forceExit(): void;

package/dist/esm/node/prerender/runPrerender.js

@@ -31,6 +31,7 @@ import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
 import { getVikeConfigPublic } from '../plugin/plugins/commonConfig.js';
+import fs from 'node:fs';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -50,11 +51,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
     assert(false);
 }
-async function runPrerenderFromAutoRun(viteConfig, config) {
-    let prerenderContextPublic;
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
-        const ret = await runPrerender({ viteConfig });
-        prerenderContextPublic = ret.prerenderContextPublic;
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -62,8 +61,6 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         logErrorHint(err);
         process.exit(1);
     }
-    const vike = getVikeConfigPublic(config);
-    vike.prerenderContext = prerenderContextPublic;
     const forceExit = isVikeCli() || isViteCliCall();
     return { forceExit };
 }
@@ -80,7 +77,9 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
-    const { outDirClient } = getOutDirs(viteConfig);
+    const vike = getVikeConfigPublic(viteConfig);
+    assert(vike.prerenderContext.isPrerenderingEnabled);
+    const { outDirClient, outDirServer } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
     validatePrerenderConfig(prerenderConfigGlobal);
@@ -123,7 +122,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
-    return { viteConfig, prerenderContextPublic };
+    objectAssign(vike.prerenderContext, prerenderContextPublic);
+    if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
+        fs.rmSync(outDirServer, { recursive: true });
+    }
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
@@ -592,6 +595,12 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);
+    objectAssign(pageContext, {
+        _prerenderResult: {
+            filePath,
+            fileContent
+        }
+    });
     output.push({
         filePath,
         fileType,
@@ -599,15 +608,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
         pageContext
     });
     if (onPagePrerender) {
-        const prerenderPageContext = {};
-        objectAssign(prerenderPageContext, pageContext);
-        objectAssign(prerenderPageContext, {
-            _prerenderResult: {
-                filePath,
-                fileContent
-            }
-        });
-        await onPagePrerender(prerenderPageContext);
+        await onPagePrerender(pageContext);
     }
     else {
         const { promises } = await import('fs');

package/dist/esm/shared/page-configs/Config.d.ts

@@ -308,6 +308,16 @@ type ConfigBuiltIn = {
          * @default true
          */
         enable?: boolean | null;
+        /**
+         * If you pre-render all your pages then Vike removes the `dist/server/` directory after pre-rendering has finished.
+         *
+         * If you set this setting to `true` then Vike won't remove the `dist/server/` directory.
+         *
+         * https://vike.dev/prerender#keepDistServer
+         *
+         * @default false
+         */
+        keepDistServer?: boolean;
     };
     /**
      * Install Vike extensions.

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.226";
+export declare const PROJECT_VERSION: "0.4.227";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.226';
+export const PROJECT_VERSION = '0.4.227';

package/dist/esm/utils/assertSingleInstance.js

@@ -11,13 +11,24 @@ import { PROJECT_VERSION } from './PROJECT_VERSION.js';
 /* Use original assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertWarning } from './assert.js'
 */
-const globalObject = getGlobalObject('utils/assertSingleInstance.ts', {
-    instances: [],
-    alreadyLogged: new Set()
-});
+let globalObject;
+// getGlobalObjectSafe() can be called before this line
+globalObject ?? (globalObject = genGlobalConfig());
+function genGlobalConfig() {
+    return getGlobalObject('utils/assertSingleInstance.ts', {
+        instances: [],
+        alreadyLogged: new Set()
+    });
+}
+// We need getGlobalObjectSafe() because globalObject is `undefined` when exported functions are called before globalObject is initialized
+function getGlobalObjectSafe() {
+    globalObject ?? (globalObject = genGlobalConfig());
+    return globalObject;
+}
 const clientRuntimesClonflict = 'Client runtime of both Server Routing and Client Routing loaded https://vike.dev/client-runtimes-conflict';
 const clientNotSingleInstance = 'Client runtime loaded twice https://vike.dev/client-runtime-duplicated';
 function assertSingleInstance() {
+    const globalObject = getGlobalObjectSafe();
     {
         const versions = unique(globalObject.instances);
         assertWarning(versions.length <= 1, 
@@ -34,6 +45,7 @@ function assertSingleInstance() {
     }
 }
 function assertSingleInstance_onClientEntryServerRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== true, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -48,6 +60,7 @@ function assertSingleInstance_onClientEntryServerRouting(isProduction) {
     assertSingleInstance();
 }
 function assertSingleInstance_onClientEntryClientRouting(isProduction) {
+    const globalObject = getGlobalObjectSafe();
     assertWarning(globalObject.isClientRouting !== false, clientRuntimesClonflict, {
         onlyOnce: true,
         showStackTrace: true
@@ -63,10 +76,12 @@ function assertSingleInstance_onClientEntryClientRouting(isProduction) {
 }
 // Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
 function assertSingleInstance_onAssertModuleLoad() {
+    const globalObject = getGlobalObjectSafe();
     globalObject.instances.push(PROJECT_VERSION);
     assertSingleInstance();
 }
 function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    const globalObject = getGlobalObjectSafe();
     if (condition) {
         return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.226",
+  "version": "0.4.227",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {