vike 0.4.247 → 0.4.249-commit-775a43e

package/dist/shared-server-client/assertVirtualFileExports.js

@@ -0,0 +1,16 @@
+export { assertVirtualFileExports };
+import { assert } from './utils.js';
+function assertVirtualFileExports(moduleExports, test, moduleId) {
+    if (!moduleExports || !test(moduleExports)) {
+        /* https://github.com/vikejs/vike/issues/2903#issuecomment-3642285811
+        throw getProjectError('@cloudflare/vite-plugin error https://github.com/vikejs/vike/issues/2903#issuecomment-3642285811')
+        /*/
+        assert(false, { moduleExports, moduleExportsKeys: getKeys(moduleExports), moduleId });
+        //*/
+    }
+}
+function getKeys(obj) {
+    if (obj === undefined)
+        return null;
+    return [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj), ...Object.keys(obj)];
+}

package/dist/shared-server-client/createGlobalContextShared.d.ts

@@ -0,0 +1,122 @@
+export { createGlobalContextShared };
+export { getGlobalContextSyncErrMsg };
+export type { GlobalContextBase };
+export type { GlobalContextBasePublic };
+export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
+import type { PageFile } from './getPageFiles.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
+import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import type { GlobalContextServerInternal } from '../server/runtime/globalContext.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
+import { type Hook } from './hooks/getHook.js';
+declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
+    globalContext?: {};
+    onCreateGlobalContextHooks?: Hook<GlobalContextPrepareMinimum>[];
+    previousCreateGlobalContextPromise?: Promise<void>;
+}, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../types/index.js").ConfigResolved;
+                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("./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("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../types/index.js").ConfigResolved;
+            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("./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("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    /**
+     * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/globalContext#typescript
+     */
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+} & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
+declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../types/index.js").ConfigResolved;
+                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("./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("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../types/index.js").ConfigResolved;
+            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("./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("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    /**
+     * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/globalContext#typescript
+     */
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+};

package/dist/shared-server-client/createGlobalContextShared.js

@@ -0,0 +1,110 @@
+export { createGlobalContextShared };
+export { getGlobalContextSyncErrMsg };
+import { assert, changeEnumerable, genPromise, objectAssign, objectReplace, unique } from './utils.js';
+import { parseVirtualFileExportsGlobalEntry } from './getPageFiles/parseVirtualFileExportsGlobalEntry.js';
+import { resolveGlobalContextConfig } from './page-configs/resolveVikeConfigPublic.js';
+import { execHookGlobal } from './hooks/execHook.js';
+import { prepareGlobalContextForPublicUsage, } from './prepareGlobalContextForPublicUsage.js';
+import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
+const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+// TO-DO/eventually use flat globalContext — like flat pageContext
+async function createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, addGlobalContext, 
+// TO-DO/next-major-release: we'll be able to remove addGlobalContextTmp after loadPageRoutes() is sync (it will be sync after we remove the old design)
+addGlobalContextTmp, addGlobalContextAsync) {
+    const { previousCreateGlobalContextPromise } = globalObject;
+    const { promise, resolve } = genPromise({
+        // Avoid this Cloudflare Worker error:
+        // ```console
+        // Error: Disallowed operation called within global scope. Asynchronous I/O (ex: fetch() or connect()), setting a timeout, and generating random values are not allowed within global scope. To fix this error, perform this operation within a handler.
+        // ```
+        timeout: null,
+    });
+    globalObject.previousCreateGlobalContextPromise = promise;
+    if (previousCreateGlobalContextPromise) {
+        assert(globalObject.globalContext);
+        await previousCreateGlobalContextPromise;
+    }
+    try {
+        const globalContext = createGlobalContextBase(virtualFileExportsGlobalEntry);
+        let isNewGlobalContext;
+        if (!globalObject.globalContext) {
+            // We set globalObject.globalContext early and before any async operations, so that getGlobalContextSync() can be used early.
+            // - Required by vike-vercel
+            globalObject.globalContext = globalContext;
+            isNewGlobalContext = false;
+        }
+        else {
+            isNewGlobalContext = true;
+        }
+        if (addGlobalContext &&
+            // TO-DO/next-major-release: remove
+            globalContext._pageConfigs.length > 0) {
+            const globalContextAdded = addGlobalContext?.(globalContext);
+            objectAssign(globalContext, globalContextAdded);
+        }
+        else {
+            const globalContextAdded = await addGlobalContextTmp?.(globalContext);
+            objectAssign(globalContext, globalContextAdded);
+        }
+        {
+            const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
+            objectAssign(globalContext, globalContextAddedAsync);
+        }
+        const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
+        let hooksCalled = false;
+        if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
+            globalObject.onCreateGlobalContextHooks = onCreateGlobalContextHooks;
+            await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
+            hooksCalled = true;
+        }
+        if (isNewGlobalContext) {
+            // Singleton: ensure all `globalContext` user-land references are preserved & updated.
+            if (hooksCalled) {
+                objectReplace(globalObject.globalContext, globalContext);
+            }
+            else {
+                // We don't use objectReplace() in order to keep user-land properties.
+                objectAssign(globalObject.globalContext, globalContext, true);
+            }
+        }
+        return globalObject.globalContext;
+    }
+    finally {
+        resolve();
+    }
+}
+function createGlobalContextBase(virtualFileExportsGlobalEntry) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    const globalContextAddendum = resolveGlobalContextConfig(pageConfigs, pageConfigGlobal);
+    const globalContext = {
+        /**
+         * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+         *
+         * https://vike.dev/globalContext#typescript
+         */
+        isGlobalContext: true,
+        _isOriginalObject: true,
+        _virtualFileExportsGlobalEntry: virtualFileExportsGlobalEntry,
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        ...globalContextAddendum,
+    };
+    changeEnumerable(globalContext, '_isOriginalObject', false);
+    return globalContext;
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}
+function hooksAreEqual(hooks1, hooks2) {
+    const hooksFn1 = hooks1.map((hook) => hook.hookFn);
+    const hooksFn2 = hooks2.map((hook) => hook.hookFn);
+    return (hooksFn1.every((hook) => hooksFn2.includes(hook)) &&
+        //
+        hooksFn2.every((hook) => hooksFn1.includes(hook)));
+}

