vike 0.4.218 → 0.4.220-commit-a9f46b8

package/dist/esm/node/runtime/globalContext.d.ts

@@ -12,40 +12,43 @@ export { setGlobalContext_viteConfig };
 export { setGlobalContext_vikeConfig };
 export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
+export { setGlobalContext_buildEntry };
+export { clearGlobalContext };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import { PluginManifest } from '../shared/assertPluginManifest.js';
-import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import type { ConfigUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 type GlobalContextPublic = {
     assetsManifest: null | ViteManifest;
 };
+type PageRuntimeInfo = Awaited<ReturnType<typeof getPageRuntimeInfo>>['userFiles'];
 type GlobalContext = {
     baseServer: string;
     baseAssets: null | string;
     includeAssetsImportedByServer: boolean;
-    redirects: Record<string, string>;
     trailingSlash: boolean;
     disableUrlNormalization: boolean;
-} & ({
+    vikeConfig: {
+        global: ConfigUserFriendly;
+    };
+} & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
-    vikeConfig: VikeConfigObject;
     viteDevServer: ViteDevServer;
     assetsManifest: null;
-    pluginManifest: null;
 } | ({
     isProduction: true;
     assetsManifest: ViteManifest;
-    pluginManifest: PluginManifest;
     viteDevServer: null;
 } & ({
     isPrerendering: false;
     viteConfig: null;
 } | {
     isPrerendering: true;
+    usesClientRouter: boolean;
     viteConfig: ResolvedConfig;
 })));
 declare function getGlobalContext(): GlobalContext;
@@ -63,4 +66,17 @@ declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext_renderPage(): Promise<void>;
 declare function initGlobalContext_runPrerender(): Promise<void>;
 declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
+declare function getPageRuntimeInfo(isProduction: boolean): Promise<{
+    userFiles: {
+        pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        pageConfigs: import("../../__internal/index.js").PageConfig[];
+        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;
+    };
+    globalConfig: ConfigUserFriendly;
+}>;
 declare function getRuntimeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): RuntimeManifest;
+declare function setGlobalContext_buildEntry(buildEntry: unknown): void;
+declare function clearGlobalContext(): void;

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

@@ -14,23 +14,26 @@ export { setGlobalContext_viteConfig };
 export { setGlobalContext_vikeConfig };
 export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
-import { assert, onSetupRuntime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
-import { loadImportBuild } from './globalContext/loadImportBuild.js';
-import { setPageFiles } from '../../shared/getPageFiles.js';
+export { setGlobalContext_buildEntry };
+export { clearGlobalContext };
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy } from './utils.js';
+import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
+import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
+import { getPageFilesAll, setPageFiles, setPageFilesAsync } from '../../shared/getPageFiles/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
-import { getPageFilesExports } from './page-files/getPageFilesExports.js';
 import { resolveBaseFromResolvedConfig } from '../shared/resolveBase.js';
-const globalObject = getGlobalObject('globalContext.ts', (() => {
-    const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
-    return {
-        viteDevServerPromise,
-        viteDevServerPromiseResolve
-    };
-})());
+import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
+import { assertV1Design } from '../shared/assertV1Design.js';
+const debug = createDebugger('vike:globalContext');
+const globalObject = getGlobalObject('globalContext.ts', getInitialGlobalContext());
+initDevEntry();
 function getGlobalContext() {
-    assert(globalObject.globalContext);
+    if (!globalObject.globalContext) {
+        debug('getGlobalContext()', new Error().stack);
+        assert(false);
+    }
     return globalObject.globalContext;
 }
 /** @experimental https://vike.dev/getGlobalContext */
