vike 0.4.231 → 0.4.232-commit-ec54a7e

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

@@ -1,16 +1,16 @@
-export { runPrerenderFromAPI };
-export { runPrerenderFromCLIPrerenderCommand };
-export { runPrerenderFromAutoRun };
-export { runPrerender_forceExit };
-import path from 'path';
+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 'node: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';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, onSetupPrerender, PROJECT_VERSION, preservePropertyGetters, changeEnumerable, escapeHtml, } from './utils.js';
 import { prerenderPage } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import { createPageContextServerSide } from '../runtime/renderPage/createPageContextServerSide.js';
 import pc from '@brillout/picocolors';
-import { cpus } from 'os';
-import { getGlobalContextServerInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
-import { resolveConfig } from 'vite';
+import { cpus } from 'node:os';
+import { getGlobalContextServerInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering, } from '../runtime/globalContext.js';
+import { resolveConfig as resolveViteConfig } from 'vite';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
@@ -19,55 +19,20 @@ import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js'
 import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadPageConfigsLazyServerSide } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
-import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering } from '../../shared/hooks/getHook.js';
+import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering, } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
-import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
+import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.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 '../plugin/shared/getOutDirs.js';
-import { isVikeCli } from '../cli/context.js';
-import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
-import { getVikeConfigInternal } from '../plugin/plugins/commonConfig.js';
+import { getOutDirs } from '../vite/shared/getOutDirs.js';
 import fs from 'node:fs';
 import { getProxyForPublicUsage } from '../../shared/getProxyForPublicUsage.js';
+import { getStaticRedirectsForPrerender } from '../runtime/renderPage/resolveRedirects.js';
+import { augmentType } from '../runtime/utils.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();
@@ -77,16 +42,16 @@ async function runPrerender(options = {}, standaloneTrigger) {
         console.log(`${pc.cyan(`vike v${PROJECT_VERSION}`)} ${pc.green('pre-rendering HTML...')}`);
     }
     await disableReactStreaming();
