vike 0.4.237 → 0.4.238-commit-3c1a09d

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

@@ -1,10 +1,12 @@
 export { analyzePage };
 import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js';
 import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { getVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { generateVirtualFileId } from '../../shared/virtualFileId.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
-async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
+function analyzePage(pageContext) {
+    const { pageId, _pageConfig: pageConfig, _globalContext: globalContext } = pageContext;
+    const { _pageFilesAll: pageFilesAll } = globalContext;
     if (pageConfig) {
         const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
@@ -15,14 +17,14 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
-            id: getVirtualFileIdPageConfigLazy(pageConfig.pageId, true),
+            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: true }),
             onlyAssets: isClientRuntimeLoaded ? false : true,
             eagerlyImported: false,
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
         if (!globalContext._isProduction) {
             clientDependencies.push({
-                id: getVirtualFileIdPageConfigLazy(pageConfig.pageId, false),
+                id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: false }),
                 onlyAssets: true,
                 eagerlyImported: false,
             });

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

@@ -26,7 +26,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -39,7 +39,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         };
         config: import("../../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & (({
         _isProduction: false;

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

@@ -1,6 +1,6 @@
 export { createPageContextServerSide };
 export { createPageContextServerSideWithoutGlobalContext };
-import { assert, assertUsage, assertWarning, augmentType, normalizeHeaders, objectAssign } from '../utils.js';
+import { assert, assertUsage, assertWarning, updateType, normalizeHeaders, objectAssign } from '../utils.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
 function createPageContextServerSide(pageContextInit, globalContext, args) {
@@ -39,7 +39,7 @@ function createPageContextServerSide(pageContextInit, globalContext, args) {
         objectAssign(pageContextCreated, { headers });
     }
     const pageContextAugmented = createPageContextShared(pageContextCreated, globalContext._vikeConfigPublicGlobal);
-    augmentType(pageContextCreated, pageContextAugmented);
+    updateType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }
 function createPageContextServerSideWithoutGlobalContext(pageContextInit) {

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

@@ -17,7 +17,6 @@ declare function execHookOnRenderHtml(pageContext: PageContextForPublicUsageServ
     __getPageAssets: GetPageAssets;
     _isHtmlOnly: boolean;
     _baseServer: string;
-    _pageFilePathsLoaded: string[];
     _httpRequestId: number | null;
 }): Promise<{
     renderHook: RenderHook;

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

@@ -53,17 +53,7 @@ function getRenderHook(pageContext) {
     }
     if (!hookFound) {
         const hookName = pageContext._globalContext._pageConfigs.length > 0 ? 'onRenderHtml' : 'render';
-        assertUsage(false, [
-            `No ${hookName}() hook found, see https://vike.dev/${hookName}`,
-            /*
-            'See https://vike.dev/render-modes for more information.',
-            [
-              // 'Loaded config files (none of them define the onRenderHtml() hook):',
-              'Loaded server-side page files (none of them `export { render }`):',
-              ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
-            ].join('\n')
-            */
-        ].join(' '));
+        assertUsage(false, `No ${hookName}() hook found, see https://vike.dev/${hookName}`);
     }
     return hookFound;
 }

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

@@ -1,9 +1,9 @@
 export { execHookServer };
 export type { PageContextExecHookServer };
 import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
-import type { VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../../shared/getPageFiles.js';
 import type { HookName } from '../../../types/Config.js';
-type PageContextExecHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
+type PageContextExecHookServer = VikeConfigPublicPageLazyLoaded & PageContextForPublicUsageServer;
 declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
     hookFn: (arg: import("../../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
     hookTimeout: import("../../../shared/hooks/getHook.js").HookTimeout;

package/dist/esm/node/runtime/renderPage/getPageAssets/getManifestEntry.js

@@ -1,6 +1,6 @@
 export { getManifestEntry };
 import { assert, slice, assertIsImportPathNpmPackage } from '../../utils.js';
-import { isVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 function getManifestEntry(id, assetsManifest) {
     const debugInfo = getDebugInfo(id, assetsManifest);
@@ -12,7 +12,8 @@ function getManifestEntry(id, assetsManifest) {
         return { manifestEntry, manifestKey };
     }
     // Page code importer
-    if (isVirtualFileIdPageConfigLazy(id)) {
+    const virtualFile = parseVirtualFileId(id);
+    if (virtualFile && virtualFile.type === 'page-entry') {
         {
             const manifestKey = id;
             const manifestEntry = assetsManifest[manifestKey];
@@ -22,9 +23,9 @@ function getManifestEntry(id, assetsManifest) {
         }
         // Workaround for what seems to be a Vite bug when process.cwd() !== config.root
         //  - Manifest key is:
-        //       ../../virtual:vike:pageConfigLazy:client:/pages/index
+        //       ../../virtual:vike:page-entry:client:/pages/index
         //    But it should be this instead:
-        //      virtual:vike:pageConfigLazy:client:/pages/index
+        //      virtual:vike:page-entry:client:/pages/index
         //  - This workaround was implemented to support Vitest running /tests/*
         //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
         const manifestKeyEnd = id;

package/dist/esm/node/runtime/renderPage/getPageAssets/retrievePageAssetsDev.d.ts

@@ -0,0 +1,10 @@
+export { retrievePageAssetsDev };
+export { setGetClientEntrySrcDev };
+import type { ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { GetClientEntrySrcDev } from '../../../vite/shared/getClientEntrySrcDev.js';
+declare function retrievePageAssetsDev(viteDevServer: ViteDevServer, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<{
+    clientEntriesSrc: string[];
+    assetUrls: string[];
+}>;
+declare function setGetClientEntrySrcDev(getClientEntrySrcDev: GetClientEntrySrcDev): void;

package/dist/esm/node/runtime/renderPage/getPageAssets/{retrieveAssetsDev.js → retrievePageAssetsDev.js}

@@ -1,13 +1,27 @@
-export { retrieveAssetsDev };
-import { assert, styleFileRE } from '../../utils.js';
-import { isVirtualFileIdEntry } from '../../../shared/virtualFiles/virtualFileEntry.js';
-async function retrieveAssetsDev(clientDependencies, viteDevServer) {
+export { retrievePageAssetsDev };
+export { setGetClientEntrySrcDev };
+import { assert, getGlobalObject, styleFileRE } from '../../utils.js';
+import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
+const globalObject = getGlobalObject('getPageAssets/retrievePageAssetsDev.ts', {
+    // We cannot define getClientEntrySrcDev() in this file because it depends on utils/requireResolve.ts which isn't available in production
+    getClientEntrySrcDev: null,
+});
+async function retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.getClientEntrySrcDev(clientEntry, viteDevServer));
+    const assetUrls = await getAssetUrls(clientDependencies, viteDevServer);
+    return { clientEntriesSrc, assetUrls };
+}
+function setGetClientEntrySrcDev(getClientEntrySrcDev) {
+    globalObject.getClientEntrySrcDev = getClientEntrySrcDev;
+}
+async function getAssetUrls(clientDependencies, viteDevServer) {
     const assetUrls = new Set();
     await Promise.all(clientDependencies.map(async ({ id }) => {
         if (id.startsWith('@@vike'))
             return; // vike doesn't have any CSS
         assert(id);
-        assert(!isVirtualFileIdEntry(id));
+        const virtualFile = parseVirtualFileId(id);
+        assert(!virtualFile || virtualFile.type !== 'global-entry');
         const { moduleGraph } = viteDevServer;
         const [_, graphId] = await moduleGraph.resolveUrl(id);
         assert(graphId, { id });
@@ -34,8 +48,9 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
     if (visitedModules.has(mod.url))
         return;
     visitedModules.add(mod.url);
-    if (isVirtualFileIdEntry(mod.id || mod.url))
-        return; // virtual:vike:entry:server dependency list includes all pages
+    const virtualFile = parseVirtualFileId(mod.id || mod.url);
+    if (virtualFile && virtualFile.type === 'global-entry')
+        return; // virtual:vike:global-entry:server dependency list includes all pages
     if (isStyle(mod) && (!importer || !isStyle(importer))) {
         if (mod.url.startsWith('/')) {
             styleUrls.add(mod.url);

package/dist/esm/node/runtime/renderPage/getPageAssets/retrievePageAssetsProd.d.ts

@@ -0,0 +1,10 @@
+export { retrievePageAssetsProd };
+export { resolveIncludeAssetsImportedByServer };
+import type { ViteManifest } from '../../../../types/ViteManifest.js';
+import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { ConfigResolved } from '../../../../types/index.js';
+declare function retrievePageAssetsProd(assetsManifest: ViteManifest, clientDependencies: ClientDependency[], clientEntries: string[], config: ConfigResolved): {
+    clientEntriesSrc: string[];
+    assetUrls: string[];
+};
+declare function resolveIncludeAssetsImportedByServer(config: ConfigResolved): boolean;

package/dist/esm/node/runtime/renderPage/getPageAssets/{retrieveAssetsProd.js → retrievePageAssetsProd.js}

@@ -1,8 +1,22 @@
-export { retrieveAssetsProd };
+export { retrievePageAssetsProd };
+export { resolveIncludeAssetsImportedByServer };
 import { assert, isImportPathNpmPackage } from '../../utils.js';
 import { getManifestEntry } from './getManifestEntry.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
-function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImportedByServer) {
+function retrievePageAssetsProd(assetsManifest, clientDependencies, clientEntries, config) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => getClientEntrySrcProd(clientEntry, assetsManifest));
+    const assetUrls = getAssetsUrl(clientDependencies, assetsManifest, config);
+    return { clientEntriesSrc, assetUrls };
+}
+function getClientEntrySrcProd(clientEntry, assetsManifest) {
+    const { manifestEntry } = getManifestEntry(clientEntry, assetsManifest);
+    assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
+    let { file } = manifestEntry;
+    assert(!file.startsWith('/'));
+    return '/' + file;
+}
+function getAssetsUrl(clientDependencies, assetsManifest, config) {
+    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(config);
     let assetUrls = new Set();
     assert(assetsManifest);
     const visistedAssets = new Set();
@@ -56,3 +70,6 @@ function collectSingleStyle(assetUrls, assetsManifest) {
         assetUrls.add(`/${style.file}`);
     }
 }
+function resolveIncludeAssetsImportedByServer(config) {
+    return config.includeAssetsImportedByServer ?? true;
+}

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

@@ -1,14 +1,9 @@
 export { getPageAssets };
-export { setResolveClientEntriesDev };
-export { resolveIncludeAssetsImportedByServer };
 export type { PageAsset };
 export type { GetPageAssets };
-export type { PageContextGetPageAssets };
 import { type MediaType } from './inferMediaType.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { ResolveClientEntriesDev } from '../../vite/shared/resolveClientEntriesDev.js';
-import type { ConfigResolved } from '../../../types/index.js';
 type PageAsset = {
     src: string;
     assetType: null | NonNullable<MediaType>['assetType'];
@@ -16,11 +11,8 @@ type PageAsset = {
     isEntry: boolean;
 };
 type GetPageAssets = () => Promise<PageAsset[]>;
-type PageContextGetPageAssets = {
+declare function getPageAssets(pageContext: {
     _baseServer: string;
     _baseAssets: string | null;
     _globalContext: GlobalContextServerInternal;
-};
-declare function getPageAssets(pageContext: PageContextGetPageAssets, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;
-declare function setResolveClientEntriesDev(resolveClientEntriesDev: ResolveClientEntriesDev): void;
-declare function resolveIncludeAssetsImportedByServer(config: ConfigResolved): boolean;
+}, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;

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

@@ -1,15 +1,9 @@
 export { getPageAssets };
-export { setResolveClientEntriesDev };
-export { resolveIncludeAssetsImportedByServer };
-import { assert, prependBase, toPosixPath, unique, getGlobalObject, getViteRPC } from '../utils.js';
-import { retrieveAssetsDev } from './getPageAssets/retrieveAssetsDev.js';
-import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
+import { retrievePageAssetsProd } from './getPageAssets/retrievePageAssetsProd.js';
+import { retrievePageAssetsDev } from './getPageAssets/retrievePageAssetsDev.js';
 import { inferMediaType } from './inferMediaType.js';
-import { getManifestEntry } from './getPageAssets/getManifestEntry.js';
 import { sortPageAssetsForEarlyHintsHeader } from './getPageAssets/sortPageAssetsForEarlyHintsHeader.js';
-const globalObject = getGlobalObject('renderPage/getPageAssets.ts', {
-    resolveClientEntriesDev: null,
-});
+import { assert, prependBase, toPosixPath, unique, getViteRPC } from '../utils.js';
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
     const { _isProduction: isProduction } = globalContext;
@@ -18,7 +12,7 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
         ? !globalContext._viteDevServer
             ? await getViteRPC().retrievePageAssetsDevRPC(clientDependencies, clientEntries)
             : await retrievePageAssetsDev(globalContext._viteDevServer, clientDependencies, clientEntries)
-        : retrievePageAssetsProd(globalContext.assetsManifest, clientDependencies, clientEntries, resolveIncludeAssetsImportedByServer(globalContext.config));
+        : retrievePageAssetsProd(globalContext.assetsManifest, clientDependencies, clientEntries, globalContext.config);
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
         const { mediaType = null, assetType = null } = inferMediaType(src) || {};
@@ -52,26 +46,3 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     await sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction);
     return pageAssets;
 }
-async function retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries) {
-    const clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
-    const assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
-    return { clientEntriesSrc, assetUrls };
-}
-function retrievePageAssetsProd(assetsManifest, clientDependencies, clientEntries, includeAssetsImportedByServer) {
-    const clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
-    const assetUrls = retrieveAssetsProd(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(includeAssetsImportedByServer));
-    return { clientEntriesSrc, assetUrls };
-}
-function resolveClientEntriesProd(clientEntry, assetsManifest) {
-    const { manifestEntry } = getManifestEntry(clientEntry, assetsManifest);
-    assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
-    let { file } = manifestEntry;
-    assert(!file.startsWith('/'));
-    return '/' + file;
-}
-function setResolveClientEntriesDev(resolveClientEntriesDev) {
-    globalObject.resolveClientEntriesDev = resolveClientEntriesDev;
-}
-function resolveIncludeAssetsImportedByServer(config) {
-    return config.includeAssetsImportedByServer ?? true;
-}

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

@@ -1,6 +1,6 @@
 export { handleErrorWithoutErrorPage };
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
+import type { PageContextAfterRender } from './renderPageAfterRoute.js';
 import type { PageContextCreated } from './createPageContextServerSide.js';
 declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreated & {
     errorWhileRendering: null | Error;

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

@@ -1,34 +1,122 @@
-export { loadPageConfigsLazyServerSideAndExecHook };
+export { loadPageConfigsLazyServerSide };
 export type { PageContext_loadPageConfigsLazyServerSide };
 export type { PageConfigsLazy };
-import { type VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
+import { type VikeConfigPublicPageLazyLoaded } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
-import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
-import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
-import type { GlobalContextServerInternal } from '../globalContext.js';
-import { type PageContextExecHookServer } from './execHookServer.js';
+import { type PageAsset } from './getPageAssets.js';
+import type { PageConfigRuntime } from '../../../types/PageConfig.js';
 import type { PassToClient } from '../html/serializeContext.js';
-type PageContextExecuteHook = Omit<PageContextExecHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazyServerSide>>>;
-type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
+import type { PageContextAfterRoute } from '../../../shared/route/index.js';
+import type { PageContextCreated } from './createPageContextServerSide.js';
+type PageContext_loadPageConfigsLazyServerSide = PageContextCreated & PageContextAfterRoute & {
+    is404: boolean | null;
     pageId: string;
-    urlOriginal: string;
-    _globalContext: GlobalContextServerInternal;
 };
 type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
-declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & VikeConfigPublicPageLazy & {
-    Page: unknown;
-    _isHtmlOnly: boolean;
-    _passToClient: PassToClient;
-    _pageFilePathsLoaded: string[];
-    headersResponse: Headers;
+declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<{
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _globalContext: {
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        _vikeConfigPublicGlobal: {
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        config: import("../../../types/index.js").ConfigResolved;
+        pages: {
+            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
+        };
+    } & (({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
+        isClientSide: false;
+        _pageRoutes: import("../../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+    });
+    _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: import("../renderPage.js").PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    config: import("../../../types/index.js").ConfigResolved;
+    _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("../utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & PageContextAfterRoute & {
+    is404: boolean | null;
+    pageId: string;
+} & {
+    _pageConfig: PageConfigRuntime | null;
+} & {
+    _pageConfig: null | PageConfigRuntime;
+} & VikeConfigPublicPageLazyLoaded & {
+    _pageConfig: null | PageConfigRuntime;
+} & {
+    cspNonce: string;
 } & {
-    __getPageAssets: () => Promise<PageAsset[]>;
-}>;
-declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: PassToClient;
-    _pageFilePathsLoaded: string[];
     headersResponse: Headers;
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;