vike 0.4.218 → 0.4.220-commit-a9f46b8

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -5,7 +5,8 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const { pageConfigs, pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
@@ -25,14 +26,15 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
-        const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
         lines.push(`  {`);
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide));
+        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
+        lines.push(`    loadConfigValuesAll: ${load},`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -42,7 +44,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

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

@@ -33,7 +33,7 @@ function setGlobalContext() {
                 order: 'post',
                 async handler(config) {
                     const { outDirRoot } = getOutDirs(config);
-                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
                     const vikeConfig = await getVikeConfig(config);
                     setGlobalContext_vikeConfig(vikeConfig);

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

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

package/dist/esm/node/plugin/plugins/{vite6HmrRegressionWorkaround.js → workaroundVite6HmrRegression.js}

@@ -1,11 +1,11 @@
-export { vite6HmrRegressionWorkaround };
+export { workaroundVite6HmrRegression };
 // https://vite.dev/guide/migration (will be 404 after vite@7 release) > search for `hmrReload()`
 // https://v6.vite.dev/guide/migration (will exist after vite@7 release) > search for `hmrReload()`
 // Workaround seems to work for docs page /banner (which is HTML-only)
 // But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
-function vite6HmrRegressionWorkaround() {
+function workaroundVite6HmrRegression() {
     return {
-        name: 'vike:vite6HmrRegressionWorkaround',
+        name: 'vike:workaroundVite6HmrRegression',
         enforce: 'post',
         hotUpdate: {
             order: 'post',

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

@@ -0,0 +1,9 @@
+export { isPrerenderAutoRunEnabled };
+export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function isPrerenderAutoRunEnabled(vikeConfigGlobal: VikeConfigGlobal): boolean;
+declare function temp_disablePrerenderAutoRun(): void;
+declare function isPrerendering(): boolean;
+declare function setContextIsPrerendering(): void;

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

@@ -0,0 +1,22 @@
+export { isPrerenderAutoRunEnabled };
+export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+const globalObject = getGlobalObject('prerender/context.ts', {});
+function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
+    return (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        !globalObject.isDisabled &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender');
+}
+// TODO/v1-release: remove
+function temp_disablePrerenderAutoRun() {
+    globalObject.isDisabled = true;
+}
+function isPrerendering() {
+    return !!globalObject.isPrerendering;
+}
+function setContextIsPrerendering() {
+    globalObject.isPrerendering = true;
+}

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

@@ -3,9 +3,47 @@ export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
-import '../runtime/page-files/setup.js';
+export type { PrerenderContextPublic };
+import { PageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
+import { PageContextUrlInternal } from '../../shared/getPageContextUrlComputed.js';
 import type { APIOptions } from '../api/types.js';
+type ProvidedByHook = null | {
+    hookFilePath: string;
+    hookName: 'onBeforePrerenderStart' | 'prerender';
+};
+type TransformerHook = {
+    hookFilePath: string;
+    hookName: 'onPrerenderStart' | 'onBeforePrerender';
+};
+type PageContextPrerendered = {
+    urlOriginal: string;
+    _providedByHook?: ProvidedByHook;
+};
+type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContext = {
+    pageContexts: PageContext[];
+    pageContextInit: Record<string, unknown> | null;
+    noExtraDir: boolean;
+    prerenderedPageContexts: PrerenderedPageContexts;
+    output: Output;
+};
+type Output = {
+    filePath: string;
+    fileType: FileType;
+    fileContent: string;
+    pageContext: PageContextPrerendered;
+}[];
+type FileType = 'HTML' | 'JSON';
+type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts'>;
+type PageContext = PageContextInitEnhanced & {
+    _urlRewrite: null;
+    _urlHandler: null;
+    _urlOriginalBeforeHook?: string;
+    _urlOriginalModifiedByHook?: TransformerHook;
+    _providedByHook: ProvidedByHook;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+} & PageContextUrlInternal;
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -30,5 +68,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, forceExit: boolean): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
+    prerenderContextPublic: PrerenderContextPublic;
+}>;
 declare function runPrerender_forceExit(): void;

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

@@ -2,11 +2,10 @@ export { runPrerenderFromAPI };
 export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
-import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender } from './utils.js';
-import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy } from './utils.js';
+import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
@@ -15,7 +14,7 @@ import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
 import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
@@ -28,6 +27,7 @@ import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
+import { setContextIsPrerendering } from './context.js';
 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.
@@ -46,19 +46,21 @@ async function runPrerenderFromCLIPrerenderCommand() {
     }
     runPrerender_forceExit();
 }
-async function runPrerenderFromAutoRun(viteConfig, forceExit) {
+async function runPrerenderFromAutoRun(viteConfig) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
-    if (forceExit)
-        runPrerender_forceExit();
+    return { prerenderContextPublic };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    setContextIsPrerendering();
     checkOutdatedOptions(options);
     onSetupPrerender();
     setGlobalContext_isPrerendering();
@@ -69,11 +71,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
-    assertLoadedConfig(viteConfig, options);
     const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         assert(standaloneTrigger);
         assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
@@ -83,39 +85,40 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
-    const renderContext = await getRenderContext();
-    renderContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    objectAssign(prerenderContext, {
-        _urlHandler: null,
-        _noExtraDir: noExtraDir ?? false,
+    const globalContext = getGlobalContext();
+    globalContext.pageFilesAll.forEach(assertExportNames);
+    const prerenderContext = {
+        noExtraDir: noExtraDir ?? false,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null
-    });
+        pageContextInit: options.pageContextInit ?? null,
+        prerenderedPageContexts: {},
+        output: []
+    };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderedPageContexts = {};
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
+    await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
+    await callOnPrerenderStartHook(prerenderContext);
     let prerenderedCount = 0;
+    // Write files as soon as pages finish rendering (instead of writing all files at once only after all pages have rendered).
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
         if (htmlFile.pageId) {
-            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+            prerenderContext.prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
         }
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
     await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
-    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
-    return { viteConfig };
+    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
-async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
@@ -133,7 +136,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     });
     // Old design
     // TODO/v1-release: remove
-    await Promise.all(renderContext.pageFilesAll
+    const globalContext = getGlobalContext();
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('doNotPrerender'))
@@ -145,8 +149,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
         assert(p.loadFile);
         await p.loadFile();
     })));
