vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/node/{plugin → vite}/utils.js

@@ -2,7 +2,8 @@
 // We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
-// It's common practice for Vike's Vite plugin to import from Vike's sever runtime
+// - Server-side bloat is negligible
+// - The Vite plugin imports the server runtime anyways
 export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
 export * from '../../utils/requireResolve.js';
@@ -10,22 +11,16 @@ export * from '../../utils/includes.js';
 export * from '../../utils/isDev.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
-export * from '../../utils/joinEnglish.js';
 export * from '../../utils/escapeRegex.js';
-export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findPackageJson.js';
-export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
-export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
-export * from '../../utils/isArray.js';
-export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/isEqualStringList.js';
 export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';

package/dist/esm/shared/assertHookReturnedObject.js

@@ -14,6 +14,6 @@ function assertHookReturnedObject(obj, keysExpected, errPrefix) {
         'returned an object with following unknown keys:',
         stringifyStringArray(keysUnknown) + '.',
         'Only following keys are allowed:',
-        stringifyStringArray(keysExpected) + '.'
+        stringifyStringArray(keysExpected) + '.',
     ].join(' '));
 }

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

@@ -1,5 +1,5 @@
 export { assertPageContextProvidedByUser };
-declare function assertPageContextProvidedByUser(pageContextProvidedByUser: unknown, { hookName, hookFilePath }: {
+declare function assertPageContextProvidedByUser(pageContextProvidedByUser: unknown, { hookName, hookFilePath, }: {
     hookFilePath: string;
     hookName: 'onBeforeRender' | 'onRenderHtml' | 'render' | 'onBeforeRoute';
 }): asserts pageContextProvidedByUser is Record<string, unknown>;

package/dist/esm/shared/assertPageContextProvidedByUser.js

@@ -1,7 +1,7 @@
 export { assertPageContextProvidedByUser };
 import { assert, assertUsage, assertWarning, isObject } from './utils.js';
 import pc from '@brillout/picocolors';
-function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName, hookFilePath }) {
+function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName, hookFilePath, }) {
     if (pageContextProvidedByUser === undefined || pageContextProvidedByUser === null)
         return;
     assert(!hookName.endsWith(')'));
@@ -10,6 +10,6 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     assertUsage(!('isPageContext' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
-    assertWarning(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
+    assertWarning(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.pageId')} which means that Vike's routing is overridden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
     assertUsage(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.is404')} which is forbidden, use ${pc.cyan('throw render()')} instead, see https://vike.dev/render`);
 }

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

@@ -1,13 +1,18 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-export type { GlobalContextShared };
-export type { GlobalContextSharedPublic };
+export type { GlobalContextBase };
+export type { GlobalContextBasePublic };
+export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
 import type { PageFile } from './getPageFiles.js';
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
+import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.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<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
-}, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): Promise<{
+    onCreateGlobalContextHooks?: Hook[];
+}, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -18,22 +23,21 @@ declare function createGlobalContextShared<GlobalContextAddendum extends object>
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _vikeConfigPublicGlobal: {
+        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;
+    };
+    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("./page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 } & Awaited<GlobalContextAddendum>>;
-type GlobalContextSharedPublic = Pick<GlobalContextShared, 'config' | 'pages' | 'isGlobalContext'>;
-type GlobalContextShared = ReturnType<typeof createGlobalContextBase>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExports: unknown): {
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -45,17 +49,16 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _vikeConfigPublicGlobal: {
+        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;
+    };
+    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("./page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,39 +1,40 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-import { changeEnumerable, objectAssign, unique } from './utils.js';
-import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
-import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from './page-configs/getUserFriendlyConfigs.js';
+import { changeEnumerable, objectAssign, objectReplace, unique } from './utils.js';
+import { parseVirtualFileExports } from './getPageFiles/parseVirtualFileExports.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager, } 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.";
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     const globalContextAddendum = await addGlobalContext?.(globalContext);
     objectAssign(globalContext, globalContextAddendum);
+    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 (!globalObject.globalContext) {
         globalObject.globalContext = globalContext;
-        // - We deliberately call onCreateGlobalContext() only at the beginning and only once per process.
-        // - TO-DO/eventually: HMR
-        //    - Once Photon supports it: `server.hot.send({ type: 'full-server-reload' })`
-        //    - Either use:
-        //      - import.meta.hot
-        //        - https://vite.dev/guide/api-hmr.html
-        //        - Use a Vite transformer to inject import.meta.hot code into each user-land `+onCreateGlobalContext.js` file
-        //        - Seems more idiomatic
-        //      - globalContext._viteDevServer.hot.send()
-        //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
-        //        - Seems less idiomatic
-        await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
     }
     else {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
-        // We don't use objectReplace() in order to keep user-land properties.
-        objectAssign(globalObject.globalContext, globalContext, true);
+        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;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager, } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -47,29 +48,29 @@ function createGlobalContextBase(virtualFileExports) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
-        config: userFriendlyConfigsGlobal.config,
-        pages: userFriendlyConfigsPageEager
+        _vikeConfigPublicGlobal: vikeConfigPublicGlobal,
+        config: vikeConfigPublicGlobal.config,
+        pages: vikeConfigPublicPagesEager,
     };
     changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
 function getConfigsAll(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExports(virtualFileExports);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({
-        pageConfigGlobalValues: pageConfigGlobal.configValues
+    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({
+        pageConfigGlobalValues: pageConfigGlobal.configValues,
     });
-    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return getUserFriendlyConfigsPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    const vikeConfigPublicPagesEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return resolveVikeConfigPublicPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
     }));
     return {
         pageFilesAll,
         allPageIds,
         pageConfigs,
         pageConfigGlobal,
-        userFriendlyConfigsGlobal,
-        userFriendlyConfigsPageEager
+        vikeConfigPublicGlobal,
+        vikeConfigPublicPagesEager,
     };
 }
 function getAllPageIds(pageFilesAll, pageConfigs) {
@@ -78,3 +79,10 @@ function getAllPageIds(pageFilesAll, pageConfigs) {
     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/esm/shared/createPageContextShared.d.ts

@@ -1,9 +1,14 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import type { PageConfigUserFriendly } from './page-configs/getUserFriendlyConfigs.js';
-import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
+import type { VikeConfigPublicGlobal } from './page-configs/resolveVikeConfigPublic.js';
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
 import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & PageConfigUserFriendly>;
+declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, vikeConfigPublicGlobal: VikeConfigPublicGlobal): Promise<T & {
+    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;
+}>;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/esm/shared/createPageContextShared.js

@@ -3,15 +3,15 @@ export { createPageContextObject };
 import { execHookGlobal } from './hooks/execHook.js';
 import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
-async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
-    objectAssign(pageContextCreated, userFriendlyConfigsGlobal);
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
+    objectAssign(pageContextCreated, vikeConfigPublicGlobal);
     await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {
     const pageContext = {
         _isOriginalObject: true,
-        isPageContext: true
+        isPageContext: true,
     };
     changeEnumerable(pageContext, '_isOriginalObject', false);
     return pageContext;

package/dist/esm/shared/error-page.d.ts

@@ -1,7 +1,7 @@
 export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
 import type { PageFile } from './getPageFiles.js';
 declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string | null;
 declare function isErrorPageId(pageId: string, _isV1Design: false): boolean;

package/dist/esm/shared/getPageContextRequestUrl.js

@@ -1,7 +1,7 @@
 export { getPageContextRequestUrl };
 export { pageContextJsonFileExtension };
 export { doNotCreateExtraDirectory };
-// This module isn't loaded by the client-side of Server Routing => we don't inlcude `urlToFile` to `./utils.ts`
+// 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

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -13,17 +13,17 @@ function getPageContextUrlComputed(pageContext) {
     objectDefineProperty(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
         enumerable: true,
-        configurable: true
+        configurable: true,
     });
     objectDefineProperty(pageContextUrlComputed, 'url', {
         get: urlGetter,
         enumerable: false,
-        configurable: true
+        configurable: true,
     });
     objectDefineProperty(pageContextUrlComputed, 'urlParsed', {
         get: urlParsedGetter,
         enumerable: true,
-        configurable: true
+        configurable: true,
     });
     return pageContextUrlComputed;
 }
@@ -109,7 +109,7 @@ function urlParsedGetter() {
         get hashString() {
             assertWarning(false, 'pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal', {
                 onlyOnce: true,
-                showStackTrace: true
+                showStackTrace: true,
             });
             warnHashNotAvailable('hashString');
             return urlParsed.hashOriginal;
@@ -118,7 +118,7 @@ function urlParsedGetter() {
         get searchString() {
             assertWarning(false, 'pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal', { onlyOnce: true, showStackTrace: true });
             return urlParsed.searchOriginal;
-        }
+        },
     };
     changeEnumerable(urlParsedEnhanced, 'hashString', false);
     changeEnumerable(urlParsedEnhanced, 'searchString', false);

package/dist/esm/shared/getPageFiles/analyzeClientSide.d.ts

@@ -1,5 +1,5 @@
 export { analyzeClientSide };
-import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../types/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
 declare function analyzeClientSide(pageConfig: PageConfigRuntime | null, pageFilesAll: PageFile[], pageId: string): {
     isClientRuntimeLoaded: boolean;

package/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.d.ts

@@ -1,6 +1,6 @@
 export { analyzeExports };
 import type { PageFile } from '../getPageFileObject.js';
-declare function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId }: {
+declare function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId, }: {
     pageFilesClientSide: PageFile[];
     pageFilesServerSide: PageFile[];
     pageId: string;

package/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.js

@@ -2,7 +2,7 @@ export { analyzeExports };
 import { getExportNames } from './getExportNames.js';
 import { assertUsage } from '../../utils.js';
 // TODO/v1-release: remove
-function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId }) {
+function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId, }) {
     return { isHtmlOnly: isHtmlOnly(), isClientRouting: isClientRouting() };
     function isHtmlOnly() {
         {
@@ -35,8 +35,8 @@ function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId }) {
             'See https://vike.dev/render-modes for more information.',
             [
                 'Loaded client-side page files (none of them `export { render }`):',
-                ...pageFilesClientSide.map((p, i) => ` (${i + 1}): ${p.filePath}`)
-            ].join('\n')
+                ...pageFilesClientSide.map((p, i) => ` (${i + 1}): ${p.filePath}`),
+            ].join('\n'),
         ].join(' '));
     }
     function isClientRouting() {

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.d.ts

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

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -1,7 +1,7 @@
 // TODO/v1-release: remove
 export { determineClientEntry };
 export { getVikeClientEntry };
-function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {
+function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting, }) {
     let clientEntries = [];
     const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => !pageFilesClientSide.includes(p));
     const clientDependencies = [];
@@ -23,6 +23,6 @@ function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtml
 }
 function getVikeClientEntry(isClientRouting) {
     return isClientRouting
-        ? '@@vike/dist/esm/client/client-routing-runtime/entry.js'
-        : '@@vike/dist/esm/client/server-routing-runtime/entry.js';
+        ? '@@vike/dist/esm/client/runtime-client-routing/entry.js'
+        : '@@vike/dist/esm/client/runtime-server-routing/entry.js';
 }