-    const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
-    const vikeConfig = await getVikeConfig(viteConfig);
-    const vike = getVikeConfigInternal(viteConfig);
-    const { outDirClient, outDirServer } = getOutDirs(viteConfig);
-    const { root } = viteConfig;
+    const viteConfig = await resolveViteConfig(options.viteConfig || {}, 'build', 'production');
+    const vikeConfig = await getVikeConfigInternal();
+    const { outDirServer } = getOutDirs(viteConfig);
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
-        assert(standaloneTrigger);
-        /* TODO/soon: use this again a little while after https://github.com/magne4000/vite-plugin-vercel/pull/156 is merged.
+        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
         assertUsage(
           false,
           `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${pc.cyan('prerender')} setting (${pc.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`
@@ -103,10 +68,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
         output: [],
         _noExtraDir: noExtraDir,
         _pageContextInit: options.pageContextInit ?? null,
-        _prerenderedPageContexts: {}
+        _prerenderedPageContexts: {},
     };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
+    await collectDoNoPrerenderList(vikeConfig._pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
     // Allow user to create `pageContext` for parameterized routes and/or bulk data fetching
     // https://vike.dev/onBeforePrerenderStart
     await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
@@ -124,18 +89,25 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
         const { pageId } = htmlFile.pageContext;
-        assert(pageId);
-        prerenderContext._prerenderedPageContexts[pageId] = htmlFile.pageContext;
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
+        assert((typeof pageId === 'string' && pageId) || pageId === null);
+        if (pageId) {
+            prerenderContext._prerenderedPageContexts[pageId] = htmlFile.pageContext;
+        }
+        await writeFiles(htmlFile, viteConfig, options.onPagePrerender, prerenderContext, logLevel);
     };
     await prerenderPages(prerenderContext, concurrencyLimit, onComplete);
     warnContradictoryNoPrerenderList(prerenderContext._prerenderedPageContexts, doNotPrerenderList);
+    const { redirects, isPrerenderingEnabledForAllPages } = prerenderConfigGlobal;
+    if (redirects !== null ? redirects : isPrerenderingEnabledForAllPages) {
+        const showWarningUponDynamicRedirects = !prerenderConfigGlobal.partial;
+        await prerenderRedirects(globalContext, onComplete, showWarningUponDynamicRedirects);
+    }
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
     await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    objectAssign(vike.prerenderContext, prerenderContextPublic, true);
+    objectAssign(vikeConfig.prerenderContext, prerenderContextPublic, true);
     if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
         fs.rmSync(outDirServer, { recursive: true });
     }
@@ -212,7 +184,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookName: 'onBeforePrerenderStart',
             hookFilePath,
             pageId: pageConfig.pageId,
-            hookTimeout
+            hookTimeout,
         });
     })));
     // 0.4 design
@@ -237,7 +209,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookName: 'prerender',
             hookFilePath,
             pageId: p.pageId,
-            hookTimeout: getHookTimeoutDefault('onBeforePrerenderStart')
+            hookTimeout: getHookTimeoutDefault('onBeforePrerenderStart'),
         });
     })));
     await Promise.all(onBeforePrerenderStartHooks.map(({ pageId, ...hook }) => concurrencyLimit(async () => {
@@ -302,7 +274,7 @@ function getUrlList404(globalContext) {
         urlList.push({
             // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
             urlOriginal: '/404',
-            pageId: errorPageId
+            pageId: errorPageId,
         });
     }
     return urlList;
@@ -320,10 +292,10 @@ async function createPageContexts(urlList, prerenderContext, globalContext, conc
 async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
     const pageContextInit = {
         urlOriginal,
-        ...prerenderContext._pageContextInit
+        ...prerenderContext._pageContextInit,
     };
     const pageContext = await createPageContextServerSide(pageContextInit, globalContext, {
-        isPrerendering: true
+        isPrerendering: true,
     });
     assert(pageContext.isPrerendering === true);
     objectAssign(pageContext, {
@@ -334,7 +306,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
         _prerenderContext: prerenderContext,
         _providedByHook: providedByHook,
         _urlOriginalModifiedByHook: null,
-        is404
+        is404,
     });
     if (!is404) {
         const pageContextFromRoute = await route(pageContext);
@@ -348,10 +320,10 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
         objectAssign(pageContext, {
             pageId,
             _debugRouteMatches: [],
-            routeParams: {}
+            routeParams: {},
         });
     }
-    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -391,7 +363,7 @@ function assertRouteMatch(pageContextFromRoute, pageContext) {
         assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.cyan(urlOriginal)} that ${noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
     }
     else {
-        // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
+        // `prerenderHookFile` is `null` when the URL was deduced by the Filesystem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
         assert(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
         // Abort since the URL doesn't correspond to any page
         return;
@@ -408,7 +380,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             onPrerenderStartHook = {
                 ...hook,
                 // Make TypeScript happy
-                hookName
+                hookName,
             };
         }
     }
@@ -421,7 +393,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
             assertUsage(p.fileType !== '.page.client', `${p.filePath} (which is a \`.page.client.js\` file) has \`export { onBeforePrerender }\` but it is only allowed in \`.page.server.js\` or \`.page.js\` files`);
-            assertUsage(p.isDefaultPageFile, `${p.filePath} has \`export { onBeforePrerender }\` but it is only allowed in \`_defaut.page.\` files`);
+            assertUsage(p.isDefaultPageFile, `${p.filePath} has \`export { onBeforePrerender }\` but it is only allowed in \`_default.page.\` files`);
             return true;
         });
         if (pageFilesWithOnBeforePrerenderHook.length === 0) {
@@ -442,7 +414,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
             hookName: 'onBeforePrerender',
-            hookTimeout
+            hookTimeout,
         };
     }
     if (!onPrerenderStartHook) {
@@ -460,7 +432,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
                 return pageContext.urlOriginal;
             },
             enumerable: false,
-            configurable: true
+            configurable: true,
         });
         assert(isPropertyGetter(pageContext, 'url'));
         assert(pageContext.urlOriginal);
@@ -491,8 +463,8 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         assertWarning(false, `${errPrefix} returns ${pc.cyan('{ globalContext: { prerenderPageContexts } }')} but the return value has been renamed to ${pc.cyan('{ prerenderContext: { pageContexts } }')}, see ${docLink}`, { onlyOnce: true });
         result = {
             prerenderContext: {
-                pageContexts: result.globalContext.prerenderPageContexts
-            }
+                pageContexts: result.globalContext.prerenderPageContexts,
+            },
         };
     }
     assertUsage(isObjectWithKeys(result, ['prerenderContext']) &&
@@ -518,7 +490,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         if (pageContext.urlOriginal !== pageContext._urlOriginalBeforeHook && !pageContext.is404) {
             pageContext._urlOriginalModifiedByHook = {
                 hookFilePath,
-                hookName
+                hookName,
             };
             const pageContextFromRoute = await route(pageContext, 
             // Avoid calling onBeforeRoute() twice, otherwise onBeforeRoute() will wrongfully believe URL doesn't have locale after onBeforeRoute() already removed the local from the URL when called the first time.
@@ -543,7 +515,6 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir ?? pageContext.is404
         });
     })));
 }
@@ -572,23 +543,24 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         .filter((pageId) => !isErrorPage(pageId, globalContext._pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
-        assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender#partial) to suppress this warning.`, { onlyOnce: true });
+        assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while there isn't any ${hookName}() hook returning an URL matching the page's route. You must use a ${hookName}() hook (https://vike.dev/${hookName}) for providing the list of URLs to be pre-rendered for that page. If you want to skip pre-rendering that page, you can remove this warning by setting +prerender to false at ${pageAt} (https://vike.dev/prerender#toggle) or by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
     });
 }
-async function writeFiles({ pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
-    const { urlOriginal } = pageContext;
-    assert(urlOriginal.startsWith('/'));
-    const writeJobs = [
-        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
-    ];
+async function writeFiles({ pageContext, htmlString, pageContextSerialized }, viteConfig, onPagePrerender, prerenderContext, logLevel) {
+    const writeJobs = [write(pageContext, 'HTML', htmlString, viteConfig, onPagePrerender, prerenderContext, logLevel)];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
+        writeJobs.push(write(pageContext, 'JSON', pageContextSerialized, viteConfig, onPagePrerender, prerenderContext, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
+async function write(pageContext, fileType, fileContent, viteConfig, onPagePrerender, prerenderContext, logLevel) {
+    const { urlOriginal } = pageContext;
+    assert(urlOriginal.startsWith('/'));
+    const { outDirClient } = getOutDirs(viteConfig);
+    const { root } = viteConfig;
     let fileUrl;
     if (fileType === 'HTML') {
+        const doNotCreateExtraDirectory = prerenderContext._noExtraDir ?? pageContext.is404;
         fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
@@ -599,7 +571,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     assert(fileUrl.startsWith('/'));
     const filePathRelative = fileUrl.slice(1);
     assert(!filePathRelative.startsWith('/'), 
-    // Let's remove this debug info after we add a assertUsage() avoiding https://github.com/vikejs/vike/issues/1929
+    // https://github.com/vikejs/vike/issues/1929
     { urlOriginal, fileUrl });
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
@@ -607,20 +579,20 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     objectAssign(pageContext, {
         _prerenderResult: {
             filePath,
-            fileContent
-        }
+            fileContent,
+        },
     });
-    output.push({
+    prerenderContext.output.push({
         filePath,
         fileType,
         fileContent,
-        pageContext
+        pageContext,
     });
     if (onPagePrerender) {
         await onPagePrerender(pageContext);
     }
     else {
-        const { promises } = await import('fs');
+        const { promises } = await import('node:fs');
         const { writeFile, mkdir } = promises;
         await mkdir(path.posix.dirname(filePath), { recursive: true });
         await writeFile(filePath, fileContent);
@@ -677,7 +649,7 @@ function checkOutdatedOptions(options) {
     ['base', 'outDir'].forEach((prop) => {
         assertWarning(options[prop] === undefined, `[prerender()] Option ${pc.cyan(prop)} is outdated and has no effect (vike now automatically determines ${pc.cyan(prop)})`, {
             showStackTrace: true,
-            onlyOnce: true
+            onlyOnce: true,
         });
     });
 }
@@ -698,16 +670,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;
@@ -728,10 +690,10 @@ function preparePrerenderContextForPublicUsage(prerenderContext) {
             get() {
                 assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${pc.underline(docLink)}`, {
                     showStackTrace: true,
-                    onlyOnce: true
+                    onlyOnce: true,
                 });
                 return prerenderContext.pageContexts;
-            }
+            },
         });
     }
     // Required because of https://vike.dev/i18n#pre-rendering
@@ -742,3 +704,41 @@ function preparePrerenderContextForPublicUsage(prerenderContext) {
     const prerenderContextPublic = getProxyForPublicUsage(prerenderContext, 'prerenderContext');
     return prerenderContextPublic;
 }
+async function prerenderRedirects(globalContext, onComplete, showWarningUponDynamicRedirects) {
+    const redirects = globalContext.config.redirects ?? [];
+    const redirectsStatic = getStaticRedirectsForPrerender(redirects, showWarningUponDynamicRedirects);
+    for (const [urlSource, urlTarget] of Object.entries(redirectsStatic)) {
+        const urlOriginal = urlSource;
+        const htmlString = getRedirectHtml(urlTarget);
+        await onComplete({
+            pageContext: { urlOriginal, pageId: null, is404: false, isRedirect: true },
+            htmlString,
+            pageContextSerialized: null,
+        });
+    }
+}
+function getRedirectHtml(urlTarget) {
+    const urlTargetSafe = escapeHtml(urlTarget);
+    // To test it: /test/playground => http://localhost:3000/download
+    const htmlString = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="refresh" content="0;url=${urlTargetSafe}">
+  <title>Redirect ${urlTargetSafe}</title>
+  <style>body{opacity:0}</style>
+  <noscript>
+  <style>body{opacity:1}</style>
+  </noscript>
+</head>
+<body style="min-height: 100vh; margin: 0; font-family: sans-serif; display: flex; justify-content: center; align-items: center; transition: opacity 0.3s;">
+  <script>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
+  <div>
+    <h1>Redirect <a href="${urlTargetSafe}"><code style="background-color: #eaeaea; padding: 3px 5px; border-radius: 4px;">${urlTargetSafe}</code></a></h1>
+    <p>If you aren't redirected, click the link above.</p>
+    <!-- This HTML was generated by Vike. -->
+  </div>
+</body>
+</html>`;
+    return htmlString;
+}

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 usually fine, see ...", { onlyOnce: false })
+    */
+}

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

@@ -16,3 +16,4 @@ export * from '../../utils/isObject.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/preservePropertyGetters.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/escapeHtml.js';

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

@@ -18,3 +18,4 @@ export * from '../../utils/isObject.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/preservePropertyGetters.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/escapeHtml.js';