vike 0.4.237-commit-92dc549 → 0.4.237-commit-fd8294f

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/pluginAutoFullBuild.js

@@ -1,6 +1,5 @@
 export { pluginAutoFullBuild };
 export { isPrerenderForceExit };
-import { build } from 'vite';
 import { assert, assertWarning, getGlobalObject, onSetupBuild } from '../../utils.js';
 import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
@@ -9,8 +8,8 @@ import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { isVikeCliOrApi } from '../../../api/context.js';
 import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
-import { isViteClientSide, isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
-import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
+import { runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 const globalObject = getGlobalObject('build/pluginAutoFullBuild.ts', {
     forceExit: false,
@@ -54,16 +53,12 @@ function pluginAutoFullBuild() {
             closeBundle: {
                 sequential: true,
                 order: 'post',
-                async handler() {
+                handler() {
                     onSetupBuild();
                     handleAssetsManifest_assertUsageCssTarget(config, this.environment);
-                    const vikeConfig = await getVikeConfigInternal();
-                    if (globalObject.forceExit &&
-                        // Let vike:build:pluginBuildApp force exit
-                        !vikeConfig.config.vite6BuilderApp) {
-                        runPrerender_forceExit();
-                        assert(false);
-                    }
+                    /* Let vike:build:pluginBuildApp force exit
+                    runPrerender_forceExit()
+                    */
                 },
             },
         },
@@ -72,10 +67,9 @@ function pluginAutoFullBuild() {
 async function triggerFullBuild(config, viteEnv, bundle) {
     const vikeConfig = await getVikeConfigInternal();
     // Whether builder.buildApp() is being used, see plugin:build:pluginBuildApp
-    const isBuilderApp = vikeConfig.config.vite6BuilderApp;
     // If builder.buildApp() => trigger at end of `this.environment.name === 'ssr'`.
     // Else => trigger at end of client-side build.
-    if (isBuilderApp ? !isViteServerSide_onlySsrEnv(config, viteEnv) : !isViteClientSide(config, viteEnv))
+    if (!isViteServerSide_onlySsrEnv(config, viteEnv))
         return;
     if (isEntirelyDisabled(vikeConfig))
         return;
@@ -86,27 +80,15 @@ async function triggerFullBuild(config, viteEnv, bundle) {
     if (!bundle[getManifestFilePathRelative(config.build.manifest)])
         return;
     const configInline = getFullBuildInlineConfig(config);
-    if (!isBuilderApp) {
-        await build(setSSR(configInline));
-    }
-    else {
-        // The server build is already called by builder.buildApp()
-    }
+    /* Already triggered by vike:build:pluginBuildApp
+    await build(setSSR(configInline))
+    */
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
         const res = await runPrerenderFromAutoRun(configInline);
         globalObject.forceExit = res.forceExit;
         assert(wasPrerenderRun());
     }
 }
-function setSSR(configInline) {
-    return {
-        ...configInline,
-        build: {
-            ...configInline.build,
-            ssr: true,
-        },
-    };
-}
 async function abortViteBuildSsr() {
     const vikeConfig = await getVikeConfigInternal();
     if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {

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

@@ -3,7 +3,6 @@ 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';
 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/pluginDev/determineOptimizeDeps.js

@@ -13,8 +13,9 @@ async function determineOptimizeDeps(config) {
     const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
     config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
     config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
-    // Workaround until https://github.com/vitejs/vite-plugin-react/issues/650
-    // - TODO/soon: remove workaround once https://github.com/vitejs/vite/pull/20495 is released
+    // Workaround for https://github.com/vitejs/vite-plugin-react/issues/650
+    // - The issue was closed as completed with https://github.com/vitejs/vite/pull/20495 but it doesn't fix the issue and the workaround is still needed.
+    // - TO-DO/eventually: try removing the workaround and see if the CI fails (at test/@cloudflare_vite-plugin/) — maybe the issue will get fixed at some point.
     includeServer.push('react/jsx-dev-runtime');
     for (const envName in config.environments) {
         const env = config.environments[envName];

package/dist/esm/node/vite/plugins/pluginFileEnv.js

@@ -7,6 +7,7 @@ import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
+import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 function pluginFileEnv() {
     let config;
     let viteDevServer;
@@ -28,7 +29,7 @@ function pluginFileEnv() {
             const importers = Array.from(moduleInfo.importers)
                 .map((m) => m.id)
                 .filter((id) => id !== null);
-            assertFileEnv(id, !!options?.ssr, importers, 
+            assertFileEnv(id, isViteServerSide_extraSafe(config, options, this.environment), importers, 
             // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
             true);
         },
@@ -40,7 +41,7 @@ function pluginFileEnv() {
                 return;
             if (skip(id))
                 return;
-            const isServerSide = !!options?.ssr;
+            const isServerSide = isViteServerSide_extraSafe(config, options, this.environment);
             if (!isWrongEnv(id, isServerSide))
                 return;
             const { importers } = this.getModuleInfo(id);
@@ -66,7 +67,7 @@ function pluginFileEnv() {
                     */
                     return;
                 }
-                assertFileEnv(moduleId, !!config.build.ssr, importers, false);
+                assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
             });
         },
         configResolved(config_) {

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -7,7 +7,7 @@ import { isViteServerSide, isViteServerSide_withoutEnv } from './isViteServerSid
 const debug = createDebugger('vike:outDir');
 function getOutDirs(configGlobal, viteEnv) {
     debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromResolvedConfig(configGlobal);
+    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
     assertOutDirResolved(outDir, configGlobal, viteEnv);
     const outDirs = getOutDirsAll(outDir, configGlobal.root);
     assertNormalization(outDirs.outDirRoot);
@@ -114,7 +114,8 @@ function assertOutDirResolved(outDir, configGlobal, viteEnv) {
     assert('/client'.length === '/server'.length);
     const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
     const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    if (isViteServerSide_withoutEnv(configGlobal, viteEnv)) {
+    const isServerSide = isViteServerSide_withoutEnv(configGlobal, viteEnv);
+    if (isServerSide) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {
@@ -128,8 +129,8 @@ function getOutDirFromViteUserConfig(config) {
     outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function getOutDirFromResolvedConfig(config) {
-    let outDir = config.build.outDir;
+function getOutDirFromResolvedConfig(config, viteEnv) {
+    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
     assert(outDir);
     outDir = normalizeOutDir(outDir);
     return outDir;

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -9,8 +9,8 @@ type ViteEnv = {
     name?: string;
     config: EnvironmentOptions | Environment['config'];
 };
-declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv): boolean;
 declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
 declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_extraSafe(config: ResolvedConfig, options: {