vike 0.4.236 → 0.4.237-commit-85e89b1

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,26 +39,14 @@ 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;
         _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;
@@ -68,19 +56,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _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;
@@ -90,6 +66,13 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _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: {
@@ -100,12 +83,6 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
                 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;

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,11 +1,27 @@
-export { retrieveAssetsDev };
-import { assert, styleFileRE } from '../../utils.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);
+        const virtualFile = parseVirtualFileId(id);
+        assert(!virtualFile || virtualFile.type !== 'global-entry');
         const { moduleGraph } = viteDevServer;
         const [_, graphId] = await moduleGraph.resolveUrl(id);
         assert(graphId, { id });
@@ -32,6 +48,9 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
     if (visitedModules.has(mod.url))
         return;
     visitedModules.add(mod.url);
+    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,31 +1,18 @@
 export { getPageAssets };
-export { setResolveClientEntriesDev };
-export { resolveIncludeAssetsImportedByServer };
-import { assert, prependBase, toPosixPath, unique, getGlobalObject } 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;
     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, globalContext.config);
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
         const { mediaType = null, assetType = null } = inferMediaType(src) || {};
@@ -59,16 +46,3 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     await sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction);
     return pageAssets;
 }
-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;
 };

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) {
@@ -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 = {};
@@ -105,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;