vike 0.4.236-commit-eab75f6 → 0.4.237-commit-85e89b1

package/dist/cjs/shared/page-configs/loadPageEntry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPageEntry = loadPageEntry;
+const utils_js_1 = require("../utils.js");
+const parsePageConfigsSerialized_js_1 = require("./serialize/parsePageConfigsSerialized.js");
+async function loadPageEntry(pageConfig, isDev) {
+    if ('isPageEntryLoaded' in pageConfig &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const { moduleId, moduleExportsPromise } = pageConfig.loadVirtualFilePageEntry();
+    const virtualFileExportsPageEntry = await moduleExportsPromise;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!virtualFileExportsPageEntry)
+        (0, utils_js_1.assert)(false, { moduleExportsPromise, virtualFileExportsPageEntry, moduleId });
+    const configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
+    Object.assign(pageConfig.configValues, configValues);
+    (0, utils_js_1.objectAssign)(pageConfig, { isPageEntryLoaded: true });
+    return pageConfig;
+}
+function parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry) {
+    const configValues = (0, parsePageConfigsSerialized_js_1.parseConfigValuesSerialized)(virtualFileExportsPageEntry.configValuesSerialized);
+    return configValues;
+}

package/dist/cjs/shared/page-configs/resolveVikeConfigPublic.js

@@ -4,14 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveVikeConfigPublicGlobal = resolveVikeConfigPublicGlobal;
-exports.resolveVikeConfigPublicPageEager = resolveVikeConfigPublicPageEager;
-exports.resolveVikeConfigPublicPageLazy = resolveVikeConfigPublicPageLazy;
+exports.resolveVikeConfigPublicPageEagerLoaded = resolveVikeConfigPublicPageEagerLoaded;
+exports.resolveVikeConfigPublicPageLazyLoaded = resolveVikeConfigPublicPageLazyLoaded;
 const assert_exports_old_design_js_1 = require("../getPageFiles/assert_exports_old_design.js");
 const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
 const helpers_js_1 = require("./helpers.js");
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+function resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues, pageConfig, pageConfigValues) {
     const vikeConfigPublicPage_ = resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues });
     const vikeConfigPublicPage = getPublicCopy(vikeConfigPublicPage_);
     let page;
@@ -46,7 +46,7 @@ function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues, }) {
     const vikeConfigPublicGlobal = resolveVikeConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
     return getPublicCopy(vikeConfigPublicGlobal);
 }
-function resolveVikeConfigPublicPageLazy(pageFiles, // V0.4 design
+function resolveVikeConfigPublicPageLazyLoaded(pageFiles, // V0.4 design
 pageConfig, // V1 design
 pageConfigGlobal) {
     const config = {};

package/dist/cjs/shared/page-configs/serialize/{parsePageConfigs.js → parsePageConfigsSerialized.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePageConfigs = parsePageConfigs;
+exports.parsePageConfigsSerialized = parsePageConfigsSerialized;
 exports.parseConfigValuesSerialized = parseConfigValuesSerialized;
 const utils_js_1 = require("../../utils.js");
 const getConfigDefinedAt_js_1 = require("../getConfigDefinedAt.js");
 const parse_1 = require("@brillout/json-serializer/parse");
 const assertPlusFileExport_js_1 = require("../assertPlusFileExport.js");
-function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
     // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -12,19 +12,19 @@ const pointerImports_js_1 = require("../../../node/vite/shared/resolveVikeConfig
 const helpers_js_1 = require("../helpers.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const resolveVikeConfigInternal_js_1 = require("../../../node/vite/shared/resolveVikeConfigInternal.js");
+const getConfigValueSourcesRelevant_js_1 = require("../../../node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js");
 const stringifyOptions = { forbidReactElements: true };
 const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
 const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
-// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
-// - vike/shared/page-configs/serialize/parsePageConfigs.ts
-// - parsePageConfigs() is loaded on both the client- and server-side.
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigsSerialized()
+// - vike/shared/page-configs/serialize/parsePageConfigsSerialized.ts
+// - parsePageConfigsSerialized() is loaded on both the client- and server-side.
 (0, utils_js_1.assertIsNotBrowser)();
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
-function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatch, tabspace, isEager) {
+function serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, tabspace, isEager) {
     const lines = [];
     tabspace += '  ';
-    getConfigValuesBase(pageConfig, isEnvMatch, isEager).forEach((entry) => {
+    getConfigValuesBase(pageConfig, runtimeEnv, isEager).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
             (0, utils_js_1.assert)('value' in entry); // Help TS
             const { configValueBase, value, configName, configEnv } = entry;
@@ -181,12 +181,12 @@ function logJsonSerializeError(err, configName, definedAtData) {
     (0, utils_js_1.assert)(configValueFilePathToShowToUser);
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined using a separate file ${picocolors_1.default.bold(`+${configName}.js`)}, see https://vike.dev/error/runtime-in-config`);
 }
-function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
+function getConfigValuesBase(pageConfig, runtimeEnv, isEager) {
     const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
         const { configEnv, value } = valueInfo;
-        if (!isEnvMatch(configEnv))
+        if (!(0, getConfigValueSourcesRelevant_js_1.isRuntimeEnvMatch)(configEnv, runtimeEnv))
             return 'SKIP';
-        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        // AFAICT this should never happen: I ain't aware of a use case for overriding computed values. If there is a use case, then configValueSources has higher precedence.
         if (pageConfig.configValueSources[configName])
             return 'SKIP';
         const configValueBase = {
@@ -195,16 +195,17 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
         };
         return { configValueBase, value, configName, configEnv };
     });
-    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName]) => {
         const configDef = pageConfig.configDefinitions[configName];
         (0, utils_js_1.assert)(configDef);
         if (isEager !== null && isEager !== !!configDef.eager)
             return 'SKIP';
         if (!configDef.cumulative) {
-            const source = sources[0];
-            (0, utils_js_1.assert)(source);
-            if (!isEnvMatch(source.configEnv))
+            const sourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(configName, runtimeEnv, pageConfig);
+            const source = sourcesRelevant[0];
+            if (!source)
                 return 'SKIP';
+            (0, utils_js_1.assert)(sourcesRelevant.length === 1);
             const definedAtFile = getDefinedAtFileSource(source);
             const configValueBase = {
                 type: 'standard',
@@ -213,9 +214,7 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
             return { configValueBase, sourceRelevant: source, configName };
         }
         else {
-            const sourcesRelevant = sources
-                .filter((source) => !(0, resolveVikeConfigInternal_js_1.isOverridden)(source, configName, pageConfig))
-                .filter((source) => isEnvMatch(source.configEnv));
+            const sourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(configName, runtimeEnv, pageConfig);
             if (sourcesRelevant.length === 0)
                 return 'SKIP';
             const definedAtData = [];

package/dist/cjs/shared/utils.js

@@ -45,3 +45,5 @@ __exportStar(require("../utils/objectDefineProperty.js"), exports);
 __exportStar(require("../utils/isScriptFile.js"), exports);
 __exportStar(require("../utils/objectFilter.js"), exports);
 __exportStar(require("../utils/getPropAccessNotation.js"), exports);
+__exportStar(require("../utils/getGlobalObject.js"), exports);
+__exportStar(require("../utils/genPromise.js"), exports);

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.236-commit-eab75f6';
+exports.PROJECT_VERSION = '0.4.237-commit-85e89b1';

package/dist/cjs/utils/cast.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cast = cast;
 exports.castProp = castProp;
 function cast(_thing) { }
-function castProp(_obj, _prop) { }
+function castProp(_obj, prop) { }

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

@@ -10,7 +10,7 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -23,7 +23,7 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & {
         isClientSide: true;

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

@@ -1,7 +1,7 @@
 export { setPageContextCurrent };
 export { getPageContextCurrent };
-import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
-type PageContextCurrent = VikeConfigPublicPageLazy & {
+import type { VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
+type PageContextCurrent = VikeConfigPublicPageLazyLoaded & {
     urlPathname: string;
 };
 declare function getPageContextCurrent(): null | PageContextCurrent;

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

@@ -5,7 +5,7 @@ export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
 export { execHookClient };
 export type { PageContextFromServerHooks };
-import type { VikeConfigPublicPageLazy, PageFile } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded, PageFile } from '../../shared/getPageFiles.js';
 import type { HookName } from '../../types/Config.js';
 import type { PageContextCreated } from './createPageContextClientSide.js';
 import type { PageContextBegin } from './renderPageClientSide.js';
@@ -18,7 +18,7 @@ declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContextBegin & VikeConfigPublicPageLazy & {
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContextBegin & VikeConfigPublicPageLazyLoaded & {
     _hasPageContextFromServer: true;
 } & PageContextForPublicUsageClient): Promise<PageContextSerialized & {
     _isOriginalObject: true;
@@ -30,7 +30,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -43,7 +43,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & {
         isClientSide: true;
@@ -70,7 +70,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     isHydration: boolean;
     previousPageContext: ({
         pageId: string;
-    } & VikeConfigPublicPageLazy & {
+    } & VikeConfigPublicPageLazyLoaded & {
         pageId: string;
         routeParams: Record<string, string>;
     } & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../types/PageContext.js").PageContextInternalClient & Omit<Partial<{
@@ -144,7 +144,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     } & {
         urlOriginal: string;
     }) | null;
-} & VikeConfigPublicPageLazy & {
+} & VikeConfigPublicPageLazyLoaded & {
     _hasPageContextFromServer: true;
 } & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & Omit<Partial<{
     isPageContext: true;
@@ -231,7 +231,7 @@ declare function getPageContextFromServerHooks(pageContext: {
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContextBegin & VikeConfigPublicPageLazy & PageContextForPublicUsageClient, isErrorPage: boolean): Promise<{
+} & PageContextBegin & VikeConfigPublicPageLazyLoaded & PageContextForPublicUsageClient, isErrorPage: boolean): Promise<{
     pageId: string;
     _hasPageContextFromServer: boolean;
 } & {
@@ -244,7 +244,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     _globalContext: {
         isGlobalContext: true;
         _isOriginalObject: true;
-        _virtualFileExports: unknown;
+        _virtualFileExportsGlobalEntry: unknown;
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -257,7 +257,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
         };
     } & {
         isClientSide: true;
@@ -284,7 +284,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     isHydration: boolean;
     previousPageContext: ({
         pageId: string;
-    } & VikeConfigPublicPageLazy & {
+    } & VikeConfigPublicPageLazyLoaded & {
         pageId: string;
         routeParams: Record<string, string>;
     } & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../types/PageContext.js").PageContextInternalClient & Omit<Partial<{
@@ -358,7 +358,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     } & {
         urlOriginal: string;
     }) | null;
-} & VikeConfigPublicPageLazy & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & Omit<Partial<{
+} & VikeConfigPublicPageLazyLoaded & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & Omit<Partial<{
     isPageContext: true;
     Page: import("../../types/Config.js").Config["Page"];
     routeParams: Record<string, string>;
@@ -429,7 +429,7 @@ declare function getPageContextFromClientHooks(pageContext: {
 } & {
     urlOriginal: string;
 }>;
-type PageContextExecHookClient = VikeConfigPublicPageLazy & PageContextForPublicUsageClient;
+type PageContextExecHookClient = VikeConfigPublicPageLazyLoaded & PageContextForPublicUsageClient;
 declare function execHookClient(hookName: HookName, pageContext: PageContextExecHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
     hookFn: (arg: import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
     hookTimeout: import("../../shared/hooks/getHook.js").HookTimeout;

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

@@ -23,7 +23,6 @@ const globalObject = getGlobalObject('runtime-client-routing/getPageContextFromH
 // TO-DO/eventually: rename
 function getPageContextFromHooks_serialized() {
     const pageContextSerialized = getPageContextSerializedInHtml();
-    assertUsage(!('urlOriginal' in pageContextSerialized), "Adding 'urlOriginal' to passToClient is forbidden");
     processPageContextFromServer(pageContextSerialized);
     objectAssign(pageContextSerialized, {
         _hasPageContextFromServer: true,
@@ -33,6 +32,9 @@ function getPageContextFromHooks_serialized() {
 // TO-DO/eventually: rename
 async function getPageContextFromHooks_isHydration(pageContext) {
     for (const hookName of ['data', 'onBeforeRender']) {
+        // TO-DO/soon/cumulative-hooks: filter & execute all client-only hooks
+        // - The client-side needs to know what hooks are client-only
+        //   - Possible implementation: new computed prop `clientOnlyHooks: string[]` (list of hook ids) and add `hookId` to serialized config values
         if (hookClientOnlyExists(hookName, pageContext)) {
             await execHookDataLike(hookName, pageContext);
         }
@@ -65,7 +67,7 @@ async function getPageContextFromServerHooks(pageContext, isErrorPage) {
     return { pageContextFromServerHooks };
 }
 async function getPageContextFromClientHooks(pageContext, isErrorPage) {
-    let dataHookExec = false;
+    let dataHookExecuted = false;
     // At this point, we need to call the client-side guard(), data() and onBeforeRender() hooks, if they exist on client
     // env. However if we have fetched pageContext from the server, some of them might have run already on the
     // server-side, so we run only the client-only ones in this case.
@@ -82,9 +84,10 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
             }
         }
         else {
+            // TO-DO/soon/cumulative-hooks: filter & execute all client-only hooks (see other TO-DO/soon/cumulative-hooks entries)
             if (hookClientOnlyExists(hookName, pageContext) || !pageContext._hasPageContextFromServer) {
                 if (hookName === 'data')
-                    dataHookExec = true;
+                    dataHookExecuted = true;
                 // This won't do anything if no hook has been defined or if the hook's env.client is false.
                 await execHookDataLike(hookName, pageContext);
             }
@@ -92,7 +95,7 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
     }
     // Execute +onData
     const dataHookEnv = getHookEnv('data', pageContext);
-    if ((dataHookExec && dataHookEnv.client) || (pageContext._hasPageContextFromServer && dataHookEnv.server)) {
+    if ((dataHookExecuted && dataHookEnv.client) || (pageContext._hasPageContextFromServer && dataHookEnv.server)) {
         await execHookClient('onData', pageContext);
     }
     const pageContextFromClientHooks = pageContext;
@@ -154,61 +157,40 @@ function setPageContextInitIsPassedToClient(pageContext) {
 }
 // TO-DO/next-major-release: make it sync
 async function hasPageContextServer(pageContext) {
-    return (!!globalObject.pageContextInitIsPassedToClient ||
-        (await hookServerOnlyExists('data', pageContext)) ||
-        (await hookServerOnlyExists('onBeforeRender', pageContext)));
-}
-// TO-DO/next-major-release: make it sync
-/**
- * @param hookName
- * @param pageContext
- * @returns `true` if the given page has a `hookName` hook defined with a server-only env.
- */
-async function hookServerOnlyExists(hookName, pageContext) {
-    if (pageContext._globalContext._pageConfigs.length > 0) {
-        // V1
-        const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
-        const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value;
-        if (hookEnv === null)
-            return false;
-        assert(isObject(hookEnv));
-        const { client, server } = hookEnv;
-        assert(client === true || client === undefined);
-        assert(server === true || server === undefined);
-        assert(client || server);
-        return !!server && !client;
-    }
-    else {
-        // TO-DO/next-major-release: remove
-        // V0.4
-        // data() hooks didn't exist in the V0.4 design
-        if (hookName === 'data')
-            return false;
-        assert(hookName === 'onBeforeRender');
+    if (isOldDesign(pageContext)) {
         const { hasOnBeforeRenderServerSideOnlyHook } = await analyzePageServerSide(pageContext._pageFilesAll, pageContext.pageId);
+        // data() hooks didn't exist in the V0.4 design
         return hasOnBeforeRenderServerSideOnlyHook;
     }
+    return !!globalObject.pageContextInitIsPassedToClient || hasServerOnlyHook(pageContext);
+}
+function hasServerOnlyHook(pageContext) {
+    if (isOldDesign(pageContext))
+        return false;
+    const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
+    const val = getConfigValueRuntime(pageConfig, `serverOnlyHooks`)?.value;
+    assert(val === true || val === false);
+    return val;
 }
 function hookClientOnlyExists(hookName, pageContext) {
     const hookEnv = getHookEnv(hookName, pageContext);
     return !!hookEnv.client && !hookEnv.server;
 }
 function getHookEnv(hookName, pageContext) {
-    if (pageContext._globalContext._pageConfigs.length > 0) {
-        // V1
-        const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
-        // No runtime validation to save client-side KBs
-        const hookEnv = (getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {});
-        return hookEnv;
-    }
-    else {
-        // TO-DO/next-major-release: remove
+    if (isOldDesign(pageContext)) {
         // Client-only onBeforeRender() or data() hooks were never supported for the V0.4 design
         return { client: false, server: true };
     }
+    const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
+    // No runtime validation to save client-side KBs
+    const hookEnv = (getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {});
+    return hookEnv;
 }
 async function fetchPageContextFromServer(pageContext) {
-    const pageContextUrl = getPageContextRequestUrl(pageContext._urlRewrite ?? pageContext.urlOriginal);
+    let pageContextUrl = getPageContextRequestUrl(pageContext._urlRewrite ?? pageContext.urlOriginal);
+    /* TO-DO/soon/once: pass & use previousUrl
+    pageContextUrl = modifyUrlSameOrigin(pageContextUrl, { search: { _vike: JSON.stringify({ previousUrl: pageContext.previousPageContext.urlOriginal }) } })
+    */
     const response = await fetch(pageContextUrl);
     {
         const contentType = response.headers.get('content-type');
@@ -231,10 +213,15 @@ async function fetchPageContextFromServer(pageContext) {
     if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
         throw getProjectError(`pageContext couldn't be fetched because an error occurred on the server-side`);
     }
-    assert(hasProp(pageContextFromServer, 'pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);
     return { pageContextFromServer };
 }
-function processPageContextFromServer(pageContextFromServer) {
-    removeBuiltInOverrides(pageContextFromServer);
+function processPageContextFromServer(pageContext) {
+    assertUsage(!('urlOriginal' in pageContext), "Adding 'urlOriginal' to passToClient is forbidden");
+    assert(hasProp(pageContext, 'pageId', 'string'));
+    removeBuiltInOverrides(pageContext);
+}
+// TO-DO/next-major-release: remove
+function isOldDesign(pageContext) {
+    return pageContext._globalContext._pageConfigs.length === 0;
 }

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

@@ -7,7 +7,7 @@ type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextCli
 declare const getGlobalContextClientInternal: () => Promise<{
     isGlobalContext: true;
     _isOriginalObject: true;
-    _virtualFileExports: unknown;
+    _virtualFileExportsGlobalEntry: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -20,7 +20,7 @@ declare const getGlobalContextClientInternal: () => Promise<{
     };
     config: import("../../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
     };
 } & {
     isClientSide: true;

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

@@ -2,8 +2,8 @@ export { getGlobalContextClientInternal };
 import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 // @ts-ignore
-import * as virtualFileExports from 'virtual:vike:entry:client:client-routing';
-const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, true, addGlobalContext);
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:client-routing';
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExportsGlobalEntry, true, addGlobalContext);
 async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return {

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

@@ -2,8 +2,7 @@ export { pushHistoryState };
 export { replaceHistoryStateOriginal };
 export { onPopStateBegin };
 export { saveScrollPosition };
-export { initHistoryState };
-export { monkeyPatchHistoryAPI };
+export { initHistory };
 export type { HistoryInfo };
 export type { ScrollPosition };
 type StateEnhanced = {
@@ -18,8 +17,7 @@ type ScrollPosition = {
 };
 declare function saveScrollPosition(): void;
 declare function pushHistoryState(url: string, overwriteLastHistoryEntry: boolean): void;
-declare function replaceHistoryStateOriginal(state: unknown, url: string): void;
-declare function monkeyPatchHistoryAPI(): void;
+declare function replaceHistoryStateOriginal(state: unknown, url: Parameters<typeof window.history.replaceState>[2]): void;
 type HistoryInfo = {
     url: `/${string}`;
     state: StateEnhanced;
@@ -29,4 +27,4 @@ declare function onPopStateBegin(): {
     previous: HistoryInfo;
     current: HistoryInfo;
 };
-declare function initHistoryState(): void;
+declare function initHistory(): void;

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

@@ -2,21 +2,23 @@ export { pushHistoryState };
 export { replaceHistoryStateOriginal };
 export { onPopStateBegin };
 export { saveScrollPosition };
-export { initHistoryState };
-export { monkeyPatchHistoryAPI };
+export { initHistory };
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { assert, assertUsage, getGlobalObject, isObject } from './utils.js';
-initHistoryState(); // we redundantly call initHistoryState() to ensure it's called early
-const globalObject = getGlobalObject('runtime-client-routing/history.ts', { previous: getHistoryInfo() });
+import { assert, assertUsage, getGlobalObject, isObject, deepEqual, cast } from './utils.js';
+const globalObject = getGlobalObject('history.ts', {
+    monkeyPatched: false,
+    previous: undefined,
+});
+initHistory(); // we redundantly call initHistory() to ensure it's called early
+globalObject.previous = getHistoryInfo();
 // `window.history.state === null` when:
 // - The very first render
 // - Click on `<a href="#some-hash" />`
 // - `location.hash = 'some-hash'`
 function enhanceHistoryState() {
-    const stateNotEnhanced = getStateNotEnhanced();
-    if (isVikeEnhanced(stateNotEnhanced))
+    if (isVikeEnhanced(window.history.state))
         return;
-    const stateVikeEnhanced = enhance(stateNotEnhanced);
+    const stateVikeEnhanced = enhance(window.history.state);
     replaceHistoryState(stateVikeEnhanced);
 }
 function enhance(stateNotEnhanced) {
@@ -34,6 +36,7 @@ function enhance(stateNotEnhanced) {
     }
     else {
         // State information may be incomplete if `window.history.state` is set by an old Vike version. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
+        cast(stateNotEnhanced);
         stateVikeEnhanced = {
             timestamp: stateNotEnhanced.timestamp ?? timestamp,
             scrollPosition: stateNotEnhanced.scrollPosition ?? scrollPosition,
@@ -41,21 +44,17 @@ function enhance(stateNotEnhanced) {
             _isVikeEnhanced: true,
         };
     }
-    assert(isVikeEnhanced(stateVikeEnhanced));
+    assertIsVikeEnhanced(stateVikeEnhanced);
     return stateVikeEnhanced;
 }
 function getState() {
-    const state = getStateNotEnhanced();
+    const state = window.history.state;
     // *Every* state added to the history needs to go through Vike.
     // - Otherwise Vike's `popstate` listener won't work. (Because, for example, if globalObject.previous is outdated => isHashNavigation faulty => client-side navigation is wrongfully skipped.)
     // - Therefore, we have to monkey patch history.pushState() and history.replaceState()
     // - Therefore, we need the assert() below to ensure history.state has been enhanced by Vike
     //   - If users stumble upon this assert() then let's make it a assertUsage()
-    assert(isVikeEnhanced(state), { state });
-    return state;
-}
-function getStateNotEnhanced() {
-    const state = window.history.state;
+    assertIsVikeEnhanced(state);
     return state;
 }
 function getScrollPosition() {
@@ -90,6 +89,7 @@ function pushHistoryState(url, overwriteLastHistoryEntry) {
 function replaceHistoryState(state, url) {
     const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
     window.history.replaceState(state, '', url_);
+    assertIsVikeEnhanced(window.history.state);
 }
 function replaceHistoryStateOriginal(state, url) {
     // Bypass all monkey patches.
@@ -100,7 +100,9 @@ function replaceHistoryStateOriginal(state, url) {
 // - history.pushState()
 // - history.replaceState()
 function monkeyPatchHistoryAPI() {
-    ;
+    if (globalObject.monkeyPatched)
+        return;
+    globalObject.monkeyPatched = true;
     ['pushState', 'replaceState'].forEach((funcName) => {
         const funcOriginal = window.history[funcName].bind(window.history);
         window.history[funcName] = (stateOriginal = {}, ...rest) => {
@@ -114,10 +116,19 @@ function monkeyPatchHistoryAPI() {
                     triggeredBy: 'user',
                     ...stateOriginal,
                 };
-            assert(isVikeEnhanced(stateEnhanced));
-            const ret = funcOriginal(stateEnhanced, ...rest);
+            assertIsVikeEnhanced(stateEnhanced);
+            funcOriginal(stateEnhanced, ...rest);
+            assert(deepEqual(stateEnhanced, window.history.state));
             globalObject.previous = getHistoryInfo();
-            return ret;
+            // Workaround https://github.com/vikejs/vike/issues/2504#issuecomment-3149764736
+            queueMicrotask(() => {
+                if (deepEqual(stateEnhanced, window.history.state))
+                    return;
+                Object.assign(stateEnhanced, window.history.state);
+                assertIsVikeEnhanced(stateEnhanced);
+                replaceHistoryStateOriginal(stateEnhanced, rest[1]);
+                assert(deepEqual(stateEnhanced, window.history.state));
+            });
         };
     });
 }
@@ -136,6 +147,11 @@ function isVikeEnhanced(state) {
     }
     return false;
 }
+function assertIsVikeEnhanced(state) {
+    if (isVikeEnhanced(state))
+        return;
+    assert(false, { state });
+}
 function getHistoryInfo() {
     return {
         url: getCurrentUrl(),
@@ -147,11 +163,12 @@ function onPopStateBegin() {
     const isHistoryStateEnhanced = window.history.state !== null;
     if (!isHistoryStateEnhanced)
         enhanceHistoryState();
-    assert(isVikeEnhanced(window.history.state));
+    assertIsVikeEnhanced(window.history.state);
     const current = getHistoryInfo();
     globalObject.previous = current;
     return { isHistoryStateEnhanced, previous, current };
 }
-function initHistoryState() {
-    enhanceHistoryState();
+function initHistory() {
+    monkeyPatchHistoryAPI(); // the earlier we call it the better (Vike can workaround erroneous library monkey patches if Vike is the last one in the monkey patch chain)
+    enhanceHistoryState(); // enhance very first window.history.state which is `null`
 }