vike 0.4.236 → 0.4.237

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

@@ -1,11 +1,13 @@
 export { retrieveAssetsDev };
 import { assert, styleFileRE } from '../../utils.js';
+import { isVirtualFileIdEntry } from '../../../shared/virtualFiles/virtualFileEntry.js';
 async function retrieveAssetsDev(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 { moduleGraph } = viteDevServer;
         const [_, graphId] = await moduleGraph.resolveUrl(id);
         assert(graphId, { id });
@@ -32,6 +34,8 @@ 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
     if (isStyle(mod) && (!importer || !isStyle(importer))) {
         if (mod.url.startsWith('/')) {
             styleUrls.add(mod.url);

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

@@ -1,7 +1,7 @@
 export { getPageAssets };
 export { setResolveClientEntriesDev };
 export { resolveIncludeAssetsImportedByServer };
-import { assert, prependBase, toPosixPath, unique, getGlobalObject } from '../utils.js';
+import { assert, prependBase, toPosixPath, unique, getGlobalObject, getViteRPC } from '../utils.js';
 import { retrieveAssetsDev } from './getPageAssets/retrieveAssetsDev.js';
 import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
 import { inferMediaType } from './inferMediaType.js';
@@ -14,18 +14,11 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
     const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
-    let assetUrls;
-    let clientEntriesSrc;
-    if (isDev) {
-        const { _viteDevServer: viteDevServer } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
-        assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
-    }
-    else {
-        const { assetsManifest } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
-        assetUrls = retrieveAssetsProd(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(pageContext._globalContext.config));
-    }
+    const { assetUrls, clientEntriesSrc } = isDev
+        ? !globalContext._viteDevServer
+            ? await getViteRPC().retrievePageAssetsDevRPC(clientDependencies, clientEntries)
+            : await retrievePageAssetsDev(globalContext._viteDevServer, clientDependencies, clientEntries)
+        : retrievePageAssetsProd(globalContext.assetsManifest, clientDependencies, clientEntries, resolveIncludeAssetsImportedByServer(globalContext.config));
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
         const { mediaType = null, assetType = null } = inferMediaType(src) || {};
@@ -59,6 +52,16 @@ 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 });

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;
 };

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

@@ -2,7 +2,7 @@ export { loadPageConfigsLazyServerSideAndExecHook };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } 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';
@@ -16,6 +16,7 @@ async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
     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;
@@ -28,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 = {};

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

