vike 0.4.237-commit-92dc549 → 0.4.237-commit-2d6f480

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 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 & VikeConfigPublicPageLazyLoaded & {
-    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<VikeConfigPublicPageLazyLoaded & {
     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 };
-import { getPageFilesServerSide, } from '../../../shared/getPageFiles.js';
+export { loadPageConfigsLazyServerSide };
+import { getPageFilesServerSide } from '../../../shared/getPageFiles.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 { loadPageEntry } from '../../../shared/page-configs/loadPageEntry.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 loadPageEntry(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 = resolveVikeConfigPublicPageLazyLoaded(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/{renderPageAlreadyRouted.d.ts → renderPageAfterRoute.d.ts}

@@ -1,4 +1,4 @@
-export { renderPageAlreadyRouted };
+export { renderPageAfterRoute };
 export { prerenderPage };
 export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
@@ -10,7 +10,7 @@ type PageContextAfterRender = {
     httpResponse: HttpResponse;
     errorWhileRendering: null | Error;
 };
-declare function renderPageAlreadyRouted<PageContext extends {
+declare function renderPageAfterRoute<PageContext extends {
     pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
     is404: null | boolean;
@@ -118,11 +118,19 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         url: string;
     } & {
         headers: Record<string, string> | null;
+    } & import("../../../shared/route/index.js").PageContextAfterRoute & {
+        is404: boolean | null;
+        pageId: string;
+    } & {
+        _pageConfig: import("../../../types/PageConfig.js").PageConfigRuntime | null;
+    } & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
     } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
+    } & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: import("../html/serializeContext.js").PassToClient;
-        _pageFilePathsLoaded: string[];
         headersResponse: Headers;
     } & {
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
@@ -229,11 +237,19 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         url: string;
     } & {
         headers: Record<string, string> | null;
+    } & import("../../../shared/route/index.js").PageContextAfterRoute & {
+        is404: boolean | null;
+        pageId: string;
+    } & {
+        _pageConfig: import("../../../types/PageConfig.js").PageConfigRuntime | null;
+    } & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
     } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
