vike 0.4.231-commit-e23b4f5 → 0.4.231-commit-7a947d3

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = build;
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 const vite_1 = require("vite");
+const context_js_1 = require("../cli/context.js");
+const context_js_2 = require("../prerender/context.js");
 const utils_js_1 = require("./utils.js");
 /**
  * Programmatically trigger `$ vike build`
@@ -32,7 +34,9 @@ async function build(options = {}) {
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
         await (0, vite_1.build)(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
-        // if (isVikeCli() && isPrerendering()) assert(false)
+        const prerenderTrigger = (0, context_js_2.wasPrerenderRun)();
+        if ((0, context_js_1.isVikeCli)() && prerenderTrigger && prerenderTrigger !== 'prerender()')
+            (0, utils_js_1.assert)(false);
     }
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prerender = prerender;
-const runPrerender_js_1 = require("../prerender/runPrerender.js");
+const runPrerenderEntry_js_1 = require("../prerender/runPrerenderEntry.js");
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 /**
  * Programmatically trigger `$ vike prerender`
@@ -11,7 +11,7 @@ const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 async function prerender(options = {}) {
     const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'prerender');
     options.viteConfig = viteConfigFromUserEnhanced;
-    const { viteConfig } = await (0, runPrerender_js_1.runPrerenderFromAPI)(options);
+    const { viteConfig } = await (0, runPrerenderEntry_js_1.runPrerenderFromAPI)(options);
     return {
         viteConfig
     };

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

@@ -113,7 +113,7 @@ async function cmdPreview() {
     }
 }
 async function cmdPrerender() {
-    const { runPrerenderFromCLIPrerenderCommand } = await Promise.resolve().then(() => __importStar(require('../prerender/runPrerender.js')));
+    const { runPrerenderFromCLIPrerenderCommand } = await Promise.resolve().then(() => __importStar(require('../prerender/runPrerenderEntry.js')));
     await runPrerenderFromCLIPrerenderCommand();
 }
 process.on('unhandledRejection', (rejectValue) => {

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPrerenderAutoRunEnabled = isPrerenderAutoRunEnabled;
 exports.temp_disablePrerenderAutoRun = temp_disablePrerenderAutoRun;
-exports.isPrerendering = isPrerendering;
-exports.setContextIsPrerendering = setContextIsPrerendering;
+exports.wasPrerenderRun = wasPrerenderRun;
+exports.setWasPrerenderRun = setWasPrerenderRun;
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
 const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
 const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('prerender/context.ts', {});
@@ -18,9 +18,9 @@ function isPrerenderAutoRunEnabled(vikeConfig) {
 function temp_disablePrerenderAutoRun() {
     globalObject.isDisabled = true;
 }
-function isPrerendering() {
-    return !!globalObject.isPrerendering;
+function wasPrerenderRun() {
+    return globalObject.wasPrerenderRun;
 }
-function setContextIsPrerendering() {
-    globalObject.isPrerendering = true;
+function setWasPrerenderRun(trigger) {
+    globalObject.wasPrerenderRun = trigger;
 }

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

@@ -36,10 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runPrerenderFromAPI = runPrerenderFromAPI;
-exports.runPrerenderFromCLIPrerenderCommand = runPrerenderFromCLIPrerenderCommand;
-exports.runPrerenderFromAutoRun = runPrerenderFromAutoRun;
-exports.runPrerender_forceExit = runPrerender_forceExit;
+exports.runPrerender = runPrerender;
+// Failed attempt to run this file (i.e. pre-rendering) in a separate process: https://github.com/vikejs/vike/commit/48feda87012115b32a5c9701da354cb8c138dfd2
+// - The issue is that prerenderContext needs to be serialized for being able to pass it from the child process to the parent process.
+// - The prerenderContext is used by vike-vercel
 const path_1 = __importDefault(require("path"));
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
@@ -60,51 +60,15 @@ const loadPageConfigsLazyServerSide_js_1 = require("../runtime/renderPage/loadPa
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
 const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
 const resolveVikeConfigInternal_js_1 = require("../vite/shared/resolveVikeConfigInternal.js");
-const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
 const execHook_js_1 = require("../../shared/hooks/execHook.js");
-const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
 const context_js_1 = require("./context.js");
 const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
 const getOutDirs_js_1 = require("../vite/shared/getOutDirs.js");
-const context_js_2 = require("../cli/context.js");
-const isViteCliCall_js_1 = require("../vite/shared/isViteCliCall.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const docLink = 'https://vike.dev/i18n#pre-rendering';
-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.
-    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
-}
-async function runPrerenderFromCLIPrerenderCommand() {
-    try {
-        const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
-    }
-    catch (err) {
-        console.error(err);
-        // Error may come from user-land; we need to use logErrorHint()
-        (0, logErrorHint_js_1.logErrorHint)(err);
-        process.exit(1);
-    }
-    runPrerender_forceExit();
-    (0, utils_js_1.assert)(false);
-}
-async function runPrerenderFromAutoRun(viteConfig) {
-    try {
-        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
-        console.error(err);
-        (0, logErrorHint_js_1.logErrorHint)(err);
-        process.exit(1);
-    }
-    const forceExit = (0, context_js_2.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
-    return { forceExit };
-}
-async function runPrerender(options = {}, standaloneTrigger) {
-    (0, context_js_1.setContextIsPrerendering)();
+async function runPrerender(options = {}, trigger) {
+    (0, context_js_1.setWasPrerenderRun)(trigger);
     checkOutdatedOptions(options);
     (0, utils_js_1.onSetupPrerender)();
     (0, globalContext_js_1.setGlobalContext_isPrerendering)();
@@ -121,7 +85,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
-        (0, utils_js_1.assert)(standaloneTrigger);
+        (0, utils_js_1.assert)(trigger !== 'auto-run');
         /* TODO/v1-release: use this assertUsage() again.
          * - Make sure https://github.com/magne4000/vite-plugin-vercel/pull/156 is merged before using this assertUsage() again. (Otherwise vite-plugin-vercel will trigger this assertUsage() call.)
          *   - Done: PR is merged as of June 20205
@@ -736,16 +700,6 @@ function isSameUrl(url1, url2) {
 function normalizeUrl(url) {
     return '/' + url.split('/').filter(Boolean).join('/');
 }
-function runPrerender_forceExit() {
-    // Force exit; known situations where pre-rendering is hanging:
-    //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
-    //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
-    process.exit(0);
-    /* I guess there is no need to tell the user about it? Let's see if a user complains.
-     * I don't known whether there is a way to call process.exit(0) only if needed, thus I'm not sure if there is a way to conditionally show a assertInfo().
-    assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usally fine, see ...", { onlyOnce: false })
-    */
-}
 function assertIsNotAbort(err, urlOriginal) {
     if (!(0, abort_js_1.isAbortError)(err))
         return;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrerenderFromAPI = runPrerenderFromAPI;
+exports.runPrerenderFromCLIPrerenderCommand = runPrerenderFromCLIPrerenderCommand;
+exports.runPrerenderFromAutoRun = runPrerenderFromAutoRun;
+exports.runPrerender_forceExit = runPrerender_forceExit;
+const utils_js_1 = require("./utils.js");
+const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
+const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
+const context_js_1 = require("../cli/context.js");
+const isViteCliCall_js_1 = require("../vite/shared/isViteCliCall.js");
+const runPrerender_js_1 = require("./runPrerender.js");
+async function runPrerenderFromAPI(options = {}) {
+    // - 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.
+    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
+    const { viteConfig } = await (0, runPrerender_js_1.runPrerender)(options, 'prerender()');
+    return { viteConfig };
+}
+async function runPrerenderFromCLIPrerenderCommand() {
+    try {
+        const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
+        await (0, runPrerender_js_1.runPrerender)({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
+    }
+    catch (err) {
+        console.error(err);
+        // Error may come from user-land; we need to use logErrorHint()
+        (0, logErrorHint_js_1.logErrorHint)(err);
+        process.exit(1);
+    }
+    runPrerender_forceExit();
+    (0, utils_js_1.assert)(false);
+}
+async function runPrerenderFromAutoRun(viteConfig) {
+    try {
+        await (0, runPrerender_js_1.runPrerender)({ viteConfig }, 'auto-run');
+    }
+    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);
+        (0, logErrorHint_js_1.logErrorHint)(err);
+        process.exit(1);
+    }
+    const forceExit = (0, context_js_1.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
+    return { forceExit };
+}
+function runPrerender_forceExit() {
+    // Force exit; known situations where pre-rendering is hanging:
+    //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
+    //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
+    process.exit(0);
+    /* I guess there is no need to tell the user about it? Let's see if a user complains.
+     * I don't known whether there is a way to call process.exit(0) only if needed, thus I'm not sure if there is a way to conditionally show a assertInfo().
+    assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usally fine, see ...", { onlyOnce: false })
+    */
+}

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

@@ -7,7 +7,6 @@ exports.pluginAutoFullBuild = pluginAutoFullBuild;
 exports.isPrerenderForceExit = isPrerenderForceExit;
 const vite_1 = require("vite");
 const utils_js_1 = require("../../utils.js");
-const runPrerender_js_1 = require("../../../prerender/runPrerender.js");
 const context_js_1 = require("../../../prerender/context.js");
 const isViteCliCall_js_1 = require("../../shared/isViteCliCall.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -17,6 +16,7 @@ const resolveVikeConfigInternal_js_1 = require("../../shared/resolveVikeConfigIn
 const context_js_2 = require("../../../api/context.js");
 const handleAssetsManifest_js_1 = require("./handleAssetsManifest.js");
 const isViteServerBuild_js_1 = require("../../shared/isViteServerBuild.js");
+const runPrerenderEntry_js_1 = require("../../../prerender/runPrerenderEntry.js");
 (0, utils_js_1.assertIsSingleModuleInstance)('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
@@ -31,18 +31,28 @@ function pluginAutoFullBuild() {
                 await abortViteBuildSsr();
             },
             writeBundle: {
-                /* We can't use this because it breaks Vite's logging. TODO/eventually: try again with latest Vite version.
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
                 sequential: true,
                 order: 'pre',
                 */
                 async handler(options, bundle) {
-                    await (0, handleAssetsManifest_js_1.handleAssetsManifest)(config, this.environment, options, bundle);
-                    await triggerFullBuild(config, this.environment, bundle);
+                    try {
+                        await (0, handleAssetsManifest_js_1.handleAssetsManifest)(config, this.environment, options, bundle);
+                        await triggerFullBuild(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        (0, logErrorHint_js_1.logErrorHint)(err);
+                        process.exit(1);
+                    }
                 }
             }
         },
         {
-            name: 'vike:build:pluginAutoFullBuild:forceExit',
+            name: 'vike:build:pluginAutoFullBuild:post',
             apply: 'build',
             enforce: 'post',
             closeBundle: {
@@ -55,7 +65,7 @@ function pluginAutoFullBuild() {
                     if (forceExit &&
                         // Let vike:build:pluginBuildApp force exit
                         !vikeConfig.config.vite6BuilderApp) {
-                        (0, runPrerender_js_1.runPrerender_forceExit)();
+                        (0, runPrerenderEntry_js_1.runPrerender_forceExit)();
                         (0, utils_js_1.assert)(false);
                     }
                 }
@@ -81,22 +91,15 @@ async function triggerFullBuild(config, viteEnv, bundle) {
         return;
     const configInline = getFullBuildInlineConfig(config);
     if (!isBuilderApp) {
-        try {
-            await (0, vite_1.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);
-            (0, logErrorHint_js_1.logErrorHint)(err);
-            process.exit(1);
-        }
+        await (0, vite_1.build)(setSSR(configInline));
     }
     else {
         // 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);
+        const res = await (0, runPrerenderEntry_js_1.runPrerenderFromAutoRun)(configInline);
         forceExit = res.forceExit;
+        (0, utils_js_1.assert)((0, context_js_1.wasPrerenderRun)());
     }
 }
 function setSSR(configInline) {

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pluginBuildApp = pluginBuildApp;
-const runPrerender_js_1 = require("../../../prerender/runPrerender.js");
+const runPrerenderEntry_js_1 = require("../../../prerender/runPrerenderEntry.js");
 const getOutDirs_js_1 = require("../../shared/getOutDirs.js");
 const utils_js_1 = require("../../utils.js");
 const pluginAutoFullBuild_js_1 = require("./pluginAutoFullBuild.js");
@@ -24,7 +24,7 @@ function pluginBuildApp() {
                             await builder.build(builder.environments.client);
                             await builder.build(builder.environments.ssr);
                             if ((0, pluginAutoFullBuild_js_1.isPrerenderForceExit)()) {
-                                (0, runPrerender_js_1.runPrerender_forceExit)();
+                                (0, runPrerenderEntry_js_1.runPrerender_forceExit)();
                                 (0, utils_js_1.assert)(false);
                             }
                         }

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.231-commit-e23b4f5';
+exports.PROJECT_VERSION = '0.4.231-commit-7a947d3';

package/dist/cjs/utils/genPromise.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.genPromise = genPromise;
 // Simple implementation without timeout: https://github.com/vikejs/vike/blob/2e59b922e7e0f227d26018dc2b74877c9b0f581b/vike/utils/genPromise.ts
 const assert_js_1 = require("./assert.js");
-const timeoutSeconds = 25;
-function genPromise() {
+const timeoutSecondsDefault = 25;
+function genPromise({ timeout: timeoutSeconds = timeoutSecondsDefault } = {}) {
     let resolve;
     let reject;
     let finished = false;
@@ -22,19 +22,25 @@ function genPromise() {
     });
     const timeoutClear = () => timeouts.forEach((t) => clearTimeout(t));
     const timeouts = [];
-    const promise = new Proxy(promise_internal, {
-        get(target, prop) {
-            if (prop === 'then' && !finished) {
-                const err = new Error(`Promise hasn't resolved after ${timeoutSeconds} seconds`);
-                timeouts.push(setTimeout(() => {
-                    (0, assert_js_1.assert)(err.stack);
-                    (0, assert_js_1.assertWarning)(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
-                }, timeoutSeconds * 1000));
+    let promise;
+    if (!timeoutSeconds) {
+        promise = promise_internal;
+    }
+    else {
+        promise = new Proxy(promise_internal, {
+            get(target, prop) {
+                if (prop === 'then' && !finished) {
+                    const err = new Error(`Promise hasn't resolved after ${timeoutSeconds} seconds`);
+                    timeouts.push(setTimeout(() => {
+                        (0, assert_js_1.assert)(err.stack);
+                        (0, assert_js_1.assertWarning)(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
+                    }, timeoutSeconds * 1000));
+                }
+                const value = Reflect.get(target, prop);
+                return typeof value === 'function' ? value.bind(target) : value;
             }
-            const value = Reflect.get(target, prop);
-            return typeof value === 'function' ? value.bind(target) : value;
-        }
-    });
+        });
+    }
     return { promise, resolve, reject };
 }
 function removeStackErrorPrefix(errStack) {

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

@@ -1,7 +1,9 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite, version, createBuilder } from 'vite';
-import { assertVersion } from './utils.js';
+import { isVikeCli } from '../cli/context.js';
+import { wasPrerenderRun } from '../prerender/context.js';
+import { assert, assertVersion } from './utils.js';
 /**
  * Programmatically trigger `$ vike build`
  *
@@ -30,7 +32,9 @@ async function build(options = {}) {
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
         await buildVite(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
-        // if (isVikeCli() && isPrerendering()) assert(false)
+        const prerenderTrigger = wasPrerenderRun();
+        if (isVikeCli() && prerenderTrigger && prerenderTrigger !== 'prerender()')
+            assert(false);
     }
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`

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

@@ -1,5 +1,5 @@
 export { prerender };
-import { type PrerenderOptions } from '../prerender/runPrerender.js';
+import type { PrerenderOptions } from '../prerender/runPrerender.js';
 import type { ResolvedConfig } from 'vite';
 /**
  * Programmatically trigger `$ vike prerender`

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

@@ -1,5 +1,5 @@
 export { prerender };
-import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
+import { runPrerenderFromAPI } from '../prerender/runPrerenderEntry.js';
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 /**
  * Programmatically trigger `$ vike prerender`

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

@@ -75,7 +75,7 @@ async function cmdPreview() {
     }
 }
 async function cmdPrerender() {
-    const { runPrerenderFromCLIPrerenderCommand } = await import('../prerender/runPrerender.js');
+    const { runPrerenderFromCLIPrerenderCommand } = await import('../prerender/runPrerenderEntry.js');
     await runPrerenderFromCLIPrerenderCommand();
 }
 process.on('unhandledRejection', (rejectValue) => {

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

@@ -1,9 +1,10 @@
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
-export { isPrerendering };
-export { setContextIsPrerendering };
+export { wasPrerenderRun };
+export { setWasPrerenderRun };
 import type { VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
+import type { PrerenderTrigger } from './runPrerender.js';
 declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigInternal): boolean;
 declare function temp_disablePrerenderAutoRun(): void;
-declare function isPrerendering(): boolean;
-declare function setContextIsPrerendering(): void;
+declare function wasPrerenderRun(): PrerenderTrigger | undefined;
+declare function setWasPrerenderRun(trigger: PrerenderTrigger): void;

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

@@ -1,7 +1,7 @@
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
-export { isPrerendering };
-export { setContextIsPrerendering };
+export { wasPrerenderRun };
+export { setWasPrerenderRun };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { resolvePrerenderConfigGlobal } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
@@ -16,9 +16,9 @@ function isPrerenderAutoRunEnabled(vikeConfig) {
 function temp_disablePrerenderAutoRun() {
     globalObject.isDisabled = true;
 }
-function isPrerendering() {
-    return !!globalObject.isPrerendering;
+function wasPrerenderRun() {
+    return globalObject.wasPrerenderRun;
 }
-function setContextIsPrerendering() {
-    globalObject.isPrerendering = true;
+function setWasPrerenderRun(trigger) {
+    globalObject.wasPrerenderRun = trigger;
 }

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

@@ -1,12 +1,9 @@
-export { runPrerenderFromAPI };
-export { runPrerenderFromCLIPrerenderCommand };
-export { runPrerenderFromAutoRun };
-export { runPrerender_forceExit };
+export { runPrerender };
 export type { PrerenderOptions };
 export type { PrerenderContextPublic };
+export type { PrerenderTrigger };
 import type { PageFile } from '../../shared/getPageFiles.js';
 import { type GlobalContextServerInternal } from '../runtime/globalContext.js';
-import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions } from '../api/types.js';
 type ProvidedByHook = null | {
     hookFilePath: string;
@@ -60,12 +57,9 @@ type PrerenderOptions = APIOptions & {
     /** @deprecated */
     base?: string;
 };
-declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
-    viteConfig: ResolvedConfig;
-}>;
-declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
-    forceExit: boolean;
+type PrerenderTrigger = '$ vike prerender' | 'prerender()' | 'auto-run';
+declare function runPrerender(options: PrerenderOptions | undefined, trigger: PrerenderTrigger): Promise<{
+    viteConfig: import("vite").ResolvedConfig;
 }>;
 declare function createPageContextPrerendering(urlOriginal: string, prerenderContext: PrerenderContext, globalContext: GlobalContextServerInternal, is404: boolean, pageId: string | undefined, providedByHook: ProvidedByHook): Promise<((({
     _isOriginalObject: true;
@@ -100,7 +94,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: ResolvedConfig;
+        viteConfig: import("vite").ResolvedConfig;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -118,7 +112,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     } | {
         _isPrerendering: true;
-        viteConfig: ResolvedConfig;
+        viteConfig: import("vite").ResolvedConfig;
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
@@ -221,7 +215,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: ResolvedConfig;
+        viteConfig: import("vite").ResolvedConfig;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -239,7 +233,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     } | {
         _isPrerendering: true;
-        viteConfig: ResolvedConfig;
+        viteConfig: import("vite").ResolvedConfig;
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
@@ -323,4 +317,3 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
 }) & {
     _usesClientRouter: boolean;
 }>;
-declare function runPrerender_forceExit(): void;

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

@@ -1,7 +1,7 @@
-export { runPrerenderFromAPI };
-export { runPrerenderFromCLIPrerenderCommand };
-export { runPrerenderFromAutoRun };
-export { runPrerender_forceExit };
+export { runPrerender };
+// Failed attempt to run this file (i.e. pre-rendering) in a separate process: https://github.com/vikejs/vike/commit/48feda87012115b32a5c9701da354cb8c138dfd2
+// - The issue is that prerenderContext needs to be serialized for being able to pass it from the child process to the parent process.
+// - The prerenderContext is used by vike-vercel
 import path from 'path';
 import { route } from '../../shared/route/index.js';
 import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, onSetupPrerender, PROJECT_VERSION, preservePropertyGetters, changeEnumerable } from './utils.js';
@@ -22,51 +22,15 @@ import { loadPageConfigsLazyServerSide } from '../runtime/renderPage/loadPageCon
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
-import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { execHookWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
-import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
-import { setContextIsPrerendering } from './context.js';
+import { setWasPrerenderRun } from './context.js';
 import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
 import { getOutDirs } from '../vite/shared/getOutDirs.js';
-import { isVikeCli } from '../cli/context.js';
-import { isViteCliCall } from '../vite/shared/isViteCliCall.js';
 import fs from 'node:fs';
 import { getProxyForPublicUsage } from '../../shared/getProxyForPublicUsage.js';
 const docLink = 'https://vike.dev/i18n#pre-rendering';
-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.
-    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
-}
-async function runPrerenderFromCLIPrerenderCommand() {
-    try {
-        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
-    }
-    catch (err) {
-        console.error(err);
-        // Error may come from user-land; we need to use logErrorHint()
-        logErrorHint(err);
-        process.exit(1);
-    }
-    runPrerender_forceExit();
-    assert(false);
-}
-async function runPrerenderFromAutoRun(viteConfig) {
-    try {
-        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
-        console.error(err);
-        logErrorHint(err);
-        process.exit(1);
-    }
-    const forceExit = isVikeCli() || isViteCliCall();
-    return { forceExit };
-}
-async function runPrerender(options = {}, standaloneTrigger) {
-    setContextIsPrerendering();
+async function runPrerender(options = {}, trigger) {
+    setWasPrerenderRun(trigger);
     checkOutdatedOptions(options);
     onSetupPrerender();
     setGlobalContext_isPrerendering();
@@ -83,7 +47,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
-        assert(standaloneTrigger);
+        assert(trigger !== 'auto-run');
         /* TODO/v1-release: use this assertUsage() again.
          * - Make sure https://github.com/magne4000/vite-plugin-vercel/pull/156 is merged before using this assertUsage() again. (Otherwise vite-plugin-vercel will trigger this assertUsage() call.)
          *   - Done: PR is merged as of June 20205
@@ -698,16 +662,6 @@ function isSameUrl(url1, url2) {
 function normalizeUrl(url) {
     return '/' + url.split('/').filter(Boolean).join('/');
 }
-function runPrerender_forceExit() {
-    // Force exit; known situations where pre-rendering is hanging:
-    //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
-    //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
-    process.exit(0);
-    /* I guess there is no need to tell the user about it? Let's see if a user complains.
-     * I don't known whether there is a way to call process.exit(0) only if needed, thus I'm not sure if there is a way to conditionally show a assertInfo().
-    assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usally fine, see ...", { onlyOnce: false })
-    */
-}
 function assertIsNotAbort(err, urlOriginal) {
     if (!isAbortError(err))
         return;

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

@@ -0,0 +1,14 @@
+export { runPrerenderFromAPI };
+export { runPrerenderFromCLIPrerenderCommand };
+export { runPrerenderFromAutoRun };
+export { runPrerender_forceExit };
+import type { InlineConfig, ResolvedConfig } from 'vite';
+import { PrerenderOptions } from './runPrerender.js';
+declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
+    viteConfig: ResolvedConfig;
+}>;
+declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
+    forceExit: boolean;
+}>;
+declare function runPrerender_forceExit(): void;

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

@@ -0,0 +1,53 @@
+export { runPrerenderFromAPI };
+export { runPrerenderFromCLIPrerenderCommand };
+export { runPrerenderFromAutoRun };
+export { runPrerender_forceExit };
+import { assert } from './utils.js';
+import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
+import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
+import { isVikeCli } from '../cli/context.js';
+import { isViteCliCall } from '../vite/shared/isViteCliCall.js';
+import { runPrerender } from './runPrerender.js';
+async function runPrerenderFromAPI(options = {}) {
+    // - 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.
+    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
+    const { viteConfig } = await runPrerender(options, 'prerender()');
+    return { viteConfig };
+}
+async function runPrerenderFromCLIPrerenderCommand() {
+    try {
+        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
+    }
+    catch (err) {
+        console.error(err);
+        // Error may come from user-land; we need to use logErrorHint()
+        logErrorHint(err);
+        process.exit(1);
+    }
+    runPrerender_forceExit();
+    assert(false);
+}
+async function runPrerenderFromAutoRun(viteConfig) {
+    try {
+        await runPrerender({ viteConfig }, 'auto-run');
+    }
+    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);
+    }
+    const forceExit = isVikeCli() || isViteCliCall();
+    return { forceExit };
+}
+function runPrerender_forceExit() {
+    // Force exit; known situations where pre-rendering is hanging:
+    //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
+    //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
+    process.exit(0);
+    /* I guess there is no need to tell the user about it? Let's see if a user complains.
+     * I don't known whether there is a way to call process.exit(0) only if needed, thus I'm not sure if there is a way to conditionally show a assertInfo().
+    assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usally fine, see ...", { onlyOnce: false })
+    */
+}

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

@@ -2,8 +2,7 @@ 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 { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
@@ -12,6 +11,7 @@ import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js
 import { isVikeCliOrApi } from '../../../api/context.js';
 import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
 import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/isViteServerBuild.js';
+import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
 assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
@@ -26,18 +26,28 @@ function pluginAutoFullBuild() {
                 await abortViteBuildSsr();
             },
             writeBundle: {
-                /* We can't use this because it breaks Vite's logging. TODO/eventually: try again with latest Vite version.
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
                 sequential: true,
                 order: 'pre',
                 */
                 async handler(options, bundle) {
-                    await handleAssetsManifest(config, this.environment, options, bundle);
-                    await triggerFullBuild(config, this.environment, bundle);
+                    try {
+                        await handleAssetsManifest(config, this.environment, options, bundle);
+                        await triggerFullBuild(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        logErrorHint(err);
+                        process.exit(1);
+                    }
                 }
             }
         },
         {
-            name: 'vike:build:pluginAutoFullBuild:forceExit',
+            name: 'vike:build:pluginAutoFullBuild:post',
             apply: 'build',
             enforce: 'post',
             closeBundle: {
@@ -76,15 +86,7 @@ async function triggerFullBuild(config, viteEnv, bundle) {
         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);
-        }
+        await build(setSSR(configInline));
     }
     else {
         // The server bulid is already called by builder.buildApp()
@@ -92,6 +94,7 @@ async function triggerFullBuild(config, viteEnv, bundle) {
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
         const res = await runPrerenderFromAutoRun(configInline);
         forceExit = res.forceExit;
+        assert(wasPrerenderRun());
     }
 }
 function setSSR(configInline) {

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

@@ -1,5 +1,5 @@
 export { pluginBuildApp };
-import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
+import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
 import { isPrerenderForceExit } from './pluginAutoFullBuild.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.231-commit-e23b4f5";
+export declare const PROJECT_VERSION: "0.4.231-commit-7a947d3";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.231-commit-e23b4f5';
+export const PROJECT_VERSION = '0.4.231-commit-7a947d3';

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

@@ -1,5 +1,7 @@
 export { genPromise };
-declare function genPromise<T = void>(): {
+declare function genPromise<T = void>({ timeout: timeoutSeconds }?: {
+    timeout?: number | null | undefined;
+}): {
     promise: Promise<T>;
     resolve: (val: T) => void;
     reject: (err: unknown) => void;

package/dist/esm/utils/genPromise.js

@@ -1,8 +1,8 @@
 export { genPromise };
 // Simple implementation without timeout: https://github.com/vikejs/vike/blob/2e59b922e7e0f227d26018dc2b74877c9b0f581b/vike/utils/genPromise.ts
 import { assert, assertWarning } from './assert.js';
-const timeoutSeconds = 25;
-function genPromise() {
+const timeoutSecondsDefault = 25;
+function genPromise({ timeout: timeoutSeconds = timeoutSecondsDefault } = {}) {
     let resolve;
     let reject;
     let finished = false;
@@ -20,19 +20,25 @@ function genPromise() {
     });
     const timeoutClear = () => timeouts.forEach((t) => clearTimeout(t));
     const timeouts = [];
-    const promise = new Proxy(promise_internal, {
-        get(target, prop) {
-            if (prop === 'then' && !finished) {
-                const err = new Error(`Promise hasn't resolved after ${timeoutSeconds} seconds`);
-                timeouts.push(setTimeout(() => {
-                    assert(err.stack);
-                    assertWarning(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
-                }, timeoutSeconds * 1000));
+    let promise;
+    if (!timeoutSeconds) {
+        promise = promise_internal;
+    }
+    else {
+        promise = new Proxy(promise_internal, {
+            get(target, prop) {
+                if (prop === 'then' && !finished) {
+                    const err = new Error(`Promise hasn't resolved after ${timeoutSeconds} seconds`);
+                    timeouts.push(setTimeout(() => {
+                        assert(err.stack);
+                        assertWarning(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
+                    }, timeoutSeconds * 1000));
+                }
+                const value = Reflect.get(target, prop);
+                return typeof value === 'function' ? value.bind(target) : value;
             }
-            const value = Reflect.get(target, prop);
-            return typeof value === 'function' ? value.bind(target) : value;
-        }
-    });
+        });
+    }
     return { promise, resolve, reject };
 }
 function removeStackErrorPrefix(errStack) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.231-commit-e23b4f5",
+  "version": "0.4.231-commit-7a947d3",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {