vike 0.4.228 → 0.4.229

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

@@ -4,18 +4,31 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
 export type { PrerenderContextPublic };
+import type { PageFile } from '../../shared/getPageFiles.js';
+import { type GlobalContextServerInternal, type GlobalContextServer } from '../runtime/globalContext.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions } from '../api/types.js';
-import type { PageContextServer } from '../../shared/types.js';
 type ProvidedByHook = null | {
     hookFilePath: string;
     hookName: 'onBeforePrerenderStart' | 'prerender';
 };
+type ProvidedByHookTransformer = null | {
+    hookFilePath: string;
+    hookName: 'onPrerenderStart' | 'onBeforePrerender';
+};
 type PageContextPrerendered = {
     urlOriginal: string;
     _providedByHook?: ProvidedByHook;
     pageId: string;
 };
+type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContext = {
+    pageContexts: PageContext[];
+    output: Output;
+    _pageContextInit: Record<string, unknown> | null;
+    _noExtraDir: boolean | null;
+    _prerenderedPageContexts: PrerenderedPageContexts;
+};
 type Output<PageContext = PageContextPrerendered> = {
     filePath: string;
     fileType: FileType;
@@ -23,6 +36,9 @@ type Output<PageContext = PageContextPrerendered> = {
     pageContext: PageContext;
 }[];
 type FileType = 'HTML' | 'JSON';
+type PageContext = Awaited<ReturnType<typeof createPageContextPrerendering>> & {
+    _urlOriginalBeforeHook?: string;
+};
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -50,8 +66,301 @@ declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
 declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
     forceExit: boolean;
 }>;
+declare function createPageContextPrerendering(urlOriginal: string, prerenderContext: PrerenderContext, globalContext: GlobalContextServerInternal, globalContext_public: GlobalContextServer, is404: boolean, pageId: string | undefined, providedByHook: ProvidedByHook): Promise<((({
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
+    _baseServer: string;
+    _baseAssets: string;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    urlParsed: import("../shared/utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
+} & {
+    _urlHandler: null;
+    _httpRequestId: null;
+    _urlRewrite: null;
+    _noExtraDir: boolean | null;
+    _prerenderContext: PrerenderContext;
+    _providedByHook: ProvidedByHook;
+    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
+    is404: boolean;
+} & import("../../shared/route/index.js").PageContextFromRoute & Record<"pageId", string>) | ({
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
+    _baseServer: string;
+    _baseAssets: string;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    urlParsed: import("../shared/utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
+} & {
+    _urlHandler: null;
+    _httpRequestId: null;
+    _urlRewrite: null;
+    _noExtraDir: boolean | null;
+    _prerenderContext: PrerenderContext;
+    _providedByHook: ProvidedByHook;
+    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
+    is404: boolean;
+} & {
+    pageId: string;
+    _debugRouteMatches: never[];
+    routeParams: {};
+})) & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
+    Page: unknown;
+    _isHtmlOnly: boolean;
+    _passToClient: string[];
+    _pageFilePathsLoaded: string[];
+} & {
+    __getPageAssets: () => Promise<import("../runtime/renderPage/getPageAssets.js").PageAsset[]>;
+}) & {
+    _usesClientRouter: boolean;
+}>;
 declare function runPrerender_forceExit(): void;
-type PrerenderContextPublic = {
-    output: Output<PageContextServer>;
-    pageContexts: PageContextServer[];
-};
+type PrerenderContextPublic = Pick<PrerenderContext, 'output' | 'pageContexts'>;

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

@@ -4,11 +4,12 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 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, makePublicCopy, PROJECT_VERSION, preservePropertyGetters } from './utils.js';
-import { prerenderPage, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, onSetupPrerender, getPublicProxy, PROJECT_VERSION, preservePropertyGetters } 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 { getGlobalContextInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
+import { getGlobalContextServerInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
@@ -29,7 +30,7 @@ import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './res
 import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
-import { getVikeConfigPublic } from '../plugin/plugins/commonConfig.js';
+import { getVikeConfigInternal } from '../plugin/plugins/commonConfig.js';
 import fs from 'node:fs';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
@@ -76,7 +77,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
-    const vike = getVikeConfigPublic(viteConfig);
+    const vike = getVikeConfigInternal(viteConfig);
     const { outDirClient, outDirServer } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
@@ -93,26 +94,26 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
-    const globalContext = await getGlobalContextInternal();
-    globalContext.pageFilesAll.forEach(assertExportNames);
+    const { globalContext, globalContext_public } = await getGlobalContextServerInternal();
+    globalContext._pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {
-        noExtraDir,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null,
-        prerenderedPageContexts: {},
-        output: []
+        output: [],
+        _noExtraDir: noExtraDir,
+        _pageContextInit: options.pageContextInit ?? null,
+        _prerenderedPageContexts: {}
     };
     const doNotPrerenderList = [];
     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);
+    await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, globalContext_public, concurrencyLimit, doNotPrerenderList);
     // Create `pageContext` for each page with a static route
     const urlList = getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList);
