vike 0.4.236-commit-eab75f6 → 0.4.237-commit-85e89b1

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

@@ -1,30 +1,66 @@
 export { handlePageContextRequestUrl };
 import { pageContextJsonFileExtension, doNotCreateExtraDirectory } from '../../../shared/getPageContextRequestUrl.js';
-import { baseServer, parseUrl, assert, slice } from '../utils.js';
+import { modifyUrl } from '../../../shared/modifyUrl.js';
+import { baseServer, parseUrl, assert, slice, isObject, hasProp } from '../utils.js';
 // See also shared/getPageContextRequestUrl.ts
 function handlePageContextRequestUrl(url) {
-    if (!hasSuffix(url)) {
-        return { urlWithoutPageContextRequestSuffix: url, isPageContextRequest: false };
+    const urlParsed = parseUrl(url, baseServer);
+    if (!isMatch(urlParsed)) {
+        return {
+            isPageContextJsonRequest: false,
+            urlWithoutPageContextRequestSuffix: url,
+        };
+    }
+    else {
+        const { urlWithoutPageContextRequestSuffix, searchVikeArgs } = processUrl(urlParsed, url);
+        const previousUrl = parseSearchVikeArgs(searchVikeArgs);
+        return {
+            /* TO-DO/soon/once: pass & use previousUrl
+            isPageContextJsonRequest: { previousUrl },
+            /*/
+            isPageContextJsonRequest: true,
+            //*/
+            urlWithoutPageContextRequestSuffix,
+        };
     }
-    return { urlWithoutPageContextRequestSuffix: removePageContextUrlSuffix(url), isPageContextRequest: true };
 }
-function hasSuffix(url) {
-    const { pathnameOriginal, pathname } = parseUrl(url, baseServer);
-    assert(pathnameOriginal.endsWith(pageContextJsonFileExtension) === pathname.endsWith(pageContextJsonFileExtension), {
-        url,
-    });
-    return pathnameOriginal.endsWith(pageContextJsonFileExtension);
+function isMatch(urlParsed) {
+    const { pathnameOriginal, pathname } = urlParsed;
+    assert(pathname.endsWith(pageContextJsonFileExtension) === pathnameOriginal.endsWith(pageContextJsonFileExtension));
+    return pathname.endsWith(pageContextJsonFileExtension);
 }
-function removePageContextUrlSuffix(url) {
-    const urlParsed = parseUrl(url, baseServer);
+function processUrl(urlParsed, url) {
     // We cannot use `urlParsed.pathname` because it would break the `urlParsed.pathnameOriginal` value of subsequent `parseUrl()` calls.
-    const { origin, pathnameOriginal, searchOriginal, hashOriginal } = urlParsed;
+    const { pathnameOriginal, search } = urlParsed;
     assert(doNotCreateExtraDirectory === false);
     const urlSuffix = `/index${pageContextJsonFileExtension}`;
     assert(pathnameOriginal.endsWith(urlSuffix), { url });
     let pathnameModified = slice(pathnameOriginal, 0, -1 * urlSuffix.length);
     if (pathnameModified === '')
         pathnameModified = '/';
-    assert(url === `${origin || ''}${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`, { url });
-    return `${origin || ''}${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
+    const searchVikeArgs = search?._vike;
+    const urlWithoutPageContextRequestSuffix = modifyUrl(url, {
+        pathname: pathnameModified,
+        search: {
+            _vike: searchVikeArgs ? null : undefined,
+        },
+    });
+    return {
+        searchVikeArgs,
+        urlWithoutPageContextRequestSuffix,
+    };
+}
+function parseSearchVikeArgs(searchVikeArgs) {
+    const args = {
+        previousUrl: null,
+    };
+    if (searchVikeArgs) {
+        const parsed = JSON.parse(searchVikeArgs);
+        assert(isObject(parsed));
+        if ('previousUrl' in parsed) {
+            assert(hasProp(parsed, 'previousUrl', 'string'));
+            args.previousUrl = parsed.previousUrl;
+        }
+    }
+    return args;
 }

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

@@ -1,7 +1,7 @@
 export { loadPageConfigsLazyServerSideAndExecHook };
 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';
@@ -15,7 +15,7 @@ type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & Page
     _globalContext: GlobalContextServerInternal;
 };
 type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
-declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & VikeConfigPublicPageLazyLoaded & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: PassToClient;
@@ -24,7 +24,7 @@ declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends Pa
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;
 }>;
-declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<VikeConfigPublicPageLazyLoaded & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: PassToClient;

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

@@ -1,13 +1,13 @@
 export { loadPageConfigsLazyServerSideAndExecHook };
-import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
-import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+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, objectAssign } from '../utils.js';
+import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign } 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 { loadPageEntry } from '../../../shared/page-configs/loadPageEntry.js';
 import { execHookServer } from './execHookServer.js';
 import { getCacheControl } from './getCacheControl.js';
 async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
@@ -29,19 +29,32 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await analyzePage(pageContext._globalContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);
     const isV1Design = !!pageConfig;
     const passToClient = [];
-    const errMsg = ' should be an array of strings.';
+    const errMsgSuffix = ' should be an array of strings.';
     if (!isV1Design) {
         configPublicPageLazy.exportsAll.passToClient?.forEach((e) => {
-            assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsg}`);
+            assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsgSuffix}`);
             passToClient.push(...e.exportValue);
         });
     }
     else {
         configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
-            const { value } = v;
-            // const { definedAt } = v
-            // assertUsage(isArrayOfStrings(value), `+passToClient value defined at ${definedAt}${errMsg}`)
-            passToClient.push(...value);
+            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
+            assertUsage(isArray(value), `+passToClient value defined at ${definedAt} should be an array`);
+            const valS = value.map((el) => {
+                if (isObject(el)) {
+                    assertWarning(!('once' in el), 'The passToClient once setting is deprecated and no longer has any effect. Instead, see the upcoming .once.js suffix (see https://github.com/vikejs/vike/issues/2566 for more information).', { onlyOnce: true });
+                    assertUsage(hasProp(el, 'prop', 'string'), errMsg);
+                    return el.prop;
+                }
+                assertUsage(typeof el === 'string', errMsg);
+                return el;
+            });
+            /*/
+            assertUsage(isArrayOfStrings(value), errMsg)
+            //*/
+            passToClient.push(...valS);
         });
     }
     const pageContextAddendum = {};
@@ -106,9 +119,9 @@ async function loadPageConfigsLazyServerSide(pageContext) {
 }
 async function loadPageConfigFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
+    const pageConfigLoaded = !pageConfig ? null : await loadPageEntry(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const configPublicPageLazy = resolveVikeConfigPublicPageLazy(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = resolveVikeConfigPublicPageLazyLoaded(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
         configPublicPageLazy,
         pageFilesLoaded: pageFilesServerSide,

package/dist/esm/node/runtime/renderPage/log404/index.d.ts

@@ -2,10 +2,10 @@ export { log404 };
 export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared/route/index.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
-declare function log404(pageContext: {
+import type { PageContextCreated } from '../createPageContextServerSide.js';
+declare function log404(pageContext: PageContextCreated & {
     urlPathname: string;
     errorWhileRendering: null | Error;
-    isClientSideNavigation: boolean;
     _globalContext: GlobalContextServerInternal;
 }): Promise<void>;
 declare function getRoutesInfo(pageRoutes: PageRoutes): string | null;

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;
@@ -14,7 +14,6 @@ type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPub
     Page: unknown;
     pageId: string;
     is404: null | boolean;
-    isClientSideNavigation: boolean;
     _globalContext: GlobalContextServerInternal;
 };
 declare function preparePageContextForPublicUsageServer<PageContext extends PageContextForPublicUsageServer>(pageContext: PageContext): PageContext;

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

@@ -5,6 +5,7 @@ import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlCo
 import { HttpResponse } from './createHttpResponse.js';
 import { PageContext_loadPageConfigsLazyServerSide, type PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
 import type { PageContextCreated } from './createPageContextServerSide.js';
+import type { PageContextBegin } from '../renderPage.js';
 type PageContextAfterRender = {
     httpResponse: HttpResponse;
     errorWhileRendering: null | Error;
@@ -16,7 +17,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
     routeParams: Record<string, string>;
     errorWhileRendering: null | Error;
     _httpRequestId: number;
-} & PageContextCreated & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+} & PageContextCreated & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy & {
     routeParams: Record<string, string>;
     pageId: string;
@@ -41,7 +42,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _globalContext: {
             isGlobalContext: true;
             _isOriginalObject: true;
-            _virtualFileExports: unknown;
+            _virtualFileExportsGlobalEntry: unknown;
             _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
             _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -54,7 +55,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             };
             config: import("../../../types/index.js").ConfigResolved;
             pages: {
-                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
             };
         } & (({
             _isProduction: false;
@@ -117,7 +118,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: import("../html/serializeContext.js").PassToClient;
@@ -134,8 +135,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _pageContextAlreadyProvidedByOnPrerenderHook?: true;
         is404: boolean;
     } & {
-        isClientSideNavigation: boolean;
-        _urlHandler: null;
+        _isPageContextJsonRequest: null;
     };
 } | {
     documentHtml: string;
@@ -153,7 +153,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _globalContext: {
             isGlobalContext: true;
             _isOriginalObject: true;
-            _virtualFileExports: unknown;
+            _virtualFileExportsGlobalEntry: unknown;
             _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
             _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -166,7 +166,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             };
             config: import("../../../types/index.js").ConfigResolved;
             pages: {
-                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+                [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
             };
         } & (({
             _isProduction: false;
@@ -229,7 +229,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    } & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: import("../html/serializeContext.js").PassToClient;
@@ -246,7 +246,6 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _pageContextAlreadyProvidedByOnPrerenderHook?: true;
         is404: boolean;
     } & {
-        isClientSideNavigation: boolean;
-        _urlHandler: null;
+        _isPageContextJsonRequest: null;
     };
 }>;

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

@@ -58,8 +58,7 @@ async function renderPageAlreadyRouted(pageContext) {
 }
 async function prerenderPage(pageContext) {
     objectAssign(pageContext, {
-        isClientSideNavigation: false,
-        _urlHandler: null,
+        _isPageContextJsonRequest: null,
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
@@ -68,7 +67,6 @@ async function prerenderPage(pageContext) {
     await execHookDataAndOnBeforeRender(pageContext);
     const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
-    assert(pageContext.isClientSideNavigation === false);
     const documentHtml = await getHtmlString(htmlRender);
     assert(typeof documentHtml === 'string');
     if (!pageContext._usesClientRouter) {

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

@@ -31,7 +31,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -44,7 +44,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & (({
         _isProduction: false;
@@ -109,4 +109,5 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     headers: Record<string, string> | null;
 } & {
     _httpRequestId: number;
+    _isPageContextJsonRequest: boolean;
 };

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

@@ -307,7 +307,7 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     return pageContext;
 }
 function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
-    const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
+    const { isClientSideNavigation, _urlHandler, _isPageContextJsonRequest } = handlePageContextUrl(pageContextInit.urlOriginal);
     const pageContextBegin = createPageContextServerSide(pageContextInit, globalContext, {
         isPrerendering: false,
         ssr: {
@@ -315,13 +315,14 @@ function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
             isClientSideNavigation,
         },
     });
-    objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
+    objectAssign(pageContextBegin, { _httpRequestId: httpRequestId, _isPageContextJsonRequest });
     return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
-    const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
+    const { isPageContextJsonRequest } = handlePageContextRequestUrl(urlOriginal);
     return {
-        isClientSideNavigation: isPageContextRequest,
+        isClientSideNavigation: !!isPageContextJsonRequest,
+        _isPageContextJsonRequest: isPageContextJsonRequest,
         _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix,
     };
 }
@@ -345,8 +346,8 @@ async function normalizeUrl(pageContextBegin, globalContext, httpRequestId) {
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContext;
-    const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
-    if (isPageContextRequest)
+    const { isPageContextJsonRequest } = handlePageContextRequestUrl(urlOriginal);
+    if (isPageContextJsonRequest)
         return null;
     const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, globalContext.baseServer);
     if (!urlNormalized)

package/dist/esm/node/shared/virtualFileId.d.ts

@@ -0,0 +1,28 @@
+export { parseVirtualFileId };
+export { generateVirtualFileId };
+export { virtualFileIdGlobalEntryServer };
+export { virtualFileIdGlobalEntryClientSR };
+export { virtualFileIdGlobalEntryClientCR };
+declare const virtualFileIdGlobalEntryServer = "virtual:vike:global-entry:server";
+declare const virtualFileIdGlobalEntryClientSR = "virtual:vike:global-entry:client:server-routing";
+declare const virtualFileIdGlobalEntryClientCR = "virtual:vike:global-entry:client:client-routing";
+type VirtualFileIdEntryParsed = {
+    type: 'global-entry';
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+} | {
+    type: 'page-entry';
+    isForClientSide: boolean;
+    pageId: string;
+    isExtractAssets: boolean;
+};
+declare function parseVirtualFileId(id: string): false | VirtualFileIdEntryParsed;
+declare function generateVirtualFileId(args: {
+    type: 'global-entry';
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+} | {
+    type: 'page-entry';
+    pageId: string;
+    isForClientSide: boolean;
+}): string;

package/dist/esm/node/shared/virtualFileId.js

@@ -0,0 +1,107 @@
+export { parseVirtualFileId };
+export { generateVirtualFileId };
+export { virtualFileIdGlobalEntryServer };
+export { virtualFileIdGlobalEntryClientSR };
+export { virtualFileIdGlobalEntryClientCR };
+import { extractAssetsRemoveQuery } from './extractAssetsQuery.js';
+import { assert, assertIsNotBrowser, removeVirtualFileIdPrefix } from './utils.js';
+assertIsNotBrowser();
+// Global entries
+const virtualFileIdGlobalEntryServer = 
+//
+'virtual:vike:global-entry:server';
+const virtualFileIdGlobalEntryClientSR = 
+//
+'virtual:vike:global-entry:client:server-routing';
+const virtualFileIdGlobalEntryClientCR = 
+//
+'virtual:vike:global-entry:client:client-routing';
+// Page entries
+const virtualFileIdPageEntryClient = 
+//
+'virtual:vike:page-entry:client:'; // ${pageId}
+const virtualFileIdPageEntryServer = 
+//
+'virtual:vike:page-entry:server:'; //  ${pageId}
+// Virtual ID prefixes
+const virtualFileIdPageEntryPrefix = 
+//
+'virtual:vike:page-entry:';
+const virtualFileIdGlobalEntryPrefix = 
+//
+'virtual:vike:global-entry:';
+const virtualFileIdGlobalEntries = [
+    virtualFileIdGlobalEntryServer,
+    virtualFileIdGlobalEntryClientCR,
+    virtualFileIdGlobalEntryClientSR,
+];
+assert(virtualFileIdGlobalEntries.every((v) => 
+//
+v.startsWith(virtualFileIdGlobalEntryPrefix)));
+assert([virtualFileIdPageEntryClient, virtualFileIdPageEntryServer].every((v) => 
+//
+v.startsWith(virtualFileIdPageEntryPrefix)));
+function parseVirtualFileId(id) {
+    id = removeVirtualFileIdPrefix(id);
+    if (!id.startsWith(virtualFileIdGlobalEntryPrefix) && !id.startsWith(virtualFileIdPageEntryPrefix))
+        return false;
+    // Global entry
+    if (id.includes(virtualFileIdGlobalEntryPrefix)) {
+        assert(virtualFileIdGlobalEntries.includes(id));
+        const isForClientSide = id !== virtualFileIdGlobalEntryServer;
+        const isClientRouting = id === virtualFileIdGlobalEntryClientCR;
+        return {
+            type: 'global-entry',
+            isForClientSide,
+            isClientRouting,
+        };
+    }
+    // Page entry
+    if (id.includes(virtualFileIdPageEntryPrefix)) {
+        assert(id.startsWith(virtualFileIdPageEntryPrefix));
+        const idOriginal = id;
+        id = extractAssetsRemoveQuery(id);
+        const isExtractAssets = idOriginal !== id;
+        if (id.startsWith(virtualFileIdPageEntryClient)) {
+            assert(isExtractAssets === false);
+            return {
+                type: 'page-entry',
+                pageId: id.slice(virtualFileIdPageEntryClient.length),
+                isForClientSide: true,
+                isExtractAssets,
+            };
+        }
+        if (id.startsWith(virtualFileIdPageEntryServer)) {
+            return {
+                type: 'page-entry',
+                pageId: id.slice(virtualFileIdPageEntryServer.length),
+                isForClientSide: false,
+                isExtractAssets,
+            };
+        }
+        assert(false);
+    }
+    return false;
+}
+function generateVirtualFileId(args) {
+    if (args.type === 'global-entry') {
+        const { isForClientSide, isClientRouting } = args;
+        assert(typeof isClientRouting === 'boolean');
+        if (!isForClientSide) {
+            return virtualFileIdGlobalEntryServer;
+        }
+        else if (isClientRouting) {
+            return virtualFileIdGlobalEntryClientCR;
+        }
+        else {
+            return virtualFileIdGlobalEntryClientSR;
+        }
+    }
+    if (args.type === 'page-entry') {
+        const { pageId, isForClientSide } = args;
+        assert(typeof pageId === 'string');
+        const id = `${isForClientSide ? virtualFileIdPageEntryClient : virtualFileIdPageEntryServer}${pageId}`;
+        return id;
+    }
+    assert(false);
+}

package/dist/esm/node/vite/index.js

@@ -17,14 +17,14 @@ import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
 import { pluginEnvVars } from './plugins/pluginEnvVars.js';
 import pc from '@brillout/picocolors';
 import { pluginFileEnv } from './plugins/pluginFileEnv.js';
-import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
-import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
+import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstants } from './plugins/pluginReplaceConstants.js';
 import { pluginNonRunnableDev } from './plugins/pluginNonRunnableDev.js';
+import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
-setResolveClientEntriesDev(resolveClientEntriesDev);
+setGetClientEntrySrcDev(getClientEntrySrcDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [

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

@@ -9,9 +9,11 @@ function onLoad() {
     assertIsNotBrowser();
     assertNodeVersion();
     // package.json#peerDependencies isn't enough as users often ignore it
-    // This assertion isn't reliable: the user may still use a Vite version older than 5.1.0 — see https://github.com/vitejs/vite/pull/19355
-    // TO-DO/eventually: let's also use this.meta.viteVersion https://github.com/vitejs/vite/pull/20088
-    assertVersion('Vite', version, '5.1.0');
+    // This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
+    // TO-DO/eventually: let's also use this.meta.viteVersion
+    // - https://github.com/vitejs/vite/pull/20088
+    // - https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
+    assertVersion('Vite', version, '6.0.0');
     // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
     assertIsNotProductionRuntime();
 }

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

@@ -7,13 +7,13 @@ import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
 type Bundle = Rollup.OutputBundle;
 declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
-declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig): void;
+declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig, env: Environment): void;
 declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promise<{
     readonly ssrEmitAssets: true | undefined;
     readonly cssMinify: "esbuild" | undefined;
     readonly manifest: true;
     readonly copyPublicDir: boolean | undefined;
 }>;
-declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: {
+declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment, options: {
     dir: string | undefined;
 }, bundle: Bundle): Promise<void>;

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

@@ -8,12 +8,12 @@ import fs_sync from 'node:fs';
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique, } from '../../utils.js';
-import { isVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+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 { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
+import { isViteServerBuild_onlySsrEnv, isViteServerBuild, isViteServerBuild_withoutEnv, } from '../../shared/isViteServerBuild.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
@@ -33,7 +33,7 @@ async function fixServerAssets(config) {
     return { clientManifestMod, serverManifestMod };
 }
 async function copyAssets(filesToMove, filesToRemove, config) {
-    const { outDirClient, outDirServer } = getOutDirs(config);
+    const { outDirClient, outDirServer } = getOutDirs(config, undefined);
     const assetsDir = getAssetsDir(config);
     const assetsDirServer = path.posix.join(outDirServer, assetsDir);
     if (!filesToMove.length && !filesToRemove.length && !existsSync(assetsDirServer))
@@ -165,13 +165,13 @@ function addServerAssets(clientManifest, serverManifest) {
 }
 function getPageId(key) {
     // Normalize from:
-    //   ../../virtual:vike:pageConfigLazy:client:/pages/index
+    //   ../../virtual:vike:page-entry:client:/pages/index
     // to:
-    //   virtual:vike:pageConfigLazy:client:/pages/index
+    //   virtual:vike:page-entry:client:/pages/index
     // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
     key = key.substring(key.indexOf('virtual:vike'));
-    const result = isVirtualFileIdPageConfigLazy(key);
-    return result && result.pageId;
+    const result = parseVirtualFileId(key);
+    return result && result.type === 'page-entry' ? result.pageId : null;
 }
 function collectResources(entryRoot, manifest) {
     const css = [];
@@ -216,10 +216,10 @@ function handleAssetsManifest_assertUsageCssCodeSplit(config) {
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
 const targets = [];
-function handleAssetsManifest_assertUsageCssTarget(config) {
+function handleAssetsManifest_assertUsageCssTarget(config, env) {
     if (!handleAssetsManifest_isFixEnabled(config))
         return;
-    const isServerSide = isViteServerBuild(config);
+    const isServerSide = isViteServerBuild(config, env);
     assert(typeof isServerSide === 'boolean');
     assert(config.build.target !== undefined);
     targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
@@ -290,7 +290,7 @@ async function handleAssetsManifest_getBuildConfig(config) {
         copyPublicDir: vikeConfig.config.vite6BuilderApp
             ? // Already set by vike:build:pluginBuildApp
                 undefined
-            : !isViteServerBuild(config),
+            : !isViteServerBuild_withoutEnv(config),
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
@@ -328,7 +328,7 @@ async function writeAssetsManifestFile(assetsJsonFilePath, config) {
     await fs.rm(serverManifestFilePath);
 }
 function getManifestFilePath(config, client) {
-    const outDirs = getOutDirs(config);
+    const outDirs = getOutDirs(config, undefined);
     const outDir = client ? outDirs.outDirClient : outDirs.outDirServer;
     const env = client ? config.environments.client : config.environments.ssr;
     assert(env);