vike 0.4.243 → 0.4.244-commit-aae383f

package/dist/esm/client/runtime-client-routing/getGlobalContextClientInternal.d.ts

@@ -1,8 +1,5 @@
 export { getGlobalContextClientInternal };
-export type { GlobalContextClient };
 export type { GlobalContextClientInternal };
-import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClient = GlobalContextBasePublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
 declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.d.ts

@@ -145,7 +145,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {
@@ -210,7 +210,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     isHydration: boolean;
     isBackwardNavigation: boolean | null;
     previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-    globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+    globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
 } & {
     urlOriginal: string;
 } & {
@@ -366,7 +366,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {
@@ -429,7 +429,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     isHydration: boolean;
     isBackwardNavigation: boolean | null;
     previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-    globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+    globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
 } & {
     urlOriginal: string;
 } & {

package/dist/esm/client/runtime-client-routing/initOnLinkClick.js

@@ -1,5 +1,5 @@
 export { initOnLinkClick };
-import { isLinkIgnored, isSameAsCurrentUrl, skipLink } from './skipLink.js';
+import { isLinkIgnored, isHrefCurrentUrl, isLinkSkipped } from './isLinkSkipped.js';
 import { renderPageClientSide } from './renderPageClientSide.js';
 import { scrollToHashOrTop } from './setScrollPosition.js';
 function initOnLinkClick() {
@@ -19,14 +19,14 @@ async function onLinkClick(ev) {
     // Workaround for Firefox bug: clicking on a hash link that doesn't change the current URL causes Firefox to erroneously set `window.history.state = null` without firing any signal that we can detect.
     // - https://github.com/vikejs/vike/issues/1962
     // - https://github.com/sveltejs/kit/issues/8725
-    if (href.includes('#') && isSameAsCurrentUrl(href)) {
+    if (href.includes('#') && isHrefCurrentUrl(href)) {
         // Prevent Firefox from setting `window.history.state` to `null`
         ev.preventDefault();
         // Replicate the browser's native behavior
         scrollToHashOrTop(href.split('#')[1]);
         return;
     }
-    if (skipLink(linkTag))
+    if (isLinkSkipped(linkTag))
         return;
     ev.preventDefault();
     let scrollTarget;

package/dist/esm/client/runtime-client-routing/initOnPopState.js

@@ -14,7 +14,7 @@ import { catchInfiniteLoop } from './utils.js';
 // 2. URL hash changes:
 //    - By the user clicking on `<a href="#some-hash">`
 //      - The popstate event is *only* triggered if `href` starts with '#' (even if `href==='/foo#bar'` and the current URL has the same pathname '/foo' then popstate isn't triggered)
-//      - Vike doesn't intercept hash links (see `skipLink()`) and let's the browser handle them.
+//      - Vike doesn't intercept hash links (see `isLinkSkipped()`) and let's the browser handle them.
 //    - By the app using a `location` API such as `location.hash = 'some-hash'`
 //      - Only upon hash navigation: setting `location.href='/foo'` triggers a full page reload and no popstate event is fired.
 //      - Also upon `location.href='/foo#bar'` while the current URL is '/foo' (unlike <a> clicks).

package/dist/esm/client/runtime-client-routing/isLinkSkipped.d.ts

@@ -0,0 +1,6 @@
+export { isLinkSkipped };
+export { isLinkIgnored };
+export { isHrefCurrentUrl };
+declare function isLinkSkipped(linkTag: HTMLElement): boolean;
+declare function isLinkIgnored(linkTag: HTMLElement): boolean;
+declare function isHrefCurrentUrl(href: string): boolean;

package/dist/esm/client/runtime-client-routing/{skipLink.js → isLinkSkipped.js}

@@ -1,18 +1,17 @@
-// TODO: rename_full skipLink isLinkSkipped
-export { skipLink };
+export { isLinkSkipped };
 export { isLinkIgnored };
-export { isSameAsCurrentUrl };
+export { isHrefCurrentUrl };
 import { normalizeClientSideUrl } from '../shared/normalizeClientSideUrl.js';
 import { getBaseServer } from './getBaseServer.js';
 import { assert, parseUrl, isBaseServer, isUrl, isUrlExternal } from './utils.js';
-function skipLink(linkTag) {
+function isLinkSkipped(linkTag) {
     const href = linkTag.getAttribute('href');
     return (href === null ||
         !isUrl(href) ||
         href === '' ||
         isUrlExternal(href) ||
-        isSamePageHashLink(href) ||
-        isNewTabLink(linkTag) ||
+        isHrefSamePageHash(href) ||
+        isLinkExternal(linkTag) ||
         isLinkIgnored(linkTag) ||
         !hasBaseServer(href) ||
         // Purposely last because disableAutomaticLinkInterception will be removed in the next major release
@@ -25,13 +24,11 @@ function isVikeLink(linkTag) {
         return true;
     }
     else {
-        // TODO: rename target attrVal
-        const target = linkTag.getAttribute('data-vike-link');
-        return target !== null && target !== 'false';
+        const attrVal = linkTag.getAttribute('data-vike-link');
+        return attrVal !== null && attrVal !== 'false';
     }
 }
-// TODO rename
-function isNewTabLink(linkTag) {
+function isLinkExternal(linkTag) {
     const target = linkTag.getAttribute('target');
     const rel = linkTag.getAttribute('rel');
     return target === '_blank' || target === '_external' || rel === 'external' || linkTag.hasAttribute('download');
@@ -39,11 +36,9 @@ function isNewTabLink(linkTag) {
 function isLinkIgnored(linkTag) {
     return linkTag.getAttribute('data-vike') === 'false';
 }
-// TODO refactor both functions below?
-function isSamePageHashLink(href) {
+function isHrefSamePageHash(href) {
     if (href.startsWith('#'))
         return true;
-    // TODO: remove?
     if (href.includes('#') &&
         normalizeClientSideUrl(href, { withoutHash: true }) ===
             normalizeClientSideUrl(window.location.href, { withoutHash: true })) {
@@ -51,7 +46,7 @@ function isSamePageHashLink(href) {
     }
     return false;
 }
-function isSameAsCurrentUrl(href) {
+function isHrefCurrentUrl(href) {
     if (href.startsWith('#'))
         return href === window.location.hash;
     return normalizeClientSideUrl(href) === normalizeClientSideUrl(window.location.href);

package/dist/esm/client/runtime-client-routing/prefetch.js

@@ -7,7 +7,7 @@ export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, hasProp, objectAssign, } from './utils.js';
 import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
-import { skipLink } from './skipLink.js';
+import { isLinkSkipped } from './isLinkSkipped.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { createPageContextClientSide } from './createPageContextClientSide.js';
@@ -170,7 +170,7 @@ function addLinkPrefetchHandlers_apply() {
         if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
             continue;
         globalObject.linkPrefetchHandlerAdded.add(linkTag);
-        if (skipLink(linkTag))
+        if (isLinkSkipped(linkTag))
             continue;
         linkTag.addEventListener('mouseover', () => {
             prefetchOnEvent(linkTag, 'hover');
@@ -205,7 +205,7 @@ async function prefetchOnEvent(linkTag, event) {
         }
     }
     // Check again in case DOM was manipulated since last check
-    if (skipLink(linkTag))
+    if (isLinkSkipped(linkTag))
         return;
     const urlOfLink = linkTag.getAttribute('href');
     const pageContextLink = await getPageContextLink(urlOfLink);

package/dist/esm/client/runtime-client-routing/renderPageClientSide.d.ts

@@ -4,11 +4,13 @@ export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
 export type { PageContextBegin };
+export type { PageContextInternalClientAfterRender };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
 import type { PageContextConfig } from '../../shared/getPageFiles.js';
 import type { PageContextClient, PageContextInternalClient } from '../../types/PageContext.js';
 import type { VikeGlobalInternal } from '../../types/VikeGlobalInternal.js';
+type PageContextInternalClientAfterRender = NonNullable<Awaited<ReturnType<typeof renderPageClientSide>>>;
 declare const firstRenderStartPromise: Promise<void>;
 type PageContextRouted = {
     pageId: string;
@@ -26,7 +28,152 @@ type RenderArgs = {
     isClientSideNavigation?: boolean;
     pageContextInitClient?: Record<string, unknown>;
 };
-declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;
+declare function renderPageClientSide(renderArgs: RenderArgs): Promise<({
+    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
+    urlOriginal?: string;
+    urlPathname?: string;
+    pageId: string;
+    _globalContext: import("../shared/getGlobalContextClientInternalShared.js").GlobalContextClientInternalShared;
+} & PageContextConfig & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & PageContextInternalClient & {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    urlOriginal: string;
+    _globalContext: {
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../types/index.js").ConfigResolved;
+                    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & {
+        isClientSide: true;
+    } & {
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    };
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _urlHandler: null;
+    _urlRewrite: null | string;
+    _baseServer: string;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & import("../../shared/page-configs/resolveVikeConfigPublic.js").GlobalConfigPublic & {
+    isBackwardNavigation: boolean | null;
+    isClientSideNavigation: boolean;
+    isHydration: boolean;
+    previousPageContext: ({
+        pageId: string;
+    } & PageContextConfig & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & PageContextInternalClient & Omit<Partial<PageContextConfig & {
+        isPageContext: true;
+        Page: import("../../types/Config.js").Config["Page"];
+        routeParams: Record<string, string>;
+        data: unknown;
+        urlOriginal: string;
+        headers: Record<string, string> | null;
+        headersOriginal?: unknown;
+        headersResponse: Headers;
+        is404: boolean | null;
+        isClientSideNavigation: boolean;
+        abortReason?: unknown;
+        abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+        errorWhileRendering?: unknown;
+        pageId: string | null;
+        from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        url: string;
+        pageExports: Record<string, unknown>;
+        isBaseMissing?: true;
+    }> & Pick<PageContextConfig & {
+        isPageContext: true;
+        Page: import("../../types/Config.js").Config["Page"];
+        routeParams: Record<string, string>;
+        data: unknown;
+        urlOriginal: string;
+        headers: Record<string, string> | null;
+        headersOriginal?: unknown;
+        headersResponse: Headers;
+        is404: boolean | null;
+        isClientSideNavigation: boolean;
+        abortReason?: unknown;
+        abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+        errorWhileRendering?: unknown;
+        pageId: string | null;
+        from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        url: string;
+        pageExports: Record<string, unknown>;
+        isBaseMissing?: true;
+    }, "exports" | "pageId" | "pageExports" | "config" | "Page" | "data" | "source" | "sources" | "from" | "configEntries" | "exportsAll" | "routeParams" | "abortReason"> & {
+        isClientSide: true;
+        isPrerendering: false;
+    } & {
+        isHydration: boolean;
+        isBackwardNavigation: boolean | null;
+        previousPageContext: PageContextClient<unknown> | null;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
+    } & {
+        urlOriginal: string;
+    } & {
+        urlParsed: import("./utils.js").UrlPublic;
+        urlPathname: string;
+        url: string;
+    }, ("globalContext" | "Page" | "data") | "previousPageContext"> & {
+        previousPageContext: {
+            pageId: string;
+        } | null;
+    } & {
+        urlOriginal: string;
+    }) | null;
+} & {
+    urlPathname: string;
+    _hasPageContextFromServer: boolean;
+} & PageContextRouted) | undefined>;
 declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isBackwardNavigation, pageContextsFromRewrite, isClientSideNavigation, pageContextInitClient, isFirstRender, }: {
     urlOriginal: string;
     isBackwardNavigation: boolean | null;
@@ -156,7 +303,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: PageContextClient<unknown> | null;
-        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {

package/dist/esm/client/runtime-client-routing/renderPageClientSide.js

@@ -57,8 +57,7 @@ async function renderPageClientSide(renderArgs) {
     globalObject.firstRenderStartPromiseResolve();
     if (isRenderOutdated())
         return;
-    await renderPageNominal();
-    return;
+    return await renderPageNominal();
     async function renderPageNominal() {
         const onError = async (err) => {
             await handleError({ err });
@@ -187,7 +186,7 @@ async function renderPageClientSide(renderArgs) {
                 return;
             updateType(pageContext, pageContextAugmented);
             // Render page view
-            await renderPageView(pageContext);
+            return await renderPageView(pageContext);
         }
         else {
             // Fetch pageContext from server-side hooks
@@ -227,7 +226,7 @@ async function renderPageClientSide(renderArgs) {
             if (isRenderOutdated())
                 return;
             updateType(pageContext, pageContextFromClientHooks);
-            await renderPageView(pageContext);
+            return await renderPageView(pageContext);
         }
     }
     // When the normal page threw an error:
@@ -474,6 +473,7 @@ async function renderPageClientSide(renderArgs) {
         addLinkPrefetchHandlers();
         globalObject.renderedPageContext = pageContext;
         stampFinished(urlOriginal);
+        return pageContext;
     }
 }
 async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavigation, pageContextsFromRewrite, isClientSideNavigation, pageContextInitClient, isFirstRender, }) {

package/dist/esm/client/runtime-server-routing/getGlobalContextClientInternal.d.ts

@@ -1,8 +1,5 @@
 export { getGlobalContextClientInternal };
-export type { GlobalContextClientWithServerRouting };
 export type { GlobalContextClientInternalWithServerRouting };
-import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
 declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {

package/dist/esm/client/shared/preparePageContextForPublicUsageClientShared.d.ts

@@ -8,4 +8,7 @@ type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageCon
 declare function preparePageContextForPublicUsageClientShared<PageContext extends PageContextForPublicUsageClientShared>(pageContext: PageContext): PageContext & {
     Page: unknown;
 };
-declare function preparePageContextForPublicUsageClientMinimal<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext;
+declare function preparePageContextForPublicUsageClientMinimal<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    dangerouslyUseInternals: PageContext;
+};

package/dist/esm/node/api/preview.d.ts

@@ -1,4 +1,5 @@
 export { preview };
+export type { CliPreviewConfig };
 import { type ResolvedConfig, type PreviewServer } from 'vite';
 import type { ApiOptions } from './types.js';
 /**
@@ -10,3 +11,5 @@ declare function preview(options?: ApiOptions): Promise<{
     viteServer?: PreviewServer;
     viteConfig: ResolvedConfig;
 }>;
+type CliPreviewValue = boolean | 'vite' | undefined;
+type CliPreviewConfig = CliPreviewValue | (() => CliPreviewValue | Promise<CliPreviewValue>);

package/dist/esm/node/api/preview.js

@@ -3,9 +3,10 @@ import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { preview as previewVite } from 'vite';
 import { importServerProductionIndex } from '@brillout/vite-plugin-server-entry/runtime';
 import { getOutDirs } from '../vite/shared/getOutDirs.js';
-import { assertWarning, onSetupPreview } from './utils.js';
+import { assertUsage, assertWarning, onSetupPreview, isCallable } from './utils.js';
 import pc from '@brillout/picocolors';
 import path from 'node:path';
+import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
@@ -14,7 +15,11 @@ import path from 'node:path';
 async function preview(options = {}) {
     onSetupPreview();
     const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
-    if (viteConfigResolved.vitePluginServerEntry?.inject) {
+    const cliPreview = await resolveCliPreviewConfig();
+    assertUsage(cliPreview !== false, `${pc.cyan('$ vike preview')} isn't supported`);
+    const useVite = cliPreview === 'vite' || (cliPreview === undefined && !viteConfigResolved.vitePluginServerEntry?.inject);
+    if (!useVite) {
+        // Dynamically import() server production entry dist/server/index.js
         const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
         const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
@@ -24,6 +29,7 @@ async function preview(options = {}) {
         };
     }
     else {
+        // Use Vite's preview server
         const server = await previewVite(viteConfigFromUserResolved);
         return {
             viteServer: server,
@@ -31,3 +37,13 @@ async function preview(options = {}) {
         };
     }
 }
+async function resolveCliPreviewConfig() {
+    const vikeConfig = await getVikeConfigInternal();
+    const val = vikeConfig.config.cli?.preview;
+    if (!isCallable(val)) {
+        return val;
+    }
+    else {
+        return await val();
+    }
+}

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

@@ -5,3 +5,4 @@ export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
 export * from '../../utils/assertSetup.js';
+export * from '../../utils/isCallable.js';

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

@@ -9,3 +9,4 @@ export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
 export * from '../../utils/assertSetup.js';
+export * from '../../utils/isCallable.js';

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

@@ -20,17 +20,15 @@ export { updateUserFiles };
 export { isRunnable };
 export { vikeConfigErrorRecoverMsg };
 export type { BuildInfo };
-export type { GlobalContextServerInternal as GlobalContextServerInternal };
-export type { GlobalContextServer };
+export type { GlobalContextServerInternal };
 import type { ViteManifest } from '../../types/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { type PageRoutes } from '../../shared/route/loadPageRoutes.js';
 import type { ViteConfigRuntime } from '../vite/shared/getViteConfigRuntime.js';
-import type { GlobalContext } from '../../types/PageContext.js';
+import type { GlobalContext } from '../../types/GlobalContext.js';
 import type { Hook } from '../../shared/hooks/getHook.js';
 import type { PrerenderContext } from '../../types/index.js';
 declare const vikeConfigErrorRecoverMsg: "Vike config loaded";
-type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextServer;
 type GlobalContextServerInternal = Awaited<ReturnType<typeof createGlobalContext>>;
 declare function getGlobalContextServerInternal(): Promise<{
     globalContext: (Record<string, unknown> & {

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

@@ -2,6 +2,7 @@ export { renderPage };
 export { renderPage_addAsyncHookwrapper };
 export type { PageContextInit };
 export type { PageContextBegin };
+export type { PageContextInternalServerAfterRender };
 import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
@@ -21,6 +22,288 @@ declare function renderPage<PageContextUserAdded extends {}, PageContextInitUser
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
 declare function renderPage_addAsyncHookwrapper(wrapper: typeof globalObject.asyncHookWrapper): void;
+type PageContextInternalServerAfterRender = Awaited<ReturnType<typeof renderPageNominal>>;
+declare function renderPageNominal(pageContext: PageContextBegin): Promise<({
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+} & Pick<PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+} & {
+    _globalContext: ({
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../types/index.js").ConfigResolved;
+                    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & (({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _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;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _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;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _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: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+    })) & {
+        prerenderContext: import("../prerender/runPrerender.js").PrerenderContextPublic | undefined;
+    };
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    pages: {
+        [k: string]: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    _httpRequestId: number;
+    _isPageContextJsonRequest: boolean;
+} & {
+    errorWhileRendering: null;
+} & import("../../shared/route/index.js").PageContextAfterRoute & {
+    is404: boolean | null;
+} & Record<"pageId", null> & import("./renderPage/renderPageAfterRoute.js").PageContextAfterRender) | ({
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+} & Pick<PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+} & {
+    _globalContext: ({
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../types/index.js").ConfigResolved;
+                    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & (({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _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;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _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;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _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: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+    })) & {
+        prerenderContext: import("../prerender/runPrerender.js").PrerenderContextPublic | undefined;
+    };
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    pages: {
+        [k: string]: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    _httpRequestId: number;
+    _isPageContextJsonRequest: boolean;
+} & {
+    errorWhileRendering: null;
+} & import("../../shared/route/index.js").PageContextAfterRoute & {
+    is404: boolean | null;
+} & Record<"pageId", string> & import("./renderPage/renderPageAfterRoute.js").PageContextAfterRender)>;
 declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, httpRequestId: number): {
     _isOriginalObject: true;
     isPageContext: true;

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

@@ -221,9 +221,10 @@ function handleAssetsManifest_assertUsageCssCodeSplit(config) {
 }
 function handleAssetsManifest_alignCssTarget(config) {
     globalObject.configsAll.push(config);
-    const { cssTarget } = globalObject.configsAll
-        .filter((c) => !isViteServerSide_viteEnvOptional(c, undefined))
-        .at(-1).build;
+    const clientSideConfigs = globalObject.configsAll.filter((c) => !isViteServerSide_viteEnvOptional(c, undefined));
+    if (clientSideConfigs.length === 0)
+        return;
+    const { cssTarget } = clientSideConfigs.at(-1).build;
     assert(cssTarget);
     globalObject.configsAll.forEach((c) => (c.build.cssTarget = cssTarget));
 }

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

@@ -89,6 +89,7 @@ function pluginBuildApp() {
                 */
                 async handler(options, bundle) {
                     try {
+                        handleAssetsManifest_assertUsageCssTarget(config, this.environment);
                         await handleAssetsManifest(config, this.environment, options, bundle);
                         await triggerPrerendering(config, this.environment, bundle);
                     }
@@ -112,7 +113,6 @@ function pluginBuildApp() {
                 order: 'post',
                 handler() {
                     onSetupBuild();
-                    handleAssetsManifest_assertUsageCssTarget(config, this.environment);
                 },
             },
         },

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

@@ -1,6 +1,6 @@
 export { pluginViteConfigVikeExtensions };
 import { mergeConfig } from 'vite';
-import { assertUsage, isObject } from '../utils.js';
+import { assertUsage, isCallable, isObject } from '../utils.js';
 import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
 // Apply +vite
 // - For example, Vike extensions adding Vite plugins
@@ -12,10 +12,13 @@ async function pluginViteConfigVikeExtensions() {
     const viteConfigsExtensions = vikeConfig._from.configsCumulative.vite;
     if (!viteConfigsExtensions)
         return [];
-    viteConfigsExtensions.values.forEach((v) => {
-        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigFromExtensions = mergeConfig(viteConfigFromExtensions, v.value);
-    });
+    await Promise.all(viteConfigsExtensions.values.map(async (v) => {
+        let val = v.value;
+        if (isCallable(val))
+            val = await val();
+        assertUsage(isObject(val), `${v.definedAt} should be an object, or a function returning an object`);
+        viteConfigFromExtensions = mergeConfig(viteConfigFromExtensions, val);
+    }));
     const pluginsFromExtensions = (viteConfigFromExtensions.plugins ?? []);
     delete viteConfigFromExtensions.plugins;
     return [

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -196,6 +196,10 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
     },
     middleware: { env: { server: true }, cumulative: true, eager: true, global: true },
+    cli: {
+        env: { config: true },
+        global: true,
+    },
     onPrerenderStart: {
         env: { server: true, production: true },
         eager: true,

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

@@ -2,7 +2,6 @@ export { getVikeConfig };
 export type { VikeConfig };
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
-export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
 export { isVikeConfigContextSet };
 export { reloadVikeConfig };
@@ -18,6 +17,7 @@ import { type GlobalConfigPublic } from '../../../shared/page-configs/resolveVik
 import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesAll.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
+import { type DangerouslyUseInternals } from '../../../shared/getProxyForPublicUsage.js';
 type VikeConfigContext = {
     userRootDir: string;
     isDev: boolean;
@@ -37,14 +37,18 @@ type VikeConfigInternal = GlobalConfigPublic & {
 };
 declare function reloadVikeConfig(): void;
 declare function getVikeConfigInternal(doNotRestartViteOnError?: boolean): Promise<VikeConfigInternal>;
-declare function getVikeConfigInternalSync(): VikeConfigInternal;
 /**
  * Get all the information Vike knows about the app in your Vite plugin.
  *
  * https://vike.dev/getVikeConfig
  */
-declare function getVikeConfig(config: ResolvedConfig | UserConfig): VikeConfig;
-type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContext'>;
+declare function getVikeConfig(
+/** @deprecated the `config` argument isn't needed anymore — remove it (it doesn't have any effect) */
+config?: ResolvedConfig | UserConfig): VikeConfig;
+type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContext'> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<VikeConfigInternal>;
+};
 declare function setVikeConfigContext(vikeConfigCtx_: VikeConfigContext): void;
 declare function isVikeConfigContextSet(): boolean;
 declare function getVikeConfigInternalOptional(): Promise<null | VikeConfigInternal>;

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

@@ -3,7 +3,6 @@ export { getVikeConfig };
 // Internal usage
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
-export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
 export { isVikeConfigContextSet };
 export { reloadVikeConfig };
@@ -58,11 +57,6 @@ doNotRestartViteOnError = false) {
     const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     return vikeConfig;
 }
-// TO-DO/next-major-release: remove
-function getVikeConfigInternalSync() {
-    assert(globalObject.vikeConfigSync);
-    return globalObject.vikeConfigSync;
-}
 // TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
 // - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
 // Public usage
@@ -72,10 +66,17 @@ function getVikeConfigInternalSync() {
  * https://vike.dev/getVikeConfig
  */
 function getVikeConfig(
-// TO-DO/eventually: remove unused arguments (older versions used it and we didn't remove it yet to avoid a TypeScript breaking change)
-// - No rush: we can do it later since it's getVikeConfig() is a beta feature as documented at https://vike.dev/getVikeConfig
+/** @deprecated the `config` argument isn't needed anymore — remove it (it doesn't have any effect) */
 config) {
-    const vikeConfig = getVikeConfigInternalSync();
+    /* TO-DO/eventualy: add deprecation warning. We don't do it yet because of vike-server and vike-cloudflare which are using getVikeConfig() with the argument.
+    assertWarning(
+      config === undefined,
+      `getVikeConfig() doesn't accept any argument anymore — remove the argument (it doesn't have any effect)`,
+      { onlyOnce: true, showStackTrace: true },
+    )
+    */
+    assert(globalObject.vikeConfigSync);
+    const vikeConfig = globalObject.vikeConfigSync;
     assertUsage(vikeConfig, 'getVikeConfig() can only be used when Vite is loaded (i.e. during development or build) — Vite is never loaded in production.');
     const vikeConfigPublic = getProxyForPublicUsage(vikeConfig, 'vikeConfig');
     return vikeConfigPublic;

package/dist/esm/shared/getProxyForPublicUsage.d.ts

@@ -1,4 +1,11 @@
 export { getProxyForPublicUsage };
+export type { DangerouslyUseInternals };
 type Target = Record<string, unknown>;
 type Fallback = (prop: string | symbol) => unknown;
-declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: true, fallback?: Fallback): Obj;
+declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: true, fallback?: Fallback): Obj & {
+    _isProxyObject: true;
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<Obj>;
+};
+/** https://vike.dev/warning/internals */
+type DangerouslyUseInternals<Obj> = Obj;

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -10,25 +10,27 @@ import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
 import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
 function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
     return new Proxy(obj, {
-        get: getTrapGet(obj, objName, skipOnInternalProp, fallback),
+        get: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
     });
 }
-function getTrapGet(obj, objName, skipOnInternalProp, fallback) {
-    return function (_, prop) {
-        const propStr = String(prop);
-        if (prop === '_isProxyObject')
-            return true;
-        if (!skipOnInternalProp)
+function getProp(prop, obj, objName, skipOnInternalProp, fallback) {
+    const propStr = String(prop);
+    if (prop === '_isProxyObject')
+        return true;
+    if (prop === 'dangerouslyUseInternals')
+        return obj;
+    if (!skipOnInternalProp) {
+        if (!globalThis.__VIKE__IS_CLIENT)
             onInternalProp(propStr, objName);
-        if (fallback && !(prop in obj)) {
-            // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
-            // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
-            return fallback(prop);
-        }
-        const val = obj[prop];
-        onNotSerializable(propStr, val, objName);
-        return val;
-    };
+    }
+    if (fallback && !(prop in obj)) {
+        // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
+        // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
+        return fallback(prop);
+    }
+    const val = obj[prop];
+    onNotSerializable(propStr, val, objName);
+    return val;
 }
 function onNotSerializable(propStr, val, objName) {
     if (val !== NOT_SERIALIZABLE)
@@ -38,17 +40,15 @@ function onNotSerializable(propStr, val, objName) {
     assertUsage(false, `Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`);
 }
 function onInternalProp(propStr, objName) {
-    // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
-    // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
-    //   - Where import.meta.CLIENT is defined by Vike
-    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
-    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
-    if (isBrowser())
-        return;
+    // We must skip it on the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    assert(!isBrowser());
     // TO-DO/soon/proxy: remove this and only warn on built-in access instead
     if (propStr === '_configFromHook')
         return;
     if (propStr.startsWith('_')) {
-        assertWarning(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`, { onlyOnce: true, showStackTrace: true });
+        assertWarning(false, `Using internal ${objName}.${propStr} — https://vike.dev/warning/internals`, {
+            onlyOnce: true,
+            showStackTrace: true,
+        });
     }
 }

package/dist/esm/shared/prepareGlobalContextForPublicUsage.d.ts

@@ -4,4 +4,7 @@ type GlobalContextPrepareMinimum = {
     _isOriginalObject: true;
     isGlobalContext: true;
 };
-declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext;
+declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext & {
+    _isProxyObject: true;
+    dangerouslyUseInternals: GlobalContext;
+};

package/dist/esm/shared/preparePageContextForPublicUsage.d.ts

@@ -7,5 +7,8 @@ type PageContextPrepareMinimum = {
     isPageContext: true;
     _globalContext: GlobalContextPrepareMinimum;
 };
-declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext;
+declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    dangerouslyUseInternals: PageContext;
+};
 declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;

package/dist/esm/types/Config.d.ts

@@ -42,9 +42,11 @@ import type { InjectFilterEntry } from './index.js';
 import type { VikeVitePluginOptions } from '../node/vite/index.js';
 import type { Vike } from './VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../shared/hooks/getHook.js';
-import type { GlobalContext, PageContextClient, PageContextServer } from './PageContext.js';
+import type { PageContextClient, PageContextServer } from './PageContext.js';
+import type { GlobalContext } from './GlobalContext.js';
 import type { InlineConfig } from 'vite';
 import type { PassToClientPublic } from '../node/runtime/renderPage/html/serializeContext.js';
+import type { CliPreviewConfig } from '../node/api/preview.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
@@ -384,7 +386,7 @@ type ConfigBuiltIn = {
      *
      * https://vite.dev/config/
      */
-    vite?: InlineConfig;
+    vite?: InlineConfig | (() => InlineConfig | Promise<InlineConfig>);
     /** Permanent redirections (HTTP status code 301)
      *
      * https://vike.dev/redirects
@@ -512,6 +514,10 @@ type ConfigBuiltIn = {
     keepScrollPosition?: KeepScrollPosition;
     /** @experimental */
     middleware?: Function;
+    /** @experimental */
+    cli?: {
+        preview?: CliPreviewConfig;
+    };
 };
 type ConfigBuiltInResolved = {
     passToClient?: string[][];

package/dist/esm/types/GlobalContext.d.ts

@@ -0,0 +1,18 @@
+export type { GlobalContext };
+export type { GlobalContextServer };
+export type { GlobalContextClient };
+export type { GlobalContextClientWithServerRouting };
+import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
+import type { GlobalContextClientInternalWithServerRouting } from '../client/runtime-server-routing/getGlobalContextClientInternal.js';
+import type { GlobalContextBasePublic } from '../shared/createGlobalContextShared.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
+type GlobalContext = GlobalContextServer | GlobalContextClient;
+type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: GlobalContextServerInternal;
+} & Vike.GlobalContext & Vike.GlobalContextServer;
+type GlobalContextClient = GlobalContextBasePublic & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: GlobalContextClientInternal;
+} & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};

package/dist/esm/types/GlobalContext.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/PageContext.d.ts

@@ -1,12 +1,8 @@
 export type { PageContext };
 export type { PageContextServer };
 export type { PageContextClient };
-export type { GlobalContext };
-export type { GlobalContextServer };
-export type { GlobalContextClient };
 export type { PageContextWithServerRouting };
 export type { PageContextClientWithServerRouting };
-export type { GlobalContextClientWithServerRouting };
 export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
@@ -18,13 +14,19 @@ import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer
 import type { From, PageContextConfig, Source, Sources } from '../shared/page-configs/resolveVikeConfigPublic.js';
 import type { Config } from './Config.js';
 import type { AbortStatusCode } from '../shared/route/abort.js';
-import type { GlobalContextServer } from '../node/runtime/globalContext.js';
-import type { GlobalContextClient } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
-import type { GlobalContextClientWithServerRouting } from '../client/runtime-server-routing/getGlobalContextClientInternal.js';
-type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext & Vike.PageContextServer;
+import type { GlobalContextClient, GlobalContextServer, GlobalContextClientWithServerRouting } from './GlobalContext.js';
+import type { DangerouslyUseInternals } from '../shared/getProxyForPublicUsage.js';
+import type { PageContextInternalServerAfterRender } from '../node/runtime/renderPage.js';
+import type { PageContextInternalClientAfterRender } from '../client/runtime-client-routing/renderPageClientSide.js';
+type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalServer & PageContextInternalServerAfterRender>;
+} & Vike.PageContext & Vike.PageContextServer;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
-type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext & Vike.PageContextClient;
-type GlobalContext = GlobalContextServer | GlobalContextClient;
+type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalClient_ClientRouting & PageContextInternalClientAfterRender>;
+} & Vike.PageContext & Vike.PageContextClient;
 type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
 type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext & Vike.PageContextClient;
 type PageContextBuiltInCommon<Data> = PageContextConfig & {

package/dist/esm/types/index.d.ts

@@ -1,4 +1,5 @@
-export type { PageContext, PageContextServer, PageContextClient, GlobalContext, GlobalContextServer, GlobalContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, GlobalContextClientWithServerRouting, } from './PageContext.js';
+export type { PageContext, PageContextServer, PageContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, } from './PageContext.js';
+export type { GlobalContext, GlobalContextServer, GlobalContextClient, GlobalContextClientWithServerRouting, } from './GlobalContext.js';
 export type { PrerenderContextPublic as PrerenderContext } from '../node/prerender/runPrerender.js';
 export type { PageContextBuiltInServer } from './PageContext.js';
 export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.243";
+export declare const PROJECT_VERSION: "0.4.244-commit-aae383f";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.243';
+export const PROJECT_VERSION = '0.4.244-commit-aae383f';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.243",
+  "version": "0.4.244-commit-aae383f",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/esm/client/runtime-client-routing/skipLink.d.ts

@@ -1,6 +0,0 @@
-export { skipLink };
-export { isLinkIgnored };
-export { isSameAsCurrentUrl };
-declare function skipLink(linkTag: HTMLElement): boolean;
-declare function isLinkIgnored(linkTag: HTMLElement): boolean;
-declare function isSameAsCurrentUrl(href: string): boolean;