vike 0.4.228 → 0.4.229

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolvePointerImport.js

@@ -7,13 +7,12 @@ exports.resolvePointerImport = resolvePointerImport;
 exports.resolvePointerImportData = resolvePointerImportData;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../../../../utils.js");
-const transformPointerImports_js_1 = require("./transformPointerImports.js");
-const path_1 = __importDefault(require("path"));
+const pointerImports_js_1 = require("./pointerImports.js");
 const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 function resolvePointerImport(configValue, importerFilePath, userRootDir, configName) {
     if (typeof configValue !== 'string')
         return null;
-    const pointerImportData = (0, transformPointerImports_js_1.parsePointerImportData)(configValue);
+    const pointerImportData = (0, pointerImports_js_1.parsePointerImportData)(configValue);
     if (!pointerImportData)
         return null;
     const { exportName } = pointerImportData;
@@ -27,24 +26,18 @@ function resolvePointerImport(configValue, importerFilePath, userRootDir, config
     return { fileExportPath };
 }
 function resolvePointerImportData(pointerImportData, importerFilePath, userRootDir) {
-    // `importPath` should be one of the following:
-    // - A relative import path
-    // - A filesystem absolute path
-    // - An npm package import
     const { importPath } = pointerImportData;
-    const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath);
+    (0, pointerImports_js_1.assertPointerImportPath)(importPath);
+    const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath, userRootDir);
     let filePath;
     (0, utils_js_1.assertPosixPath)(importPath);