package/dist/esm/shared/getPageFiles/analyzePageClientSide.js

@@ -14,13 +14,13 @@ function analyzePageClientSide(pageFilesAll, pageId) {
     if (isHtmlOnly) {
         // HTML-only pages don't need any client-side `render()` hook. For apps that have both HTML-only and SSR/SPA pages, we skip the `.page.client.js` file that defines `render()` for HTML-only pages.
         pageFilesClientSide = pageFilesClientSide.filter((p) => p.isEnv('CLIENT_ONLY') && !getExportNames(p).includes('render'));
-        pageFilesClientSide = removeOverridenPageFiles(pageFilesClientSide);
+        pageFilesClientSide = removeOverriddenPageFiles(pageFilesClientSide);
     }
     const { clientEntries, clientDependencies } = determineClientEntry({
         pageFilesClientSide,
         pageFilesServerSide,
         isHtmlOnly,
-        isClientRouting
+        isClientRouting,
     });
     return { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide };
 }
@@ -32,7 +32,6 @@ async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFiles
         if (sharedPageFilesAlreadyLoaded && p.isEnv('CLIENT_AND_SERVER')) {
             return;
         }
-        // TODO: Is `loadExportNames()` cached ? Does it use filesExports if possible? HMR?
         await p.loadExportNames?.();
         /*
         if (pageFile.exportNames) {
@@ -46,7 +45,7 @@ async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFiles
 }
 // [WIP] Just an experiment needed by https://vike.dev/banner
 //  - Not sure I want to make something like a public API: the CSS of `_default.page.server.js` are still loaded -> weird DX.
-function removeOverridenPageFiles(pageFilesClientSide) {
+function removeOverriddenPageFiles(pageFilesClientSide) {
     const pageFilesClientSide_ = [];
     for (const p of pageFilesClientSide) {
         pageFilesClientSide_.push(p);

package/dist/esm/shared/getPageFiles/fileTypes.js

@@ -12,7 +12,7 @@ const fileTypes = [
     // New type `.page.css`/`.page.server.css`/`.page.client.css` for `extensions[number].pageFileDist`.
     //  - Extensions using `pageFileDist` are expected to use a bundler that generates a `.css` colocated next to the original `.page.js` file (e.g. `/renderer/_default.page.server.css` for `/renderer/_default.page.server.js`.
     //  - Since these `.page.css` files Bundlers We can therefore expect that there isn't any `.page.server.sass`/...
-    '.css'
+    '.css',
 ];
 function isValidFileType(filePath) {
     return ['.js', '.mjs', '.cjs', '.css'].some((ext) => filePath.endsWith(ext));

package/dist/esm/shared/getPageFiles/getAllPageIdFiles.js

@@ -28,10 +28,10 @@ function determine(pageFilesAll, pageId, envIsClient) {
     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 `_defaut.page.*` files of the same `fileType`. In other words: non-renderer `_default.page.*` files are cumulative.
+    // 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 `renderPage()`.
     const defaultFilesNonRenderer = pageFilesRelevant.filter((p) => p.isDefaultPageFile && !p.isRendererPageFile && (p.isEnv(env) || p.isEnv('CLIENT_AND_SERVER')));
-    // Ordered by `pageContext.exports` precendence
+    // Ordered by `pageContext.exports` precedence
     const pageFiles = [pageIdFileEnv, pageIdFileIso, ...defaultFilesNonRenderer, rendererFileEnv, rendererFileIso].filter(isNotNullish);
     return pageFiles;
 }

package/dist/esm/shared/getPageFiles/getPageFileObject.js

@@ -30,7 +30,7 @@ function getPageFileObject(filePath) {
         isDefaultPageFile: isDefaultFilePath(filePath),
         isRendererPageFile: fileType !== '.css' && isDefaultFilePath(filePath) && isRendererFilePath(filePath),
         isErrorPageFile: isErrorPageId(filePath, false),
-        pageId: determinePageIdOld(filePath)
+        pageId: determinePageIdOld(filePath),
     };
     return pageFile;
 }

package/dist/esm/shared/getPageFiles/{parseGlobResults.d.ts → parseVirtualFileExports.d.ts}

@@ -1,7 +1,7 @@
-export { parseGlobResults };
+export { parseVirtualFileExports };
 import { type PageFile } from './getPageFileObject.js';
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
-declare function parseGlobResults(pageFilesExports: unknown): {
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../types/PageConfig.js';
+declare function parseVirtualFileExports(virtualFileExports: unknown): {
     pageFilesAll: PageFile[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;

package/dist/esm/shared/getPageFiles/{parseGlobResults.js → parseVirtualFileExports.js}

@@ -1,27 +1,27 @@
-export { parseGlobResults };
+export { parseVirtualFileExports };
 // TODO/v1-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 { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
-// TODO/now: rename
-function parseGlobResults(pageFilesExports) {
-    assert(hasProp(pageFilesExports, 'pageFilesLazy', 'object'));
-    assert(hasProp(pageFilesExports, 'pageFilesEager', 'object'));
-    assert(hasProp(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
-    assert(hasProp(pageFilesExports, 'pageFilesExportNamesEager', 'object'));
-    assert(hasProp(pageFilesExports.pageFilesLazy, '.page'));
-    assert(hasProp(pageFilesExports.pageFilesLazy, '.page.client') || hasProp(pageFilesExports.pageFilesLazy, '.page.server'));
-    assert(hasProp(pageFilesExports, 'pageFilesList', 'string[]'));
-    assert(hasProp(pageFilesExports, 'pageConfigsSerialized'));
-    assert(hasProp(pageFilesExports, 'pageConfigGlobalSerialized'));
-    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+function parseVirtualFileExports(virtualFileExports) {
+    assert(hasProp(virtualFileExports, 'pageFilesLazy', 'object'));
+    assert(hasProp(virtualFileExports, 'pageFilesEager', 'object'));
+    assert(hasProp(virtualFileExports, 'pageFilesExportNamesLazy', 'object'));
+    assert(hasProp(virtualFileExports, 'pageFilesExportNamesEager', 'object'));
+    assert(hasProp(virtualFileExports.pageFilesLazy, '.page'));
+    assert(hasProp(virtualFileExports.pageFilesLazy, '.page.client') ||
+        hasProp(virtualFileExports.pageFilesLazy, '.page.server'));
+    assert(hasProp(virtualFileExports, 'pageFilesList', 'string[]'));
+    assert(hasProp(virtualFileExports, 'pageConfigsSerialized'));
+    assert(hasProp(virtualFileExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExports;
     assertPageConfigsSerialized(pageConfigsSerialized);
     assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
     const { pageConfigs, pageConfigGlobal } = parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
-    parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -32,7 +32,7 @@ function parseGlobResults(pageFilesExports) {
             }
         };
     });
-    parseGlobResult(pageFilesExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -45,20 +45,20 @@ function parseGlobResults(pageFilesExports) {
         };
     });
     // `pageFilesEager` contains `.page.route.js` files
-    parseGlobResult(pageFilesExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         assert(isObject(moduleExports));
         pageFile.fileExports = moduleExports;
     });
-    parseGlobResult(pageFilesExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExports.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;
     });
-    pageFilesExports.pageFilesList.forEach((filePath) => {
+    virtualFileExports.pageFilesList.forEach((filePath) => {
         pageFilesMap[filePath] = pageFilesMap[filePath] ?? getPageFileObject(filePath);
     });
     const pageFilesAll = Object.values(pageFilesMap);

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

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, PageConfigUserFriendlyOld } from './page-configs/getUserFriendlyConfigs.js';
+export type { ExportsAll, VikeConfigPublicPageLazy } from './page-configs/resolveVikeConfigPublic.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';

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

@@ -1,4 +1,4 @@
 export { getProxyForPublicUsage };
 type Target = Record<string, unknown>;
 type Fallback = (prop: string | symbol) => unknown;
-declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true, fallback?: Fallback): Obj;
+declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: true, fallback?: Fallback): Obj;