+        _pageConfig: null | import("../../../types/PageConfig.js").PageConfigRuntime;
+    } & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: import("../html/serializeContext.js").PassToClient;
-        _pageFilePathsLoaded: string[];
         headersResponse: Headers;
     } & {
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;

package/dist/esm/node/runtime/renderPage/{renderPageAlreadyRouted.js → renderPageAfterRoute.js}

@@ -1,11 +1,11 @@
-export { renderPageAlreadyRouted };
+export { renderPageAfterRoute };
 export { prerenderPage };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
-import { assert, assertUsage, augmentType, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, updateType, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
-import { loadPageConfigsLazyServerSideAndExecHook, } from './loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
 import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
 import { logRuntimeError } from '../loggerRuntime.js';
@@ -14,8 +14,7 @@ import { preparePageContextForPublicUsageServer } from './preparePageContextForP
 import { execHookGuard } from '../../../shared/route/execHookGuard.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
-// TODO/now: rename?
-async function renderPageAlreadyRouted(pageContext) {
+async function renderPageAfterRoute(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
     //  - ID of the error page `_error.page.js`.
@@ -24,7 +23,7 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(isError ===
         (pageContext.pageId ===
             getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+    updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     if (!isError) {
         await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }

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

@@ -1,9 +1,9 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { renderPageAfterRoute } from './renderPage/renderPageAfterRoute.js';
 import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, updateType, } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -16,7 +16,7 @@ import pc from '@brillout/picocolors';
 import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
-import { loadPageConfigsLazyServerSideAndExecHook } from './renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
 import { getVikeConfigError } from '../shared/getVikeConfigError.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
@@ -153,7 +153,7 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
 async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
     assert(pageContextNominalPageBegin);
     assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage);
     // Handle `throw redirect()` and `throw render()` while rendering nominal page
     if (isAbortError(errNominalPage)) {
         const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
@@ -178,7 +178,7 @@ async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNo
     }
     let pageContextErrorPage;
     try {
-        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+        pageContextErrorPage = await renderPageAfterRoute(pageContextErrorPageInit);
     }
     catch (errErrorPage) {
         // Handle `throw redirect()` and `throw render()` while rendering error page
@@ -293,11 +293,11 @@ async function renderPageNominal(pageContext) {
     assert(hasProp(pageContext, 'pageId', 'string'));
     assert(pageContext.errorWhileRendering === null);
     // Render
-    const pageContextAfterRender = await renderPageAlreadyRouted(pageContext);
+    const pageContextAfterRender = await renderPageAfterRoute(pageContext);
     assert(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPagePartial) {
+async function getPageContextErrorPageInit(pageContextBegin, errNominalPage) {
     const pageContext = forkPageContext(pageContextBegin);
     assert(errNominalPage);
     objectAssign(pageContext, {
@@ -305,9 +305,6 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
         errorWhileRendering: errNominalPage,
         routeParams: {},
     });
-    objectAssign(pageContext, {
-        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR',
-    });
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
@@ -423,7 +420,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+            updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext, false);
         }

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

@@ -55,7 +55,7 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/getViteRPC.js';
 export * from '../../utils/isRunnableDevEnvironment.js';

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

@@ -59,7 +59,7 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/augmentType.js';
+export * from '../../utils/updateType.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/getViteRPC.js';
 export * from '../../utils/isRunnableDevEnvironment.js';

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.d.ts

@@ -12,7 +12,6 @@ declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promis
     readonly ssrEmitAssets: true | undefined;
     readonly cssMinify: "esbuild" | undefined;
     readonly manifest: true;
-    readonly copyPublicDir: boolean | undefined;
 }>;
 declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment, options: {
     dir: string | undefined;

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.js

@@ -11,9 +11,9 @@ import { assert, assertWarning, getGlobalObject, isEqualStringList, isObject, pL
 import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
-import { getVikeConfigInternal, isV1Design } from '../../shared/resolveVikeConfigInternal.js';
+import { isV1Design } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerSide_onlySsrEnv, isViteServerSide, isViteServerSide_withoutEnv, } from '../../shared/isViteServerSide.js';
+import { isViteServerSide_onlySsrEnv, isViteServerSide } from '../../shared/isViteServerSide.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 const globalObject = getGlobalObject('build/handleAssetsManifest.ts', {
@@ -280,7 +280,6 @@ async function writeManifestFile(manifest, manifestFilePath) {
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
 async function handleAssetsManifest_getBuildConfig(config) {
-    const vikeConfig = await getVikeConfigInternal();
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     return {
         // https://github.com/vikejs/vike/issues/1339
@@ -288,10 +287,9 @@ async function handleAssetsManifest_getBuildConfig(config) {
         // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
         cssMinify: isFixEnabled ? 'esbuild' : undefined,
         manifest: true,
-        copyPublicDir: vikeConfig.config.vite6BuilderApp
-            ? // Already set by vike:build:pluginBuildApp
-                undefined
-            : !isViteServerSide_withoutEnv(config),
+        /* Already set by vike:build:pluginBuildApp
+        copyPublicDir: !isViteServerSide_withoutEnv(config),
+        */
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildApp.js

@@ -2,8 +2,7 @@ export { pluginBuildApp };
 import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
-import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
-import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { isPrerenderForceExit } from './pluginBuildConfig.js';
 function pluginBuildApp() {
     return [
         {
@@ -12,10 +11,7 @@ function pluginBuildApp() {
             enforce: 'pre',
             config: {
                 order: 'pre',
-                async handler(_config) {
-                    const vikeConfig = await getVikeConfigInternal();
-                    if (!vikeConfig.config.vite6BuilderApp)
-                        return;
+                handler(_config) {
                     return {
                         builder: {
                             // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
@@ -37,10 +33,7 @@ function pluginBuildApp() {
         {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
-            async config(config) {
-                const vikeConfig = await getVikeConfigInternal();
-                if (!vikeConfig.config.vite6BuilderApp)
-                    return;
+            config(config) {
                 return {
                     environments: {
                         ssr: {

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.d.ts

@@ -1,6 +1,8 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
+export { pluginAutoFullBuild };
+export { isPrerenderForceExit };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
 declare function pluginBuildConfig(): Plugin[];
@@ -10,3 +12,5 @@ declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config
     clientEntries: Record<string, string>;
 };
 declare function assertRollupInput(config: ResolvedConfig): void;
+declare function pluginAutoFullBuild(): Plugin[];
+declare function isPrerenderForceExit(): boolean;