package/dist/shared-server-client/forkPageContext.d.ts

@@ -0,0 +1,2 @@
+export { forkPageContext };
+declare function forkPageContext<PageContext extends Record<string, unknown>>(pageContext: PageContext): {} & PageContext;

package/dist/shared-server-client/forkPageContext.js

@@ -0,0 +1,8 @@
+export { forkPageContext };
+import { objectAssign } from './utils.js';
+// Create pageContext forks to avoid leaks: upon an error (bug or abort) a brand new pageContext object is created, in order to avoid previous pageContext modifications that are now obsolete to leak to the new pageContext object.
+function forkPageContext(pageContext) {
+    const pageContextNew = {};
+    objectAssign(pageContextNew, pageContext, true);
+    return pageContextNew;
+}

package/dist/shared-server-client/getPageContextRequestUrl.js

@@ -0,0 +1,13 @@
+export { getPageContextRequestUrl };
+export { pageContextJsonFileExtension };
+export { doNotCreateExtraDirectory };
+// This module isn't loaded by the client-side of Server Routing => we don't include `urlToFile` to `./utils.ts`
+import { urlToFile } from '../utils/urlToFile.js';
+const pageContextJsonFileExtension = '.pageContext.json';
+// `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/vikejs/vike/issues/443
+const doNotCreateExtraDirectory = false;
+// See also node/renderPageServer/handlePageContextRequestUrl.ts
+function getPageContextRequestUrl(url) {
+    const pageContextRequestUrl = urlToFile(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
+    return pageContextRequestUrl;
+}

package/dist/shared-server-client/getPageContextUrlComputed.d.ts

@@ -0,0 +1,42 @@
+export { getPageContextUrlComputed };
+export type { PageContextUrlInternal };
+export type { PageContextUrlClient };
+export type { PageContextUrlServer };
+export type { PageContextUrlSource };
+import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
+import { type UrlPublic } from './utils.js';
+type PageContextUrlComputed = {
+    /** Parsed information about the current URL */
+    urlParsed: UrlPublic;
+    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+    urlPathname: string;
+    /** @deprecated */
+    url: string;
+};
+type PageContextUrl = {
+    /** The URL of the HTTP request */
+    urlOriginal: string;
+} & PageContextUrlComputed;
+type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
+    _urlRewrite?: string;
+};
+type PageContextUrlClient = PageContextUrl;
+type PageContextUrlServer = PageContextUrl & {
+    urlParsed: Omit<PageContextUrl['urlParsed'], HashProps> & {
+        /** Only available on the client-side */
+        hash: '';
+        /** Only available on the client-side */
+        hashString: null;
+        /** @deprecated */
+        hashOriginal: null;
+    };
+};
+type HashProps = 'hash' | 'hashString' | 'hashOriginal';
+declare function getPageContextUrlComputed(pageContext: PageContextUrlSource): PageContextUrlComputed;
+type PageContextUrlSource = {
+    urlOriginal: string;
+    urlLogical?: string;
+    _urlRewrite?: string;
+    _baseServer: string;
+    _urlHandler: null | ((url: string) => string);
+};

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/determineClientEntry.d.ts

