vike 0.4.237 → 0.4.238

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,120 @@
-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;
 } & {
-    __getPageAssets: () => Promise<PageAsset[]>;
-}>;
-declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: PassToClient;
-    _pageFilePathsLoaded: string[];
     headersResponse: Headers;
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;

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

@@ -1,43 +1,39 @@
-export { loadPageConfigsLazyServerSideAndExecHook };
+export { loadPageConfigsLazyServerSide };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
-import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveVikeConfigPublicPageLazyLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign } from '../utils.js';
+import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign, updateType, } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
-import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
-import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
+import { loadAndParseVirtualFilePageEntry } from '../../../shared/page-configs/loadAndParseVirtualFilePageEntry.js';
 import { execHookServer } from './execHookServer.js';
 import { getCacheControl } from './getCacheControl.js';
-async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
-    objectAssign(pageContext, pageContextAddendum);
+async function loadPageConfigsLazyServerSide(pageContext) {
+    objectAssign(pageContext, {
+        _pageConfig: findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId),
+    });
+    // Load the page's + files
+    updateType(pageContext, await loadPageUserFiles(pageContext));
+    // Resolve new computed pageContext properties
+    updateType(pageContext, await resolvePageContext(pageContext));
+    // Execute +onCreatePageContext
     await execHookServer('onCreatePageContext', pageContext);
     return pageContext;
 }
-// TODO/now: define new function resolveAfterLoad() ?
-async function loadPageConfigsLazyServerSide(pageContext) {
-    const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
-    const globalContext = pageContext._globalContext;
-    const [{ pageFilesLoaded, configPublicPageLazy }] = await Promise.all([
-        loadPageConfigFiles(pageContext._globalContext._pageFilesAll, pageConfig, globalContext._pageConfigGlobal, pageContext.pageId, !globalContext._isProduction),
-        analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
-            sharedPageFilesAlreadyLoaded: true,
-        }),
-    ]);
-    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await analyzePage(pageContext._globalContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);
-    const isV1Design = !!pageConfig;
+async function resolvePageContext(pageContext) {
+    const { isHtmlOnly, clientEntries, clientDependencies } = analyzePage(pageContext);
     const passToClient = [];
     const errMsgSuffix = ' should be an array of strings.';
+    const isV1Design = !!pageContext._pageConfig;
     if (!isV1Design) {
-        configPublicPageLazy.exportsAll.passToClient?.forEach((e) => {
+        pageContext.exportsAll.passToClient?.forEach((e) => {
             assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsgSuffix}`);
             passToClient.push(...e.exportValue);
         });
     }
     else {
-        configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
+        pageContext.from.configsCumulative.passToClient?.values.forEach((v) => {
             const { value, definedAt } = v;
             const errMsg = `+passToClient value defined at ${definedAt}${errMsgSuffix}`;
             //*/ TO-DO/next-major-release: remove the passToClient once setting from the public API
@@ -57,16 +53,13 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             passToClient.push(...valS);
         });
     }
-    const pageContextAddendum = {};
-    objectAssign(pageContextAddendum, configPublicPageLazy);
-    objectAssign(pageContextAddendum, {
-        Page: configPublicPageLazy.exports.Page,
+    objectAssign(pageContext, {
+        Page: pageContext.exports.Page,
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
-        _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath),
-        headersResponse: resolveHeadersResponse(pageContext, pageContextAddendum),
+        headersResponse: resolveHeadersResponse(pageContext),
     });
-    objectAssign(pageContextAddendum, {
+    objectAssign(pageContext, {
         __getPageAssets: async () => {
             if ('_pageAssets' in pageContext) {
                 return pageContext._pageAssets;
@@ -79,14 +72,14 @@ async function loadPageConfigsLazyServerSide(pageContext) {
         },
     });
     // TO-DO/next-major-release: remove
-    Object.assign(pageContextAddendum, {
+    Object.assign(pageContext, {
         _getPageAssets: async () => {
             assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
                 onlyOnce: true,
                 showStackTrace: true,
             });
             const pageAssetsOldFormat = [];
-            (await pageContextAddendum.__getPageAssets()).forEach((p) => {
+            (await pageContext.__getPageAssets()).forEach((p) => {
                 if (p.assetType === 'script' && p.isEntry) {
                     pageAssetsOldFormat.push({
                         src: p.src,
@@ -105,30 +98,33 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    debugPageFiles({
-        pageContext,
-        isHtmlOnly,
-        isClientRouting,
-        pageFilesLoaded,
-        pageFilesClientSide,
-        pageFilesServerSide,
-        clientEntries,
-        clientDependencies,
-    });
-    return pageContextAddendum;
+    return pageContext;
+}
+async function loadPageUserFiles(pageContext) {
+    const [{ configPublicPageLazy }] = await Promise.all([
+        loadPageUserFiles_v1Design(pageContext),
+        analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
+            sharedPageFilesAlreadyLoaded: true,
+        }),
+    ]);
+    objectAssign(pageContext, configPublicPageLazy);
+    return pageContext;
 }
-async function loadPageConfigFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
-    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
+async function loadPageUserFiles_v1Design(pageContext) {
+    const pageFilesServerSide = getPageFilesServerSide(pageContext._pageFilesAll, pageContext.pageId);
+    const isDev = !pageContext._globalContext._isProduction;
+    const pageConfigLoaded = !pageContext._pageConfig
+        ? null
+        : await loadAndParseVirtualFilePageEntry(pageContext._pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const configPublicPageLazy = resolveVikeConfigPublicPageLazy(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = resolveVikeConfigPublicPageLazyLoaded(pageFilesServerSide, pageConfigLoaded, pageContext._globalContext._pageConfigGlobal);
     return {
         configPublicPageLazy,
         pageFilesLoaded: pageFilesServerSide,
     };
 }
-function resolveHeadersResponse(pageContext, pageContextAddendum) {
-    const headersResponse = mergeHeaders(pageContextAddendum.config.headersResponse);
+function resolveHeadersResponse(pageContext) {
+    const headersResponse = mergeHeaders(pageContext.config.headersResponse);
     if (!headersResponse.get('Cache-Control')) {
         const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs);
         if (cacheControl)

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

@@ -1,10 +1,10 @@
 export { preparePageContextForPublicUsageServer };
 export type { PageContextForPublicUsageServer };
 import type { PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
-import type { VikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import type { PageContextInternalServer } from '../../../types/PageContext.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPublicPageLazy & {
+type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPublicPageLazyLoaded & {
     urlOriginal: string;
     /** @deprecated */
     url: string;