-    await createPageContextsForOnPrerenderStartHook(urlList, prerenderContext, globalContext, concurrencyLimit, false);
+    await createPageContexts(urlList, prerenderContext, globalContext, globalContext_public, concurrencyLimit, false);
     // Create `pageContext` for 404 page
     const urlList404 = getUrlList404(globalContext);
-    await createPageContextsForOnPrerenderStartHook(urlList404, prerenderContext, globalContext, concurrencyLimit, true);
+    await createPageContexts(urlList404, prerenderContext, globalContext, globalContext_public, concurrencyLimit, true);
     // Allow user to duplicate the list of `pageContext` for i18n
     // https://vike.dev/onPrerenderStart
     await callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit);
@@ -122,15 +123,15 @@ async function runPrerender(options = {}, standaloneTrigger) {
         prerenderedCount++;
         const { pageId } = htmlFile.pageContext;
         assert(pageId);
-        prerenderContext.prerenderedPageContexts[pageId] = htmlFile.pageContext;
+        prerenderContext._prerenderedPageContexts[pageId] = htmlFile.pageContext;
         await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
     await prerenderPages(prerenderContext, concurrencyLimit, onComplete);
-    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    warnContradictoryNoPrerenderList(prerenderContext._prerenderedPageContexts, doNotPrerenderList);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
+    await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
     objectAssign(vike.prerenderContext, prerenderContextPublic);
     if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
@@ -157,7 +158,7 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, default
     });
     // Old design
     // TODO/v1-release: remove
-    await Promise.all(globalContext.pageFilesAll
+    await Promise.all(globalContext._pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('doNotPrerender'))
@@ -169,8 +170,8 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, default
         assert(p.loadFile);
         await p.loadFile();
     })));
-    globalContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = getPageFilesServerSide(globalContext.pageFilesAll, pageId);
+    globalContext._allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = getPageFilesServerSide(globalContext._pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -194,10 +195,10 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, globalContext_public, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
     // V1 design
-    await Promise.all(globalContext.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);
@@ -213,7 +214,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         });
     })));
     // 0.4 design
-    await Promise.all(globalContext.pageFilesAll
+    await Promise.all(globalContext._pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('prerender'))
@@ -257,7 +258,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             }
             // Add result
             const providedByHook = { hookFilePath, hookName };