@@ -0,0 +1,14 @@
+export { determineClientEntry };
+export { getVikeClientEntry };
+import type { ClientDependency } from './ClientDependency.js';
+import type { PageFile } from '../../getPageFiles.js';
+declare function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting, }: {
+    pageFilesClientSide: PageFile[];
+    pageFilesServerSide: PageFile[];
+    isHtmlOnly: boolean;
+    isClientRouting: boolean;
+}): {
+    clientEntries: string[];
+    clientDependencies: ClientDependency[];
+};
+declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/client/runtime-client-routing/entry.js" | "@@vike/dist/client/runtime-server-routing/entry.js";

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -0,0 +1,28 @@
+// TO-DO/next-major-release: remove
+export { determineClientEntry };
+export { getVikeClientEntry };
+function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting, }) {
+    let clientEntries = [];
+    const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => !pageFilesClientSide.includes(p));
+    const clientDependencies = [];
+    clientDependencies.push(...pageFilesClientSide.map((p) => ({ id: p.filePath, onlyAssets: false, eagerlyImported: false })));
+    // CSS & assets
+    clientDependencies.push(...pageFilesServerSideOnly.map((p) => ({ id: p.filePath, onlyAssets: true, eagerlyImported: false })));
+    // Handle SPA & SSR pages.
+    if (isHtmlOnly) {
+        clientEntries = pageFilesClientSide.map((p) => p.filePath);
+    }
+    else {
+        // Add the vike client entry
+        const clientEntry = getVikeClientEntry(isClientRouting);
+        clientDependencies.push({ id: clientEntry, onlyAssets: false, eagerlyImported: false });
+        clientEntries = [clientEntry];
+    }
+    // console.log(pageFilesClientSide, pageFilesServerSide, clientDependencies, clientEntry)
+    return { clientEntries, clientDependencies };
+}
+function getVikeClientEntry(isClientRouting) {
+    return isClientRouting
+        ? '@@vike/dist/client/runtime-client-routing/entry.js'
+        : '@@vike/dist/client/runtime-server-routing/entry.js';
+}

package/dist/shared-server-client/getPageFiles/getAllPageIdFiles.js

