vike 0.4.228 → 0.4.229-commit-a19745d

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);

package/dist/cjs/node/runtime/globalContext.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalContext = getGlobalContext;
 exports.getGlobalContextSync = getGlobalContextSync;
 exports.getGlobalContextAsync = getGlobalContextAsync;
-exports.getGlobalContextInternal = getGlobalContextInternal;
+exports.getGlobalContextServerInternal = getGlobalContextServerInternal;
 exports.getViteDevServer = getViteDevServer;
 exports.getViteConfig = getViteConfig;
 exports.initGlobalContext_renderPage = initGlobalContext_renderPage;
@@ -21,32 +21,36 @@ exports.clearGlobalContext = clearGlobalContext;
 exports.assertBuildInfo = assertBuildInfo;
 exports.updateUserFiles = updateUserFiles;
 // The core logic revolves around:
-// - globalObject.userFiles which is the main requirement for resolveGlobalContext()
+// - virtualFileExports is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
-//   - loadBuildEntry() sets globalObject.buildEntry and then sets globalObject.userFiles
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExports
 //   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
-//   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
 const utils_js_1 = require("./utils.js");
 const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
 const virtualFileImportUserCode_js_1 = require("../shared/virtual-files/virtualFileImportUserCode.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
-const getPageConfigsRuntime_js_1 = require("../../shared/getPageConfigsRuntime.js");
 const resolveBase_js_1 = require("../shared/resolveBase.js");
+const createGlobalContextShared_js_1 = require("../../shared/createGlobalContextShared.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/globalContext.ts', getInitialGlobalContext());
-async function getGlobalContextInternal() {
-    // getGlobalContextInternal() should always be called after initGlobalContext()
+// Trick to break down TypeScript circular dependency
+// https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
+const globalObjectTyped = globalObject;
+async function getGlobalContextServerInternal() {
+    // getGlobalContextServerInternal() should always be called after initGlobalContext()
     (0, utils_js_1.assert)(globalObject.isInitialized);
     assertGlobalContextIsDefined();
     if (globalObject.isProduction !== true)
         await globalObject.waitForUserFilesUpdate;
-    const { globalContext } = globalObject;
+    const { globalContext, globalContext_public } = globalObjectTyped;
     assertIsDefined(globalContext);
-    return globalContext;
+    (0, utils_js_1.assert)(globalContext_public);
+    return { globalContext, globalContext_public };
 }
 function assertIsDefined(globalContext) {
     if (!globalContext) {
@@ -56,9 +60,11 @@ function assertIsDefined(globalContext) {
     }
 }
 function assertGlobalContextIsDefined() {
-    assertIsDefined(globalObject.globalContext);
+    assertIsDefined(globalObjectTyped.globalContext);
+    (0, utils_js_1.assert)(globalObject.globalContext);
     (0, utils_js_1.assert)(globalObject.globalContext_public);
 }
+// We purposely return GlobalContext instead of GlobalContextServer because `import { getGlobalContext } from 'vike'` can resolve to the client-side implementation.
 /**
  * Get runtime information about your app.
  *
@@ -86,7 +92,7 @@ async function getGlobalContextAsync(isProduction) {
     if (!isProduction)
         await globalObject.waitForUserFilesUpdate;
     assertGlobalContextIsDefined();
-    const { globalContext_public } = globalObject;
+    const { globalContext_public } = globalObjectTyped;
     (0, utils_js_1.assert)(globalContext_public);
     return globalContext_public;
 }
@@ -99,24 +105,25 @@ async function getGlobalContextAsync(isProduction) {
  */
 function getGlobalContextSync() {
     debug('getGlobalContextSync()');
-    const { globalContext_public } = globalObject;
-    (0, utils_js_1.assertUsage)(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.");
+    const { globalContext_public } = globalObjectTyped;
+    (0, utils_js_1.assertUsage)(globalContext_public, createGlobalContextShared_js_1.getGlobalContextSyncErrMsg);
     (0, utils_js_1.assertWarning)(false, 
-    // We discourage users from using it because using `pageContext.globalContext` is better: it doesn't have the race condition issue that `getGlobalContextSync()` would have when called inside React/Vue components.
+    // We discourage users from using it because `pageContext.globalContext` is safer: I ain't sure but there could be race conditions when using `getGlobalContextSync()` inside React/Vue components upon HMR.
     // We're lying about "is going to be deprecated in the next major release": let's keep it and see if users need it (so far I can't see a use case for it).
     'getGlobalContextSync() is going to be deprecated in the next major release, see https://vike.dev/getGlobalContext', { onlyOnce: true });
     return globalContext_public;
 }
 function makePublic(globalContext) {
-    const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', [
+    const globalContextPublic = (0, utils_js_1.getPublicProxy)(globalContext, 'globalContext', [
         'assetsManifest',
         'config',
         'viteConfig',
         'viteConfigRuntime',
         'pages',
         'baseServer',
-        'baseAssets'
-    ]);
+        'baseAssets',
+        'isClientSide'
+    ], true);
     return globalContextPublic;
 }
 async function setGlobalContext_viteDevServer(viteDevServer) {
@@ -224,96 +231,6 @@ function setIsProduction(isProduction) {
         (0, utils_js_1.assert)(globalObject.isProduction === isProduction);
     globalObject.isProduction = isProduction;
 }
-function defineGlobalContext() {
-    const globalContext = resolveGlobalContext();
-    assertIsDefined(globalContext);
-    const globalContext_public = makePublic(globalContext);
-    (0, utils_js_1.objectAssign)(globalContext, { globalContext_public });
-    globalObject.globalContext = globalContext;
-    globalObject.globalContext_public = globalContext_public;
-    assertGlobalContextIsDefined();
-    (0, utils_js_1.onSetupRuntime)();
-}
-function resolveGlobalContext() {
-    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction, userFiles } = globalObject;
-    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
-    let globalContext;
-    if (!isProduction) {
-        // Requires globalObject.viteDevServer
-        if (!viteDevServer)
-            return null;
-        (0, utils_js_1.assert)(userFiles); // main common requiement
-        (0, utils_js_1.assert)(viteConfig);
-        (0, utils_js_1.assert)(viteConfigRuntime);
-        (0, utils_js_1.assert)(!isPrerendering);
-        globalContext = {
-            isProduction: false,
-            isPrerendering: false,
-            assetsManifest: null,
-            viteDevServer,
-            viteConfig,
-            ...userFiles,
-            viteConfigRuntime,
-            ...resolveBaseRuntime(viteConfigRuntime, userFiles.config)
-        };
-    }
-    else {
-        // Requires globalObject.buildEntry
-        if (!globalObject.buildEntry)
-            return null;
-        (0, utils_js_1.assert)(userFiles); // main common requiement
-        const { buildInfo, assetsManifest } = globalObject;
-        (0, utils_js_1.assert)(buildInfo);
-        (0, utils_js_1.assert)(assetsManifest);
-        const globalContext_ = {
-            isProduction: true,
-            assetsManifest,
-            ...userFiles,
-            viteDevServer: null,
-            viteConfigRuntime: buildInfo.viteConfigRuntime,
-            usesClientRouter: buildInfo.usesClientRouter,
-            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, userFiles.config)
-        };
-        if (isPrerendering) {
-            (0, utils_js_1.assert)(viteConfig);
-            (0, utils_js_1.objectAssign)(globalContext_, {
-                isPrerendering: true,
-                viteConfig
-            });
-            globalContext = globalContext_;
-        }
-        else {
-            (0, utils_js_1.objectAssign)(globalContext_, {
-                isPrerendering: false,
-                viteConfig: null
-            });
-            globalContext = globalContext_;
-        }
-    }
-    return globalContext;
-}
-async function getUserFiles() {
-    // Help TypeScript resolve what TypeScript (wrongfully) believes to be cyclic dependency
-    const globalObject_ = globalObject;
-    const { pageConfigsRuntime } = globalObject_;
-    (0, utils_js_1.assert)(pageConfigsRuntime);
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = pageConfigsRuntime;
-    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    const userFiles = {
-        pageFilesAll,
-        pageConfigs,
-        pageConfigGlobal,
-        allPageIds,
-        pageRoutes,
-        onBeforeRouteHook,
-        pages: pageConfigsUserFriendly,
-        config: globalConfig.config
-    };
-    (0, assertV1Design_js_1.assertV1Design)(
-    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
-    pageConfigs.length > 0, pageFilesAll);
-    return userFiles;
-}
 function assertViteManifest(manifest) {
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -329,10 +246,7 @@ function assertViteManifest(manifest) {
 }
 async function loadBuildEntry(outDir) {
     debug('loadBuildEntry()');
-    if (globalObject.userFiles) {
-        (0, utils_js_1.assert)(globalObject.buildInfo);
-        (0, utils_js_1.assert)(globalObject.assetsManifest);
-        (0, utils_js_1.assert)(globalObject.buildEntry);
+    if (globalObject.globalContext) {
         return;
     }
     if (!globalObject.buildEntry) {
@@ -345,20 +259,18 @@ async function loadBuildEntry(outDir) {
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         (0, utils_js_1.assert)(globalObject.buildEntry);
+        // If using `inject` then dist/server/index.js imports dist/server/entry.js and loadBuildEntry() isn't needed.
+        // If dist/server/entry.js isn't imported then this means the user is running the original server entry `$ ts-node server/index.ts`.
         (0, utils_js_1.assertWarning)(
-        // vike-server => `vitePluginServerEntry.inject === true`
-        // vike-node => `vitePluginServerEntry.inject === [ 'index' ]`
-        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true, 
-        /* TO-DO/eventually:
-        !!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject,
-        */
-        `Run the built server entry (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
+        // vike-server => `inject === true`
+        // vike-node => `inject === [ 'index' ]` => we don't show the warning to vike-node users (I don't remember why).
+        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true || globalObject.isPrerendering, `Run the built server entry (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await setUserFiles(buildEntry.virtualFileExports);
+    await setGlobalContext(buildEntry.virtualFileExports);
 }
 async function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
@@ -418,15 +330,80 @@ async function updateUserFiles() {
     // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
     if (viteDevServer !== globalObject.viteDevServer)
         return;
-    await setUserFiles(virtualFileExports);
+    await setGlobalContext(virtualFileExports);
     resolve();
 }
-async function setUserFiles(virtualFileExports) {
-    globalObject.pageConfigsRuntime = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
-    const userFiles = await getUserFiles();
-    globalObject.userFiles = userFiles;
-    defineGlobalContext();
+async function setGlobalContext(virtualFileExports) {
+    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContext);
+    (0, assertV1Design_js_1.assertV1Design)(
+    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
+    globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
+    // Public usage
+    globalObject.globalContext_public = makePublic(globalContext);
     assertGlobalContextIsDefined();
+    (0, utils_js_1.onSetupRuntime)();
+    // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
+    return globalContext;
+}
+async function addGlobalContext(globalContext) {
+    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    const globalContextBase = {
+        isClientSide: false,
+        _pageRoutes: pageRoutes,
+        _onBeforeRouteHook: onBeforeRouteHook
+    };
+    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
+    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
+    if (!isProduction) {
+        (0, utils_js_1.assert)(viteDevServer);
+        (0, utils_js_1.assert)(globalContext); // main common requirement
+        (0, utils_js_1.assert)(viteConfig);
+        (0, utils_js_1.assert)(viteConfigRuntime);
+        (0, utils_js_1.assert)(!isPrerendering);
+        return {
+            ...globalContext,
+            ...globalContextBase,
+            ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+            _isProduction: false,
+            _isPrerendering: false,
+            assetsManifest: null,
+            _viteDevServer: viteDevServer,
+            viteConfig,
+            viteConfigRuntime
+        };
+    }
+    else {
+        (0, utils_js_1.assert)(globalObject.buildEntry);
+        (0, utils_js_1.assert)(globalContext); // main common requiement
+        const { buildInfo, assetsManifest } = globalObject;
+        (0, utils_js_1.assert)(buildInfo);
+        (0, utils_js_1.assert)(assetsManifest);
+        const globalContextBase2 = {
+            ...globalContext,
+            ...globalContextBase,
+            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, globalContext.config),
+            _isProduction: true,
+            assetsManifest,
+            _viteDevServer: null,
+            viteConfigRuntime: buildInfo.viteConfigRuntime,
+            _usesClientRouter: buildInfo.usesClientRouter
+        };
+        if (isPrerendering) {
+            (0, utils_js_1.assert)(viteConfig);
+            return {
+                ...globalContextBase2,
+                _isPrerendering: true,
+                viteConfig
+            };
+        }
+        else {
+            return {
+                ...globalContextBase2,
+                _isPrerendering: false,
+                viteConfig: null
+            };
+        }
+    }
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');