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

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

@@ -25,16 +25,16 @@ export { vikeConfigErrorRecoverMsg };
 //  - setGlobalContext_isProduction => setGlobalContext_isProductionEnvironment
 //  - sProductionEnvironment => sDevEnv
 // The core logic revolves around:
-// - virtualFileExports is the main requirement
+// - virtualFileExportsGlobalEntry is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
-//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExports
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExportsGlobalEntry
 //   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
-//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExportsGlobalEntry
 import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION, getViteRPC, isRunnableDevEnvironment, assertIsNotBrowser, } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
-import { virtualFileIdEntryServer } from '../shared/virtualFiles/virtualFileEntry.js';
+import { virtualFileIdGlobalEntryServer } from '../shared/virtualFileId.js';
 import pc from '@brillout/picocolors';
 import { loadPageRoutes, loadPageRoutesSync } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
@@ -159,15 +159,14 @@ function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
     setIsProduction(true);
 }
-// TODO/now: `rename tolerateContraditction tolerateContradiction`
-function setGlobalContext_isProduction(isProduction, tolerateContraditction = false) {
+function setGlobalContext_isProduction(isProduction, tolerateContradiction = false) {
     if (debug.isActivated)
-        debug('setGlobalContext_isProduction()', { isProduction, tolerateContraditction });
+        debug('setGlobalContext_isProduction()', { isProduction, tolerateContradiction });
     if (globalObject.isProduction === undefined) {
         setIsProduction(isProduction);
     }
     else {
-        assert(globalObject.isProduction === isProduction || tolerateContraditction);
+        assert(globalObject.isProduction === isProduction || tolerateContradiction);
     }
 }
 function getViteDevServer() {
@@ -274,7 +273,7 @@ async function loadBuildEntry(outDir) {
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await createGlobalContext(buildEntry.virtualFileExports);
+    await createGlobalContext(buildEntry.virtualFileExportsGlobalEntry);
 }
 // This is the production entry, see:
 // https://github.com/vikejs/vike/blob/798e5465dc3e3e6723b38b601a50350c0a006fb8/packages/vike/node/vite/plugins/pluginBuild/pluginBuildEntry.ts#L47
@@ -291,15 +290,15 @@ async function setGlobalContext_buildEntry(buildEntry) {
 }
 function assertBuildEntry(buildEntry) {
     assert(isObject(buildEntry));
-    assert(hasProp(buildEntry, 'virtualFileExports', 'object'));
-    const { virtualFileExports } = buildEntry;
+    assert(hasProp(buildEntry, 'virtualFileExportsGlobalEntry', 'object'));
+    const { virtualFileExportsGlobalEntry } = buildEntry;
     assert(hasProp(buildEntry, 'assetsManifest', 'object'));
     const { assetsManifest } = buildEntry;
     assertViteManifest(assetsManifest);
     assert(hasProp(buildEntry, 'buildInfo', 'object'));
     const { buildInfo } = buildEntry;
     assertBuildInfo(buildInfo);
-    checkType({ virtualFileExports, assetsManifest, buildInfo });
+    checkType({ virtualFileExportsGlobalEntry, assetsManifest, buildInfo });
 }
 function assertBuildInfo(buildInfo) {
     assert(isObject(buildInfo));
@@ -353,15 +352,15 @@ async function updateUserFiles() {
         viteDevServer !== globalObject.viteDevServer;
     const { viteDevServer } = globalObject;
     let hasError = false;
-    let virtualFileExports;
+    let virtualFileExportsGlobalEntry;
     let err;
     if (viteDevServer) {
         assert(isRunnable(viteDevServer));
         /* We don't use runner.import() yet, because as of vite@7.0.6 (July 2025) runner.import() unexpectedly invalidates the module graph, which is a unexpected behavior that doesn't happen with ssrLoadModule()
         // Vite 6
         try {
-          virtualFileExports = await (viteDevServer.environments.ssr as RunnableDevEnvironment).runner.import(
-            'virtual:vike:entry:server',
+          virtualFileExportsGlobalEntry = await (viteDevServer.environments.ssr as RunnableDevEnvironment).runner.import(
+            'virtual:vike:global-entry:server',
           )
         } catch (err_) {
           hasError = true
@@ -370,7 +369,7 @@ async function updateUserFiles() {
         */
         // Vite 5
         try {
-            virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileIdEntryServer);
+            virtualFileExportsGlobalEntry = await viteDevServer.ssrLoadModule(virtualFileIdGlobalEntryServer);
         }
         catch (err_) {
             hasError = true;
@@ -383,10 +382,10 @@ async function updateUserFiles() {
                ```js
                assert(false)
                // This line breaks the HMR of regular (runnable) apps, even though (as per the assert() above) it's never run. It seems to be a Vite bug: handleHotUpdate() receives an empty `modules` list.
-               import('virtual:vike:entry:server')
+               import('virtual:vike:global-entry:server')
                ```
             */
-            virtualFileExports = await __VIKE__DYNAMIC_IMPORT('virtual:vike:entry:server');
+            virtualFileExportsGlobalEntry = await __VIKE__DYNAMIC_IMPORT('virtual:vike:global-entry:server');
         }
         catch (err_) {
             hasError = true;
@@ -397,12 +396,12 @@ async function updateUserFiles() {
         return { success: false };
     if (hasError)
         return onError(err);
-    virtualFileExports = virtualFileExports.default || virtualFileExports;
+    virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry.default || virtualFileExportsGlobalEntry;
     if (getVikeConfigErrorBuild()) {
         return { success: false };
     }
     try {
-        await createGlobalContext(virtualFileExports);
+        await createGlobalContext(virtualFileExportsGlobalEntry);
     }
     catch (err_) {
         hasError = true;
@@ -414,10 +413,10 @@ async function updateUserFiles() {
         return onError(err);
     return onSuccess();
 }
-async function createGlobalContext(virtualFileExports) {
+async function createGlobalContext(virtualFileExportsGlobalEntry) {
     debug('createGlobalContext()');
     assert(!getVikeConfigErrorBuild());
-    const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext, addGlobalContextTmp, addGlobalContextAsync);
+    const globalContext = await createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, addGlobalContext, addGlobalContextTmp, addGlobalContextAsync);
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);

package/dist/esm/node/runtime/html/serializeContext.d.ts

@@ -3,9 +3,12 @@ export { getPageContextClientSerializedAbort };
 export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
 export type { PassToClient };
+export type { PassToClientPublic };
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextSerialization = {
+import type { PageContextCreated } from '../renderPage/createPageContextServerSide.js';
+import type { PageContextBegin } from '../renderPage.js';
+type PageContextSerialization = PageContextCreated & {
     pageId: string;
     routeParams: Record<string, string>;
     _passToClient: PassToClient;
@@ -13,12 +16,14 @@ type PageContextSerialization = {
     pageProps?: Record<string, unknown>;
     _pageContextInit: Record<string, unknown>;
     _globalContext: GlobalContextServerInternal;
-    isClientSideNavigation: boolean;
+    _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
 };
 declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
-type PassToClient = (string | {
+type PassToClient = string[];
+type PassToClientPublic = (string | {
     prop: string;
+    /** @deprecated 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). */
     once?: boolean;
 })[];
 declare function getPageContextClientSerializedAbort(pageContext: Record<string, unknown> & ({

package/dist/esm/node/runtime/html/serializeContext.js

@@ -27,41 +27,24 @@ const passToClientBuiltInPageContext = [
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
 function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
-    const getObj = (passToClientEntry) => {
-        if (passToClientEntry.once)
-            return undefined; // pass it to client-side globalContext
-        return { obj: pageContext, objName: 'pageContext' };
-    };
-    const res = applyPassToClient(passToClientPageContext, getObj);
+    const res = applyPassToClient(passToClientPageContext, pageContext);
     const pageContextClient = res.objClient;
     const pageContextClientProps = res.objClientProps;
     if (pageContextClientProps.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
-    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, getObj, isHtmlJsonScript);
+    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
     return pageContextClientSerialized;
 }
 function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClient = pageContext._passToClient;
     const globalContext = pageContext._globalContext;
-    const getObj = ({ prop, once }) => {
-        if (once && getPropVal(pageContext, prop)) {
-            assert(typeof pageContext.isClientSideNavigation === 'boolean');
-            if (!pageContext.isClientSideNavigation) {
-                return { obj: pageContext, objName: 'pageContext' }; // pass it to client-side globalContext
-            }
-            else {
-                return undefined; // already passed to client-side
-            }
-        }
-        return { obj: globalContext, objName: 'globalContext' };
-    };
-    const res = applyPassToClient(passToClient, getObj);
+    const res = applyPassToClient(passToClient, globalContext);
     const globalContextClient = res.objClient;
-    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, getObj, isHtmlJsonScript);
+    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, passToClient, getObj, isHtmlJsonScript) {
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
     let serialized;
     try {
         serialized = serializeValue(obj, isHtmlJsonScript);
@@ -70,15 +53,11 @@ function serializeObject(obj, passToClient, getObj, isHtmlJsonScript) {
         const h = (s) => pc.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
-        passToClient.forEach((entry) => {
-            const entryNormalized = normalizePassToClientEntry(entry);
-            const { prop } = entryNormalized;
+        passToClient.forEach((prop) => {
             const res = getPropVal(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const { objName } = getObj(entryNormalized) ?? {};
-            assert(objName);
             const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
                 serializeValue(value, isHtmlJsonScript, varName);
@@ -188,15 +167,10 @@ function getPageContextClientSerializedAbort(pageContext, isHtmlJsonScript) {
     }
     return serializeValue(pageContext, isHtmlJsonScript);
 }
-function applyPassToClient(passToClient, getObj) {
+function applyPassToClient(passToClient, obj) {
     const objClient = {};
     const objClientProps = [];
-    passToClient.forEach((entry) => {
-        const entryNormalized = normalizePassToClientEntry(entry);
-        const { prop } = entryNormalized;
-        const { obj } = getObj(entryNormalized) ?? {};
-        if (!obj)
-            return;
+    passToClient.forEach((prop) => {
         // Get value from pageContext
         const res = getPropVal(obj, prop);
         if (!res)
@@ -208,16 +182,3 @@ function applyPassToClient(passToClient, getObj) {
     });
     return { objClient, objClientProps };
 }
-function normalizePassToClientEntry(entry) {
-    let once;
-    let prop;
-    if (typeof entry === 'string') {
-        prop = entry;
-        once = false;
-    }
-    else {
-        prop = entry.prop;
-        once = entry.once ?? false;
-    }
-    return { prop, once };
-}

package/dist/esm/node/runtime/html/stream.js

@@ -522,8 +522,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const closeStream = async () => {
             if (isClosed)
                 return;
-            isClosed = true;
             await onEnd(isCancel);
+            isClosed = true;
             controllerProxy.close();
         };
         let controllerProxy;

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

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

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

@@ -4,7 +4,7 @@ export type { PageContextCreated };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPage.js';
 type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
-declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, { isPrerendering, ssr: { urlHandler, isClientSideNavigation }, }: {
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
     isPrerendering: false;
     ssr: {
         urlHandler: null | ((url: string) => string);
@@ -26,7 +26,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -39,7 +39,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         };
         config: import("../../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & (({
         _isProduction: false;

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

@@ -3,12 +3,9 @@ export { createPageContextServerSideWithoutGlobalContext };
 import { assert, assertUsage, assertWarning, augmentType, normalizeHeaders, objectAssign } from '../utils.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
-function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
-    urlHandler: null,
-    isClientSideNavigation: false,
-}, }) {
+function createPageContextServerSide(pageContextInit, globalContext, args) {
     assert(pageContextInit.urlOriginal);
-    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering);
     objectAssign(pageContextCreated, {
         _globalContext: globalContext,
         _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
@@ -17,8 +14,8 @@ function createPageContextServerSide(pageContextInit, globalContext, { isPrerend
         _baseAssets: globalContext.baseAssets,
         _pageContextInit: pageContextInit,
         _urlRewrite: null,
-        _urlHandler: urlHandler,
-        isClientSideNavigation,
+        _urlHandler: args.ssr?.urlHandler ?? null,
+        isClientSideNavigation: args.ssr?.isClientSideNavigation ?? false,
     });
     objectAssign(pageContextCreated, globalContext._vikeConfigPublicGlobal);
     // pageContext.urlParsed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 export { handlePageContextRequestUrl };
 declare function handlePageContextRequestUrl(url: string): {
+    isPageContextJsonRequest: boolean;
     urlWithoutPageContextRequestSuffix: string;
-    isPageContextRequest: boolean;
 };