@@ -0,0 +1,100 @@
+// TO-DO/next-major-release: remove this file
+export { getPageFilesClientSide };
+export { getPageFilesServerSide };
+import { assert, assertUsage, isNotNullish } from '../utils.js';
+function getPageFilesClientSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, true);
+}
+function getPageFilesServerSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, false);
+}
+function determine(pageFilesAll, pageId, envIsClient) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const pageFilesRelevant = pageFilesAll
+        .filter((p) => p.isRelevant(pageId) && p.fileType !== '.page.route')
+        .sort(getPageFilesSorter(envIsClient, pageId));
+    // Load the `.page.js` files specific to `pageId`
+    const getPageIdFile = (iso) => {
+        const files = pageFilesRelevant.filter((p) => p.pageId === pageId && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env));
+        assertUsage(files.length <= 1, `Merge the following files into a single file: ${files.map((p) => p.filePath).join(' ')}`);
+        const pageIdFile = files[0];
+        assert(pageIdFile === undefined || !pageIdFile.isDefaultPageFile);
+        return pageIdFile;
+    };
+    const pageIdFileEnv = getPageIdFile(false);
+    const pageIdFileIso = getPageIdFile(true);
+    // A page can have only one renderer. In other words: Multiple `renderer/` overwrite each other.
+    // Load only load renderer (`/renderer/_default.*`)
+    const getRendererFile = (iso) => pageFilesRelevant.filter((p) => p.isRendererPageFile && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env))[0];
+    const rendererFileEnv = getRendererFile(false);
+    const rendererFileIso = getRendererFile(true);
+    // A page can load multiple `_default.page.*` files of the same `fileType`. In other words: non-renderer `_default.page.*` files are cumulative.
+    // The exception being HTML-only pages because we pick a single page file as client entry. We handle that use case at `renderPageServer()`.
+    const defaultFilesNonRenderer = pageFilesRelevant.filter((p) => p.isDefaultPageFile && !p.isRendererPageFile && (p.isEnv(env) || p.isEnv('CLIENT_AND_SERVER')));
+    // Ordered by `pageContext.exports` precedence
+    const pageFiles = [pageIdFileEnv, pageIdFileIso, ...defaultFilesNonRenderer, rendererFileEnv, rendererFileIso].filter(isNotNullish);
+    return pageFiles;
+}
+function getPageFilesSorter(envIsClient, pageId) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const e1First = -1;
+    const e2First = +1;
+    const noOrder = 0;
+    return (e1, e2) => {
+        // `.page.js` files specific to `pageId` first
+        if (!e1.isDefaultPageFile && e2.isDefaultPageFile) {
+            return e1First;
+        }
+        if (!e2.isDefaultPageFile && e1.isDefaultPageFile) {
+            return e2First;
+        }
+        // Non-renderer `_default.page.*` before `renderer/**/_default.page.*`
+        {
+            const e1_isRenderer = e1.isRendererPageFile;
+            const e2_isRenderer = e2.isRendererPageFile;
+            if (!e1_isRenderer && e2_isRenderer) {
+                return e1First;
+            }
+            if (!e2_isRenderer && e1_isRenderer) {
+                return e2First;
+            }
+            assert(e1_isRenderer === e2_isRenderer);
+        }
+        // Filesystem nearest first
+        {
+            const e1_distance = getPathDistance(pageId, e1.filePath);
+            const e2_distance = getPathDistance(pageId, e2.filePath);
+            if (e1_distance < e2_distance) {
+                return e1First;
+            }
+            if (e2_distance < e1_distance) {
+                return e2First;
+            }
+            assert(e1_distance === e2_distance);
+        }
+        // `.page.server.js`/`.page.client.js` before `.page.js`
+        {
+            if (e1.isEnv(env) && e2.isEnv('CLIENT_AND_SERVER')) {
+                return e1First;
+            }
+            if (e2.isEnv(env) && e1.isEnv('CLIENT_AND_SERVER')) {
+                return e2First;
+            }
+        }
+        return noOrder;
+    };
+}
+function getPathDistance(pathA, pathB) {
+    // Index of first different character
+    let idx = 0;
+    for (; idx < pathA.length && idx < pathB.length; idx++) {
+        if (pathA[idx] !== pathB[idx])
+            break;
+    }
+    const pathAWithoutCommon = pathA.slice(idx);
+    const pathBWithoutCommon = pathB.slice(idx);
+    const distanceA = pathAWithoutCommon.split('/').length;
+    const distanceB = pathBWithoutCommon.split('/').length;
+    const distance = distanceA + distanceB;
+    return distance;
+}

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js