-    if (importPath.startsWith('.') || (0, utils_js_1.isFilePathAbsolute)(importPath)) {
-        if (importPath.startsWith('.')) {
-            (0, utils_js_1.assertUsage)((0, utils_js_1.pathIsRelative)(importPath), `Invalid relative import path ${picocolors_1.default.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${picocolors_1.default.code('./')} or ${picocolors_1.default.code('../')}, or use an npm package import instead.`);
-        }
+    if ((0, utils_js_1.isImportPathRelative)(importPath) || (0, utils_js_1.isFilePathAbsolute)(importPath)) {
         // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
         assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
         // Pointer imports are included in virtual files, and we need filePathAbsoluteUserRootDir because we didn't find a way to have filesystem absolute import paths in virtual files: https://gist.github.com/brillout/2315231c9a8164f950c64b4b4a7bbd39
         const errSuffix = `outside of the ${userRootDir} directory which is forbidden: make sure your import paths resolve inside the ${userRootDir} directory, or import from an npm package.`;
         const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({ filePathAbsoluteFilesystem, userRootDir });
-        if (importPath.startsWith('.')) {
+        if ((0, utils_js_1.isImportPathRelative)(importPath)) {
             (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `The relative import ${picocolors_1.default.cyan(importPath)} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} ${errSuffix}`);
         }
         else {
@@ -56,6 +49,7 @@ function resolvePointerImportData(pointerImportData, importerFilePath, userRootD
         filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
+        (0, utils_js_1.assert)((0, utils_js_1.isImportPathNpmPackageOrPathAlias)(importPath));
         const importPathAbsolute = importPath;
         if (filePathAbsoluteFilesystem) {
             filePath = (0, getFilePath_js_1.getFilePathResolved)({
@@ -73,12 +67,20 @@ function resolvePointerImportData(pointerImportData, importerFilePath, userRootD
     }
     return filePath;
 }
-function resolveImportPathWithNode(pointerImportData, importerFilePath) {
+function resolveImportPathWithNode(pointerImportData, importerFilePath, userRootDir) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
-    const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
-    // filePathAbsoluteFilesystem is expected to be null when pointerImportData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolveOptional)(pointerImportData.importPath, cwd);
+    // filePathAbsoluteFilesystem is null when pointerImportData.importPath is a path alias that Node.js doesn't know about
+    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolveOptional)({
+        importPath: pointerImportData.importPath,
+        importerFilePath: importerFilePathAbsolute,
+        userRootDir
+    });
+    if (!filePathAbsoluteFilesystem) {
+        (0, utils_js_1.assert)(!(0, utils_js_1.isImportPathRelative)(pointerImportData.importPath));
+        // Libraries don't use path aliases => filePathAbsoluteFilesystem should be defined
+        (0, utils_js_1.assert)(!importerFilePathAbsolute.includes('node_modules'));
+    }
     return filePathAbsoluteFilesystem;
 }
 function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
@@ -90,8 +92,7 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
             : `The import ${picocolors_1.default.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            (0, utils_js_1.assert)((0, utils_js_1.pathIsRelative)(importPath));
+        if ((0, utils_js_1.isImportPathRelative)(importPath)) {
             (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
         }
         else {

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js

@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const import_1 = require("@brillout/import");
 const utils_js_1 = require("../../../../utils.js");
-const transformPointerImports_js_1 = require("./transformPointerImports.js");
+const pointerImports_js_1 = require("./pointerImports.js");
 const source_map_support_1 = __importDefault(require("source-map-support"));
 const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
@@ -61,7 +61,7 @@ async function transpileFile(filePath, transformImports, userRootDir, esbuildCac
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
-        const codeMod = (0, transformPointerImports_js_1.transformPointerImports)(code, filePathToShowToUserResolved, pointerImports);
+        const codeMod = (0, pointerImports_js_1.transformPointerImports)(code, filePathToShowToUserResolved, pointerImports);
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
@@ -126,7 +126,11 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     // - Sitll required for esbuild@0.24.0 (November 2024).
                     // - Let's try to remove this workaround again later.
                     if (resolved.errors.length > 0) {
-                        const resolvedWithNode = (0, utils_js_1.requireResolveOptional)(path, args.resolveDir);
+                        const resolvedWithNode = (0, utils_js_1.requireResolveOptionalDir)({
+                            importPath: path,
+                            importerDir: (0, utils_js_1.toPosixPath)(args.resolveDir),
+                            userRootDir
+                        });
                         if (debugEsbuildResolve.isActivated)
                             debugEsbuildResolve('resolvedWithNode', resolvedWithNode);
                         if (resolvedWithNode)
@@ -146,8 +150,8 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
                     // - Enabling us to use:
-                    //   - assertIsNpmPackageImport()
-                    //   - isNpmPackageImport(str, { cannotBePathAlias: true })
+                    //   - assertIsImportPathNpmPackage()
+                    //   - isImportPathNpmPackage(str, { cannotBePathAlias: true })
                     (0, utils_js_1.assertFilePathAbsoluteFilesystem)(importPathResolved);
                     //  Should be remove this? See comment below.
                     const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
@@ -165,7 +169,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const isNpmPkgImport = (() => {
                         if (importPathResolved.includes('/node_modules/')) {
                             // So far I can't think of a use case where this assertion would fail, but let's eventually remove it to avoid artificially restricting the user.
-                            (0, utils_js_1.assert)((0, utils_js_1.isNpmPackageImport_unreliable)(importPathOriginal));
+                            (0, utils_js_1.assert)((0, utils_js_1.isImportPathNpmPackageOrPathAlias)(importPathOriginal));
                             return true;
                         }
                         // Linked npm packages
@@ -174,7 +178,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         // - This isn't always the case: https://github.com/vikejs/vike/issues/2326
                         !importPathResolved.startsWith(userRootDir) &&
                             // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
-                            (0, utils_js_1.isNpmPackageImport_unreliable)(importPathOriginal)) {
+                            (0, utils_js_1.isImportPathNpmPackageOrPathAlias)(importPathOriginal)) {
                             return true;
                         }
                         return false;
@@ -191,7 +195,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     }
                     let importPathTranspiled;
                     (0, utils_js_1.assertPosixPath)(importPathOriginal);
-                    if (importPathOriginal.startsWith('./') || importPathOriginal.startsWith('../')) {
+                    if ((0, utils_js_1.isImportPathRelative)(importPathOriginal)) {
                         importPathTranspiled = importPathResolved;
                     }
                     else {
@@ -208,12 +212,11 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                             //   - Vike doesn't resolve path aliases at all.
                             //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
                             // - Esbuild path alias resolution seems reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
-                            (0, utils_js_1.assert)(!(0, utils_js_1.isNpmPackageImport_unreliable)(importPathOriginal));
                             importPathTranspiled = importPathResolved;
                         }
                         else {
                             // `importPathOriginal` is most likely an npm package import.
-                            (0, utils_js_1.assertIsNpmPackageImport)(importPathOriginal);
+                            (0, utils_js_1.assertIsImportPathNpmPackage)(importPathOriginal);
                             // For improved error messages, let the resolution be handled by Vike or Node.js.
                             importPathTranspiled = importPathOriginal;
                         }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -75,7 +75,7 @@ async function handleReloadSideEffects() {
         }
     }
 }
-// TODO/soon: predominantly use getVikeConfigPublic() instead of getVikeConfig() then maybe refector?
+// TODO/soon: predominantly use getVikeConfigInternal() instead of getVikeConfig() then maybe refector?
 async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     const userRootDir = config.root;
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
@@ -410,7 +410,7 @@ function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
         Object.entries(configValues).forEach(([configName, value]) => {
             var _a;
             const sourceName = `The ${(0, getConfigDefinedAt_js_1.getDefinedByString)(definedBy, configName)}`;
-            assertKnownConfig(configName, configDefinitionsResolved.configNamesKnownGlobal, configDefinitionsResolved, '/', sourceName, exitOnError);
+            assertKnownConfig(configName, configDefinitionsResolved.configNamesKnownGlobal, configDefinitionsResolved, '/', false, sourceName, exitOnError);
             const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
             sources.unshift(getSourceNonConfigFile(configName, value, definedBy));
         });
@@ -682,15 +682,12 @@ function resolveIsGlobalValue(configDefGlobal, source, plusFilesAll) {
     return isGlobal;
 }
 function getConfigNamesSetByPlusFile(plusFile) {
-    let configNames = [];
     if (!plusFile.isConfigFile) {
-        configNames.push(plusFile.configName);
+        return [plusFile.configName];
     }
-    if (!plusFile.isNotLoaded) {
-        configNames.push(...Object.keys(plusFile.fileExportsByConfigName));
+    else {
+        return Object.keys(plusFile.fileExportsByConfigName);
     }
-    configNames = (0, utils_js_1.unique)(configNames);
-    return configNames;
 }
 function getConfigDefinitions(plusFilesRelevant, filter) {
     let configDefinitions = { ...configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn };
@@ -885,12 +882,12 @@ function assertKnownConfigs(configDefinitionsResolved) {
             configNames.forEach((configName) => {
                 const { locationId } = plusFile;
                 const sourceName = plusFile.filePath.filePathToShowToUser;
-                assertKnownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, sourceName, false);
+                assertKnownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, true, sourceName, false);
             });
         });
     });
 }
-function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, sourceName, exitOnError) {
+function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, isPlusFile, sourceName, exitOnError) {
     const { configNamesKnownAll } = configDefinitionsResolved;
     if (configNamesKnownRelevant.includes(configName)) {
         (0, utils_js_1.assert)(configNamesKnownAll.includes(configName));
@@ -901,7 +898,10 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
     if (configNamesKnownAll.includes(configName)) {
         (0, utils_js_1.assertUsage)(false, `${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${picocolors_1.default.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${picocolors_1.default.underline('https://vike.dev/config#inheritance')}`, { exitOnError });
     }
-    const errMsg = `${sourceName} sets an unknown Vike config, see ${picocolors_1.default.underline('https://vike.dev/cli')} for the list of CLI options.`;
+    const errMsg = isPlusFile
+        ? `${sourceName} sets an unknown config ${configNameColored}`
+        : `${sourceName} sets an unknown Vike config, see ${picocolors_1.default.underline('https://vike.dev/cli')} for the list of CLI options`;
+    (0, utils_js_1.assert)(errMsg.includes(configName));
     // Missing vike-{react,vue,solid} installation
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];

package/dist/cjs/node/plugin/shared/getFilePath.js

@@ -44,7 +44,7 @@ function getComputedProps(args) {
         const importPathAbsolute = args.importPathAbsolute ?? null;
         const { filePathAbsoluteUserRootDir } = args;
         if (importPathAbsolute)
-            (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
+            (0, utils_js_1.assertIsImportPathNpmPackage)(importPathAbsolute);
         return {
             importPathAbsolute,
             filePathAbsoluteUserRootDir,
@@ -58,7 +58,7 @@ function getComputedProps(args) {
 }
 function getComputedPropsImportPathAbsolute(args) {
     const { importPathAbsolute } = args;
-    (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
+    (0, utils_js_1.assertIsImportPathNpmPackage)(importPathAbsolute);
     return {
         filePathAbsoluteUserRootDir: null,
         importPathAbsolute,

package/dist/cjs/node/plugin/shared/resolveClientEntriesDev.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveClientEntriesDev = resolveClientEntriesDev;
 const utils_js_1 = require("../utils.js");
-// @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
 (0, utils_js_1.assertIsNotProductionRuntime)();
 async function resolveClientEntriesDev(clientEntry, viteDevServer) {
-    let root = viteDevServer.config.root;
-    (0, utils_js_1.assert)(root);
-    root = (0, utils_js_1.toPosixPath)(root);
+    let userRootDir = viteDevServer.config.root;
+    (0, utils_js_1.assert)(userRootDir);
+    userRootDir = (0, utils_js_1.toPosixPath)(userRootDir);
     // The `?import` suffix is needed for MDX to be transpiled:
     //   - Not transpiled: `/pages/markdown.page.mdx`
     //   - Transpiled: `/pages/markdown.page.mdx?import`
@@ -22,26 +20,16 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     (0, utils_js_1.assertPosixPath)(clientEntry);
     let filePath;
     if (clientEntry.startsWith('/')) {
-        filePath = (0, utils_js_1.pathJoin)(root, clientEntry);
+        filePath = (0, utils_js_1.pathJoin)(userRootDir, clientEntry);
     }
     else {
         if (clientEntry.startsWith('@@vike/')) {
             (0, utils_js_1.assert)(clientEntry.endsWith('.js'));
-            let filePath_;
-            // For Vitest (which doesn't resolve vike to its dist but to its source files)
-            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/shared/resolveClientEntriesDev.js
-            filePath_ = (0, utils_js_1.requireResolveOptionalNonUserFile)(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts'), importMetaUrl);
-            if (!filePath_) {
-                // For users
-                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/shared/resolveClientEntriesDev.js
-                filePath_ = (0, utils_js_1.requireResolveOptionalNonUserFile)(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/'), importMetaUrl);
-            }
-            (0, utils_js_1.assert)(filePath_);
-            filePath = filePath_;
+            filePath = (0, utils_js_1.requireResolveVikeDistFile)(`dist/esm/${clientEntry.replace('@@vike/dist/esm/', '')}`);
         }
         else {
-            (0, utils_js_1.assertIsNpmPackageImport)(clientEntry);
-            filePath = (0, utils_js_1.requireResolve)(clientEntry, root);
+            (0, utils_js_1.assertIsImportPathNpmPackage)(clientEntry);
+            filePath = (0, utils_js_1.requireResolveNpmPackage)({ importPathNpmPackage: clientEntry, userRootDir });
         }
     }
     if (!filePath.startsWith('/')) {

package/dist/cjs/node/plugin/utils.js

@@ -46,3 +46,4 @@ __exportStar(require("../../utils/isEqualStringList.js"), exports);
 __exportStar(require("../../utils/isDocker.js"), exports);
 __exportStar(require("../../utils/isVitest.js"), exports);
 __exportStar(require("../../utils/rollupSourceMap.js"), exports);
+__exportStar(require("../../utils/isImportPath.js"), exports);

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

@@ -44,6 +44,7 @@ const path_1 = __importDefault(require("path"));
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
 const renderPageAlreadyRouted_js_1 = require("../runtime/renderPage/renderPageAlreadyRouted.js");
+const createPageContextServerSide_js_1 = require("../runtime/renderPage/createPageContextServerSide.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const os_1 = require("os");
 const globalContext_js_1 = require("../runtime/globalContext.js");
@@ -114,7 +115,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
-    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(viteConfig);
+    const vike = (0, commonConfig_js_1.getVikeConfigInternal)(viteConfig);
     const { outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
@@ -131,26 +132,26 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
-    const globalContext = await (0, globalContext_js_1.getGlobalContextInternal)();
-    globalContext.pageFilesAll.forEach(assertExportNames);
+    const { globalContext, globalContext_public } = await (0, globalContext_js_1.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);
@@ -160,15 +161,15 @@ async function runPrerender(options = {}, standaloneTrigger) {
         prerenderedCount++;
         const { pageId } = htmlFile.pageContext;
         (0, utils_js_1.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(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
+    await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
     (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic);
     if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
@@ -195,7 +196,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'))
@@ -207,8 +208,8 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, default
         (0, utils_js_1.assert)(p.loadFile);
         await p.loadFile();
     })));
-    globalContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(globalContext.pageFilesAll, pageId);
+    globalContext._allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(globalContext._pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -232,10 +233,10 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     (0, utils_js_1.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 (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
         const hook = (0, getHook_js_1.getHookFromPageConfig)(pageConfigLoaded, hookName);
@@ -251,7 +252,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'))
@@ -295,7 +296,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) {
                 (0, utils_js_1.objectAssign)(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
@@ -306,7 +307,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;
@@ -331,7 +332,7 @@ function getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList) {
 }
 function getUrlList404(globalContext) {
     const urlList = [];
-    const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
+    const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
     if (errorPageId) {
         urlList.push({
             // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
@@ -341,28 +342,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 (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, true);
+    const pageContext = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, globalContext_public, {
+        isPrerendering: true
+    });
     (0, utils_js_1.assert)(pageContext.isPrerendering === true);
     (0, utils_js_1.objectAssign)(pageContext, {
         _urlHandler: null,
         _httpRequestId: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext.noExtraDir,
+        _noExtraDir: prerenderContext._noExtraDir,
         _prerenderContext: prerenderContext,
         _providedByHook: providedByHook,
         _urlOriginalModifiedByHook: null,
@@ -388,14 +391,14 @@ async function createPageContext(urlOriginal, prerenderContext, globalContext, i
     {
         const { pageId } = pageContext;
         (0, utils_js_1.assert)(pageId);
-        (0, utils_js_1.assert)(globalContext.isPrerendering);
-        if (globalContext.pageConfigs.length > 0) {
-            const pageConfig = globalContext.pageConfigs.find((p) => p.pageId === pageId);
+        (0, utils_js_1.assert)(globalContext._isPrerendering);
+        if (globalContext._pageConfigs.length > 0) {
+            const pageConfig = globalContext._pageConfigs.find((p) => p.pageId === pageId);
             (0, utils_js_1.assert)(pageConfig);
             usesClientRouter = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
         }
         else {
-            usesClientRouter = globalContext.usesClientRouter;
+            usesClientRouter = globalContext._usesClientRouter;
         }
     }
     (0, utils_js_1.objectAssign)(pageContext, { _usesClientRouter: usesClientRouter });
@@ -432,9 +435,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 = (0, getHook_js_1.getHookFromPageConfigGlobal)(globalContext.pageConfigGlobal, hookName);
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(globalContext._pageConfigGlobal, hookName);
         if (hook) {
             (0, utils_js_1.assert)(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -446,9 +449,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 = (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext._pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -588,7 +591,7 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext.noExtraDir ?? pageContext.is404
+            doNotCreateExtraDirectory: prerenderContext._noExtraDir ?? pageContext.is404
         });
     })));
 }
@@ -605,16 +608,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) => !(0, error_page_js_1.isErrorPage)(pageId, globalContext.pageConfigs))
+        .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, globalContext._pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
         (0, utils_js_1.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 });
@@ -767,7 +770,7 @@ function assertIsNotAbort(err, urlOriginal) {
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOriginal} but ${picocolors_1.default.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
 function makePublic(prerenderContext) {
-    const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [
+    const prerenderContextPublic = (0, utils_js_1.getPublicProxy)(prerenderContext, 'prerenderContext', [
         'output', // vite-plugin-vercel
         'pageContexts' // https://vike.dev/i18n#pre-rendering
     ]);

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

@@ -31,6 +31,6 @@ __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
-__exportStar(require("../../utils/makePublicCopy.js"), exports);
+__exportStar(require("../../utils/getPublicProxy.js"), exports);
 __exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/preservePropertyGetters.js"), exports);