-    renderContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = getPageFilesServerSide(renderContext.pageFilesAll, pageId);
+    globalContext.allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = getPageFilesServerSide(globalContext.pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -175,10 +179,11 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
+    const globalContext = getGlobalContext();
     // V1 design
-    await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
+    await Promise.all(globalContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await loadConfigValues(pageConfig, false);
         const hook = getHookFromPageConfig(pageConfigLoaded, hookName);
@@ -194,7 +199,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
     // 0.4 design
-    await Promise.all(renderContext.pageFilesAll
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('prerender'))
@@ -235,7 +240,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
                     assertUsage(false, `URL ${pc.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, renderContext, prerenderContext);
+            const pageContextNew = createPageContext(url, prerenderContext);
             objectAssign(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -252,9 +257,10 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit) {
+async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit) {
     // Pre-render pages with a static route
-    await Promise.all(renderContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
+    const globalContext = getGlobalContext();
+    await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
@@ -279,7 +285,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, renderContext, prerenderContext);
+        const pageContext = createPageContext(urlOriginal, prerenderContext);
         objectAssign(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -297,11 +303,11 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-function createPageContext(urlOriginal, renderContext, prerenderContext) {
+function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -309,17 +315,18 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
     };
     objectAssign(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, renderContext) {
+async function callOnPrerenderStartHook(prerenderContext) {
+    const globalContext = getGlobalContext();
     let onPrerenderStartHook;
     // V1 design
-    if (renderContext.pageConfigs.length > 0) {
+    if (globalContext.pageConfigs.length > 0) {
         const hookName = 'onPrerenderStart';
-        const hook = getHookFromPageConfigGlobal(renderContext.pageConfigGlobal, hookName);
+        const hook = getHookFromPageConfigGlobal(globalContext.pageConfigGlobal, hookName);
         if (hook) {
             assert(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -331,9 +338,9 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     }
     // Old design
     // TODO/v1-release: remove
-    if (renderContext.pageConfigs.length === 0) {
+    if (globalContext.pageConfigs.length === 0) {
         const hookTimeout = getHookTimeoutDefault('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -386,17 +393,20 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     const docLink = 'https://vike.dev/i18n#pre-rendering';
     // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
     const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
-    let result = await executeHook(() => hookFn({
-        pageContexts: prerenderContext.pageContexts,
+    let result = await executeHook(() => {
+        const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
-        get prerenderPageContexts() {
-            assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                showStackTrace: true,
-                onlyOnce: true
-            });
-            return prerenderContext.pageContexts;
-        }
-    }), onPrerenderStartHook, null);
+        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
+            get() {
+                assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+        return hookFn(prerenderContextPublic);
+    }, onPrerenderStartHook, null);
     restoreEnumerable();
     if (result === null || result === undefined) {
         return;
@@ -481,7 +491,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
                 usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
-                usesClientRouter = globalContext.pluginManifest.usesClientRouter;
+                usesClientRouter = globalContext.usesClientRouter;
             }
         }
         objectAssign(pageContext, {
@@ -503,7 +513,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -521,27 +531,28 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
-    const isV1 = renderContext.pageConfigs.length > 0;
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial) {
+    const globalContext = getGlobalContext();
+    const isV1 = globalContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
     const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
-    renderContext.allPageIds
+    globalContext.allPageIds
         .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
-        .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
+        .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 });
     });
 }
-async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
-    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderContext, onComplete) {
+    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
-            result = await prerender404Page(renderContext, prerenderContext.pageContextInit);
+            result = await prerender404Page(prerenderContext.pageContextInit);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
@@ -561,22 +572,23 @@ async function prerender404(prerenderedPageContexts, renderContext, prerenderCon
         }
     }
 }
-async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
     let fileUrl;
-    if (fileExtension === '.html') {
+    if (fileType === 'HTML') {
         fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
+        assert(fileType === 'JSON');
         fileUrl = getPageContextRequestUrl(urlOriginal);
     }
     assertPosixPath(fileUrl);
@@ -588,6 +600,12 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);
+    output.push({
+        filePath,
+        fileType,
+        fileContent,
+        pageContext
+    });
     if (onPagePrerender) {
         const prerenderPageContext = {};
         objectAssign(prerenderPageContext, pageContext);
@@ -672,25 +690,6 @@ async function disableReactStreaming() {
     const { disable } = mod;
     disable();
 }
-function assertLoadedConfig(viteConfig, options) {
-    if (viteConfig.plugins.some((p) => p.name.startsWith('vike'))) {
-        return;
-    }
-    const { configFile } = viteConfig;
-    if (configFile) {
-        assertUsage(false, `${configFile} doesn't install the vike plugin`);
-    }
-    else {
-        if (!options.viteConfig) {
-            assertUsage(false, `[prerender()] No vite.config.js file found at ${process.cwd()}. Use the option ${pc.cyan('prerender({ viteConfig })')}.`, { showStackTrace: true });
-        }
-        else {
-            assertUsage(false, `[prerender()] The Vite config ${pc.cyan('prerender({ viteConfig })')} is missing the vike plugin.`, {
-                showStackTrace: true
-            });
-        }
-    }
-}
 function isSameUrl(url1, url2) {
     return normalizeUrl(url1) === normalizeUrl(url2);
 }
@@ -740,3 +739,44 @@ function makePageContextComputedUrlNonEnumerable(pageContexts) {
         });
     }
 }
+function validatePrerenderConfig(
+// Guaranteed by configDef.type to be either an object or boolean
+prerenderConfig) {
+    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
+        return;
+    assert(isObject(prerenderConfig));
+    const wrongValue = (() => {
+        {
+            const p = 'partial';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(prerenderConfig, p, 'boolean') &&
+                !hasProp(prerenderConfig, p, 'number') &&
+                !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean or a number' };
+        }
+    })();
+    if (wrongValue) {
+        const { prop, errMsg } = wrongValue;
+        assertUsage(false, `Setting ${pc.cyan(`prerender.${prop}`)} ${errMsg}`);
+    }
+}
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

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

@@ -13,4 +13,6 @@ export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
+export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/makePublicCopy.js';

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

@@ -15,4 +15,6 @@ export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
+export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/makePublicCopy.js';