@@ -0,0 +1,100 @@
+export { parseVirtualFileExportsGlobalEntry };
+// TO-DO/next-major-release: remove old design code, and remove all assertions.
+import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
+import { assertExportValues } from './assert_exports_old_design.js';
+import { getPageFileObject } from './getPageFileObject.js';
+import { fileTypes } from './fileTypes.js';
+import { parsePageConfigsSerialized } from '../page-configs/serialize/parsePageConfigsSerialized.js';
+import { assertVirtualFileExports } from '../assertVirtualFileExports.js';
+function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
+    assertVirtualFileExports(virtualFileExportsGlobalEntry, (moduleExports) => 'pageFilesLazy' in moduleExports);
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesLazy', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesEager', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesExportNamesLazy', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesExportNamesEager', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page'));
+    assert(hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.client') ||
+        hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.server'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesList', 'string[]'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigsSerialized'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExportsGlobalEntry;
+    assertPageConfigsSerialized(pageConfigsSerialized);
+    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
+    const pageFilesMap = {};
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const loadModule = globValue;
+        assertLoadModule(loadModule);
+        pageFile.loadFile = async () => {
+            if (!('fileExports' in pageFile)) {
+                pageFile.fileExports = await loadModule();
+                assertExportValues(pageFile);
+            }
+        };
+    });
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const loadModule = globValue;
+        assertLoadModule(loadModule);
+        pageFile.loadExportNames = async () => {
+            if (!('exportNames' in pageFile)) {
+                const moduleExports = await loadModule();
+                assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+                pageFile.exportNames = moduleExports.exportNames;
+            }
+        };
+    });
+    // `pageFilesEager` contains `.page.route.js` files
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const moduleExports = globValue;
+        assert(isObject(moduleExports));
+        pageFile.fileExports = moduleExports;
+    });
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const moduleExports = globValue;
+        assert(isObject(moduleExports));
+        assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+        pageFile.exportNames = moduleExports.exportNames;
+    });
+    virtualFileExportsGlobalEntry.pageFilesList.forEach((filePath) => {
+        pageFilesMap[filePath] = pageFilesMap[filePath] ?? getPageFileObject(filePath);
+    });
+    const pageFilesAll = Object.values(pageFilesMap);
+    pageFilesAll.forEach(({ filePath }) => {
+        assert(!filePath.includes('\\'));
+    });
+    return { pageFilesAll, pageConfigs, pageConfigGlobal };
+}
+function parseGlobResult(globObject) {
+    const ret = [];
+    Object.entries(globObject).forEach(([fileType, globFiles]) => {
+        cast(fileType);
+        assert(fileTypes.includes(fileType));
+        assert(isObject(globFiles));
+        Object.entries(globFiles).forEach(([filePath, globValue]) => {
+            const pageFile = getPageFileObject(filePath);
+            assert(pageFile.fileType === fileType);
+            ret.push({ filePath, pageFile, globValue });
+        });
+    });
+    return ret;
+}
+function assertLoadModule(globValue) {
+    assert(isCallable(globValue));
+}
+function assertPageConfigsSerialized(pageConfigsSerialized) {
+    assert(isArray(pageConfigsSerialized));
+    pageConfigsSerialized.forEach((pageConfigSerialized) => {
+        assert(isObject(pageConfigSerialized));
+        assert(hasProp(pageConfigSerialized, 'pageId', 'string'));
+        assert(hasProp(pageConfigSerialized, 'routeFilesystem'));
+        assert(hasProp(pageConfigSerialized, 'configValuesSerialized'));
+    });
+}
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    assert(hasProp(pageConfigGlobalSerialized, 'configValuesSerialized'));
+}

package/dist/shared-server-client/getProxyForPublicUsage.d.ts

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

package/dist/shared-server-client/getProxyForPublicUsage.js

@@ -0,0 +1,59 @@
+export { getProxyForPublicUsage };
+// We use a proxy instead of property getters.
+// - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
+//   ```console
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/4dbb354b0bcec04e862041fc9183fc4691bb8711/vike/utils/makePublicCopy.ts
+// Show warning when user is accessing internal `_` properties.
+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: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
+    });
+}
+function getProp(prop, ...args) {
+    const [obj, objName, skipOnInternalProp, fallback] = args;
+    const propStr = String(prop);
+    if (prop === '_isProxyObject')
+        return true;
+    if (prop === 'dangerouslyUseInternals') {
+        args[2] = true;
+        return getProxyForPublicUsage(...args);
+    }
+    if (!skipOnInternalProp) {
+        if (!globalThis.__VIKE__IS_CLIENT)
+            onInternalProp(propStr, objName);
+    }
+    if (prop === '_originalObject')
+        return obj;
+    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)
+        return;
+    const propName = getPropAccessNotation(propStr);
+    assert(isBrowser());
+    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 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} — https://vike.dev/warning/internals`, {
+            onlyOnce: true,
+            showStackTrace: true,
+        });
+    }
+}