-            const pageContextNew = await createPageContext(url, prerenderContext, globalContext, false, undefined, providedByHook);
+            const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, globalContext_public, false, undefined, providedByHook);
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
                 objectAssign(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
@@ -268,7 +269,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
 }
 function getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList) {
     const urlList = [];
-    globalContext.pageRoutes.map((pageRoute) => {
+    globalContext._pageRoutes.map((pageRoute) => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
@@ -293,7 +294,7 @@ function getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList) {
 }
 function getUrlList404(globalContext) {
     const urlList = [];
-    const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
+    const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
     if (errorPageId) {
         urlList.push({
             // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
@@ -303,28 +304,30 @@ function getUrlList404(globalContext) {
     }
     return urlList;
 }
-async function createPageContextsForOnPrerenderStartHook(urlList, prerenderContext, globalContext, concurrencyLimit, is404) {
+async function createPageContexts(urlList, prerenderContext, globalContext, globalContext_public, concurrencyLimit, is404) {
     await Promise.all(urlList.map(({ urlOriginal, pageId }) => concurrencyLimit(async () => {
         // Already included in a onBeforePrerenderStart() hook
         if (prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, urlOriginal))) {
             return;
         }
-        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
+        const pageContext = await createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, globalContext_public, is404, pageId, null);
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-async function createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
+async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, globalContext_public, is404, pageId, providedByHook) {
     const pageContextInit = {
         urlOriginal,
-        ...prerenderContext.pageContextInit
+        ...prerenderContext._pageContextInit
     };
-    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    const pageContext = await createPageContextServerSide(pageContextInit, globalContext, globalContext_public, {
+        isPrerendering: true
+    });
     assert(pageContext.isPrerendering === true);
     objectAssign(pageContext, {
         _urlHandler: null,
         _httpRequestId: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext.noExtraDir,
+        _noExtraDir: prerenderContext._noExtraDir,
         _prerenderContext: prerenderContext,
         _providedByHook: providedByHook,
         _urlOriginalModifiedByHook: null,
@@ -350,14 +353,14 @@ async function createPageContext(urlOriginal, prerenderContext, globalContext, i
     {
         const { pageId } = pageContext;
         assert(pageId);
-        assert(globalContext.isPrerendering);
-        if (globalContext.pageConfigs.length > 0) {
-            const pageConfig = globalContext.pageConfigs.find((p) => p.pageId === pageId);
+        assert(globalContext._isPrerendering);
+        if (globalContext._pageConfigs.length > 0) {
+            const pageConfig = globalContext._pageConfigs.find((p) => p.pageId === pageId);
             assert(pageConfig);
             usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
         }
         else {
-            usesClientRouter = globalContext.usesClientRouter;
+            usesClientRouter = globalContext._usesClientRouter;
         }
     }
     objectAssign(pageContext, { _usesClientRouter: usesClientRouter });
@@ -394,9 +397,9 @@ function assertRouteMatch(pageContextFromRoute, pageContext) {
 async function callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit) {
     let onPrerenderStartHook;
     // V1 design
-    if (globalContext.pageConfigs.length > 0) {
+    if (globalContext._pageConfigs.length > 0) {
         const hookName = 'onPrerenderStart';
-        const hook = getHookFromPageConfigGlobal(globalContext.pageConfigGlobal, hookName);
+        const hook = getHookFromPageConfigGlobal(globalContext._pageConfigGlobal, hookName);
         if (hook) {
             assert(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -408,9 +411,9 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
     }
     // Old design
     // TODO/v1-release: remove
-    if (globalContext.pageConfigs.length === 0) {
+    if (globalContext._pageConfigs.length === 0) {
         const hookTimeout = getHookTimeoutDefault('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext._pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -550,7 +553,7 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext.noExtraDir ?? pageContext.is404
+            doNotCreateExtraDirectory: prerenderContext._noExtraDir ?? pageContext.is404
         });
     })));
 }
@@ -567,16 +570,16 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
     });
 }
 async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPrerenderList, partial) {
-    const isV1 = globalContext.pageConfigs.length > 0;
+    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`
     */
-    globalContext.allPageIds
+    globalContext._allPageIds
         .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
-        .filter((pageId) => !isErrorPage(pageId, globalContext.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 });
@@ -729,7 +732,7 @@ function assertIsNotAbort(err, urlOriginal) {
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOriginal} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
 function makePublic(prerenderContext) {
-    const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
+    const prerenderContextPublic = getPublicProxy(prerenderContext, 'prerenderContext', [
         'output', // vite-plugin-vercel
         'pageContexts' // https://vike.dev/i18n#pre-rendering
     ]);

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

@@ -13,6 +13,6 @@ export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
-export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/getPublicProxy.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/preservePropertyGetters.js';

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

@@ -15,6 +15,6 @@ export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
-export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/getPublicProxy.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/preservePropertyGetters.js';