@@ -47,27 +50,8 @@ async function getGlobalContextAsync(isProduction) {
     return makePublic(globalContext);
 }
 function makePublic(globalContext) {
-    const globalContextPublic = {
-        assetsManifest: globalContext.assetsManifest
-    };
-    // Add internals (and prepended _ prefix to their keys)
-    {
-        const publicKeys = Object.keys(globalContextPublic);
-        objectKeys(globalContext)
-            .filter((key) => !publicKeys.includes(key))
-            .forEach((key) => {
-            const keyPublic = `_${key}`;
-            Object.defineProperty(globalContextPublic, keyPublic, {
-                enumerable: true,
-                get() {
-                    assertWarning(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
-                        onlyOnce: true
-                    });
-                    return globalContext[key];
-                }
-            });
-        });
-    }
+    // TODO/now: add viteConfig and vikeConfig
+    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', ['assetsManifest']);
     return globalContextPublic;
 }
 function setGlobalContext_viteDevServer(viteDevServer) {
@@ -109,9 +93,11 @@ function getViteConfig() {
     return globalObject.viteConfig ?? null;
 }
 async function initGlobalContext_renderPage() {
+    debug('initGlobalContext_renderPage()');
     await initGlobalContext(!globalObject.isViteDev);
 }
 async function initGlobalContext_runPrerender() {
+    debug('initGlobalContext_runPrerender()');
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
     globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
@@ -125,6 +111,7 @@ async function initGlobalContext_runPrerender() {
     await initGlobalContext(true);
 }
 async function initGlobalContext_getGlobalContextAsync(isProduction) {
+    debug('initGlobalContext_getGlobalContextAsync()');
     if (!isProduction) {
         const waitFor = 20;
         const timeout = setTimeout(() => {
@@ -138,6 +125,7 @@ async function initGlobalContext_getGlobalContextAsync(isProduction) {
     }
     await initGlobalContext(isProduction);
 }
+// TODO/now: refactor: move this to the top of the file
 async function initGlobalContext(isProduction) {
     if (globalObject.globalContext) {
         assert(globalObject.globalContext.isProduction === isProduction);
@@ -152,41 +140,45 @@ async function initGlobalContext(isProduction) {
         assert(vikeConfig);
         assert(viteDevServer);
         assert(!isPrerendering);
-        const vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
-        const pluginManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
+        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
+        const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
             assetsManifest: null,
-            pluginManifest: null,
             viteDevServer,
             viteConfig,
-            vikeConfig,
+            vikeConfig: {
+                global: globalConfig
+            },
+            ...userFiles,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            redirects: pluginManifest.redirects,
             trailingSlash: pluginManifest.trailingSlash,
             disableUrlNormalization: pluginManifest.disableUrlNormalization
         };
     }
     else {
-        const buildEntries = await loadImportBuild(globalObject.outDirRoot);
-        assertBuildEntries(buildEntries, isPrerendering ?? false);
-        const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
-        setPageFiles(pageFiles);
+        const buildEntry = await getBuildEntry(globalObject.outDirRoot, isPrerendering);
+        const { assetsManifest, pluginManifest } = buildEntry;
+        setPageFiles(buildEntry.pageFiles);
+        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
         assertViteManifest(assetsManifest);
         assertPluginManifest(pluginManifest);
         const globalContext = {
             isProduction: true,
             assetsManifest,
-            pluginManifest,
+            vikeConfig: {
+                global: globalConfig
+            },
+            ...userFiles,
             viteDevServer: null,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            redirects: pluginManifest.redirects,
             trailingSlash: pluginManifest.trailingSlash,
+            usesClientRouter: pluginManifest.usesClientRouter,
             disableUrlNormalization: pluginManifest.disableUrlNormalization
         };
         if (isPrerendering) {
@@ -206,29 +198,35 @@ async function initGlobalContext(isProduction) {
         }
     }
 }
+async function getPageRuntimeInfo(isProduction) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = await getPageFilesAll(false, isProduction);
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    const userFiles = {
+        pageFilesAll,
+        pageConfigs,
+        pageConfigGlobal,
+        allPageIds,
+        pageRoutes,
+        onBeforeRouteHook
+    };
+    assertV1Design(
+    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
+    pageConfigs.length > 0, pageFilesAll);
+    return { userFiles, globalConfig };
+}
 function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
-    const { includeAssetsImportedByServer, redirects, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
+    const { includeAssetsImportedByServer, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
     const { baseServer, baseAssets } = resolveBaseFromResolvedConfig(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
     const manifest = {
         baseServer,
         baseAssets,
         includeAssetsImportedByServer,
-        redirects,
         trailingSlash,
         disableUrlNormalization
     };
     assertRuntimeManifest(manifest);
     return manifest;
 }
-function assertBuildEntries(buildEntries, isPreRendering) {
-    const errMsg = [
-        `You are tyring to run`,
-        isPreRendering ? 'pre-rendering' : 'the server for production',
-        `but your app isn't built yet. Run ${pc.cyan('$ vike build')} before `,
-        isPreRendering ? 'pre-rendering.' : 'running the server.'
-    ].join(' ');
-    assertUsage(buildEntries, errMsg);
-}
 function assertViteManifest(manifest) {
     assert(isPlainObject(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -247,3 +245,59 @@ function eagerlyLoadUserFiles() {
     // We call it as early as possible here for better performance.
     getPageFilesExports();
 }
+async function getBuildEntry(outDir, isPrerendering) {
+    debug('getBuildEntry()');
+    if (!globalObject.buildEntry) {
+        debug('importServerProductionEntry()');
+        // importServerProductionEntry() loads dist/server/entry.mjs which calls setGlobalContext_buildEntry()
+        await importServerProductionEntry({ outDir, doNotLoadServer: isPrerendering });
+        if (!globalObject.buildEntry) {
+            debug('globalObject.buildEntryPrevious');
+            // Needed, for example, when calling the API prerender() then preview() because both trigger a importServerProductionEntry() call but only the first only is applied because of the import() cache. (A proper implementation would be to clear the import() cache, but it probably isn't possible on platforms such as Cloudflare Workers.)
+            globalObject.buildEntry = globalObject.buildEntryPrevious;
+        }
+        assert(globalObject.buildEntry);
+    }
+    const { buildEntry } = globalObject;
+    assert(isObject(buildEntry));
+    assert(hasProp(buildEntry, 'pageFiles', 'object'));
+    assert(hasProp(buildEntry, 'assetsManifest', 'object'));
+    assert(hasProp(buildEntry, 'pluginManifest', 'object'));
+    return buildEntry;
+}
+function setGlobalContext_buildEntry(buildEntry) {
+    debug('setGlobalContext_buildEntry()');
+    globalObject.buildEntry = buildEntry;
+    globalObject.buildEntryPrevious = buildEntry;
+}
+function initDevEntry() {
+    setPageFilesAsync(getPageFilesExports);
+}
+async function getPageFilesExports() {
+    const viteDevServer = getViteDevServer();
+    assert(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    debugGlob('Glob result: ', moduleExports);
+    assert(isObject(moduleExports));
+    return moduleExports;
+}
+function clearGlobalContext() {
+    debug('clearGlobalContext()');
+    objectReplace(globalObject, getInitialGlobalContext(), ['buildEntryPrevious']);
+}
+function getInitialGlobalContext() {
+    debug('getInitialGlobalContext()');
+    const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
+    return {
+        viteDevServerPromise,
+        viteDevServerPromiseResolve
+    };
+}

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -5,7 +5,7 @@ import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
 import { getGlobalContext } from '../../globalContext.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';

package/dist/esm/node/runtime/index-common.d.ts

@@ -6,4 +6,3 @@ export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js'
 export { createDevMiddleware } from '../runtime-dev/index.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
-import './page-files/setup.js';

package/dist/esm/node/runtime/index-common.js

@@ -8,18 +8,3 @@ export { createDevMiddleware } from '../runtime-dev/index.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 // TODO/v1-release: remove
 export { createPageRenderer } from '../createPageRenderer.js';
-addEcosystemStamp();
-import './page-files/setup.js';
-// Used by:
-// - Telefunc (to detect the user's stack https://github.com/brillout/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
-function addEcosystemStamp() {
-    const g = globalThis;
-    g._isVikeApp =
-        /* Don't set to true so that consumers do `!!globalThis._isVikeApp` instead of `globalThis._isVikeApp === true`.
-        true
-        */
-        // We use an object so that we can eventually, in the future, add helpful information as needed. (E.g. the Vike version, or global settings.)
-        {};
-    // We keep the old stamp for older Telefunc versions
-    g._isVitePluginSsr = true;
-}

package/dist/esm/node/runtime/index-deprecated.d.ts

@@ -1,5 +1,6 @@
 export * from './index-common.js';
 export * from '../../types/index-dreprecated.js';
+import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js';
 /** @deprecated
  * Replace:
  *   ```

package/dist/esm/node/runtime/onLoad.js

@@ -1,13 +1,27 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
+import { setAlwaysShowStackTrace } from '../../utils/assert.js';
 import { installRequireShim } from '@brillout/require-shim';
-import { setAlwaysShowStackTrace } from './utils.js';
 import { isErrorDebug } from '../shared/isErrorDebug.js';
 function onLoad() {
     assertIsNotBrowser();
     assertNodeVersion();
-    installRequireShim();
     if (isErrorDebug())
         setAlwaysShowStackTrace();
+    addEcosystemStamp();
+    installRequireShim();
+}
+// Used by:
+// - Telefunc (to detect the user's stack https://github.com/brillout/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
+function addEcosystemStamp() {
+    const g = globalThis;
+    g._isVikeApp =
+        /* Don't set to true so that consumers do `!!globalThis._isVikeApp` instead of `globalThis._isVikeApp === true`.
+        true
+        */
+        // We use an object so that we can eventually, in the future, add helpful information as needed. (E.g. the Vike version, or global settings.)
+        {};
+    // We keep the old stamp for older Telefunc versions
+    g._isVitePluginSsr = true;
 }

package/dist/esm/node/runtime/page-files/setup.js

@@ -1,3 +1,3 @@
-import { setPageFilesAsync } from '../../../shared/getPageFiles.js';
-import { getPageFilesExports } from './getPageFilesExports.js';
-setPageFilesAsync(getPageFilesExports);
+export {};
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
+// This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

package/dist/esm/node/runtime/renderPage/analyzePage.js

@@ -4,7 +4,7 @@ import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageC
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getGlobalContext } from '../globalContext.js';
-import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
         const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);

package/dist/esm/node/runtime/renderPage/createHttpResponse/getCacheControl.js

@@ -1,6 +1,6 @@
 export { getCacheControl };
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
 const defaultValue = 'no-store, max-age=0';
 function getCacheControl(pageId, pageConfigs, statusCode) {
     // TODO/v1-release: remove

package/dist/esm/node/runtime/renderPage/executeOnBeforeRenderAndDataHooks.d.ts

@@ -1,7 +1,7 @@
 export { executeOnBeforeRenderAndDataHooks };
-import { type PageContextExports } from '../../../shared/getPageFiles.js';
+import { type PageConfigUserFriendly } from '../../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 declare function executeOnBeforeRenderAndDataHooks(pageContext: {
     pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageContextExports & PageContextForUserConsumptionServerSide): Promise<void>;
+} & PageConfigUserFriendly & PageContextForUserConsumptionServerSide): Promise<void>;

package/dist/esm/node/runtime/renderPage/loadUserFilesServerSide.d.ts

@@ -14,7 +14,7 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
     pageId: string;
-} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageContextExports & {
+} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageConfigUserFriendly & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

package/dist/esm/node/runtime/renderPage/loadUserFilesServerSide.js

@@ -1,5 +1,5 @@
 export { loadUserFilesServerSide };
-import { getPageFilesServerSide, getPageContextExports } from '../../../shared/getPageFiles.js';
+import { getPageFilesServerSide, getPageConfigUserFriendly } from '../../../shared/getPageFiles.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { assert, assertUsage, assertWarning, hasProp, isArrayOfStrings, objectAssign, isArray } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
@@ -99,7 +99,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = getPageContextExports(pageFilesServerSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendly(pageFilesServerSide, pageConfigLoaded);
     return {
         pageContextExports,
         pageFilesLoaded: pageFilesServerSide

package/dist/esm/node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.d.ts

@@ -2,9 +2,9 @@ export { preparePageContextForUserConsumptionServerSide };
 export type { PageContextForUserConsumptionServerSide };
 import { PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-import type { PageContextExports } from '../../../shared/getPageFiles/getExports.js';
+import type { PageConfigUserFriendly } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { PageContextBuiltInServerInternal } from '../../../shared/types.js';
-type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & PageContextExports & {
+type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & PageConfigUserFriendly & {
     urlOriginal: string;
     /** @deprecated */
     url: string;