@@ -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;
@@ -56,24 +57,12 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             pages: {
                 [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
             };
-        } & ({
+        } & (({
             _isProduction: false;
             _isPrerendering: false;
             assetsManifest: null;
-            _viteDevServer: import("vite").ViteDevServer;
-            viteConfig: import("vite").ResolvedConfig;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
-            baseServer: string;
-            baseAssets: string;
+            _viteDevServer: import("vite").ViteDevServer | undefined;
+            viteConfig: import("vite").ResolvedConfig | undefined;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -83,19 +72,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
             _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -105,6 +82,13 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
+            _usesClientRouter: boolean;
+            isClientSide: false;
+            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        }) & {
+            baseServer: string;
+            baseAssets: string;
             viteConfigRuntime: {
                 root: string;
                 build: {
@@ -115,12 +99,6 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
                     inject: boolean | undefined;
                 };
             };
-            _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
-            isClientSide: false;
-            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
-            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         });
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _baseServer: string;
@@ -157,8 +135,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _pageContextAlreadyProvidedByOnPrerenderHook?: true;
         is404: boolean;
     } & {
-        isClientSideNavigation: boolean;
-        _urlHandler: null;
+        _isPageContextJsonRequest: null;
     };
 } | {
     documentHtml: string;
@@ -191,24 +168,12 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             pages: {
                 [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
             };
-        } & ({
+        } & (({
             _isProduction: false;
             _isPrerendering: false;
             assetsManifest: null;
-            _viteDevServer: import("vite").ViteDevServer;
-            viteConfig: import("vite").ResolvedConfig;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
-            baseServer: string;
-            baseAssets: string;
+            _viteDevServer: import("vite").ViteDevServer | undefined;
+            viteConfig: import("vite").ResolvedConfig | undefined;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -218,19 +183,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
-            viteConfigRuntime: {
-                root: string;
-                build: {
-                    outDir: string;
-                };
-                _baseViteOriginal: string;
-                vitePluginServerEntry: {
-                    inject: boolean | undefined;
-                };
-            };
             _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
             isClientSide: false;
             _pageRoutes: import("../../../__internal/index.js").PageRoutes;
             _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
@@ -240,6 +193,13 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
             _isProduction: true;
             assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
             _viteDevServer: null;
+            _usesClientRouter: boolean;
+            isClientSide: false;
+            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        }) & {
+            baseServer: string;
+            baseAssets: string;
             viteConfigRuntime: {
                 root: string;
                 build: {
@@ -250,12 +210,6 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
                     inject: boolean | undefined;
                 };
             };
-            _usesClientRouter: boolean;
-            baseServer: string;
-            baseAssets: string;
-            isClientSide: false;
-            _pageRoutes: import("../../../__internal/index.js").PageRoutes;
-            _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         });
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _baseServer: string;
@@ -292,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

@@ -45,7 +45,7 @@ async function renderPageAlreadyRouted(pageContext) {
         if (isError) {
             objectAssign(pageContext, { [isServerSideError]: true });
         }
-        const pageContextSerialized = getPageContextClientSerialized(pageContext);
+        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
@@ -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,14 +67,13 @@ 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) {
         return { documentHtml, pageContextSerialized: null, pageContext };
     }
     else {
-        const pageContextSerialized = getPageContextClientSerialized(pageContext);
+        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }

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

@@ -46,24 +46,12 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         pages: {
             [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
-    } & ({
+    } & (({
         _isProduction: false;
         _isPrerendering: false;
         assetsManifest: null;
-        _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: import("vite").ResolvedConfig;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
-        baseServer: string;
-        baseAssets: string;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
@@ -73,19 +61,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
         _usesClientRouter: boolean;
-        baseServer: string;
-        baseAssets: string;
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
@@ -95,6 +71,13 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -105,12 +88,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
                 inject: boolean | undefined;
             };
         };
-        _usesClientRouter: boolean;
-        baseServer: string;
-        baseAssets: string;
-        isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     });
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _baseServer: string;
@@ -132,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)
@@ -419,10 +420,10 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, pageContextErrorPageInit, true);
             augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = getPageContextClientSerialized(pageContext);
+            pageContextSerialized = getPageContextClientSerialized(pageContext, false);
         }
         else {
-            pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort);
+            pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort, false);
         }
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
         const pageContextReturn = { httpResponse };

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

@@ -42,6 +42,7 @@ export * from '../../utils/assertSetup.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
+export * from '../../utils/virtualFileId.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/getTerminWidth.js';
 export * from '../../utils/truncateString.js';
@@ -56,3 +57,6 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/getViteRPC.js';
+export * from '../../utils/isRunnableDevEnvironment.js';
+export * from '../../utils/assertIsNotBrowser.js';

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

@@ -46,6 +46,7 @@ export * from '../../utils/assertSetup.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
+export * from '../../utils/virtualFileId.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/getTerminWidth.js';
 export * from '../../utils/truncateString.js';
@@ -60,3 +61,6 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/getViteRPC.js';
+export * from '../../utils/isRunnableDevEnvironment.js';
+export * from '../../utils/assertIsNotBrowser.js';

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

@@ -14,3 +14,4 @@ export * from '../../utils/assertIsNotBrowser.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/debug.js';
+export * from '../../utils/virtualFileId.js';

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

@@ -16,3 +16,4 @@ export * from '../../utils/assertIsNotBrowser.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/debug.js';
+export * from '../../utils/virtualFileId.js';