vike 0.4.236-commit-eab75f6 → 0.4.237

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configDefinitionsBuiltIn = void 0;
 const utils_js_1 = require("../../utils.js");
 const getConfigDefinedAt_js_1 = require("../../../../shared/page-configs/getConfigDefinedAt.js");
+const getConfigValueSourcesRelevant_js_1 = require("../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js");
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -97,6 +98,22 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true },
     },
+    serverOnlyHooks: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            const sources = ['data', 'onBeforeRender', 'onCreatePageContext']
+                .map((hookName) => (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(hookName, {
+                isForClientSide: false,
+                // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                isClientRouting: true,
+            }, pageConfig))
+                .flat(1)
+                // Server-only
+                .filter((source) => !source.configEnv.client);
+            return sources.length > 0;
+        },
+    },
     // Whether the page loads:
     //  - Vike's client runtime
     //  - User's client hooks
@@ -104,7 +121,8 @@ const configDefinitionsBuiltIn = {
     isClientRuntimeLoaded: {
         env: { server: true, client: true },
         eager: true,
-        _computed: (configValueSources) => {
+        _computed: (pageConfig) => {
+            const { configValueSources } = pageConfig;
             {
                 const source = getConfigValueSource(configValueSources, 'clientHooks');
                 if (source) {
@@ -122,15 +140,25 @@ const configDefinitionsBuiltIn = {
                 !!getConfigEnv(configValueSources, 'Page')?.client);
         },
     },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
     onBeforeRenderEnv: {
         env: { client: true },
         eager: true,
-        _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender'),
+        _computed: (pageConfig) => {
+            const { configValueSources } = pageConfig;
+            return !isConfigSet(configValueSources, 'onBeforeRender')
+                ? null
+                : getConfigEnv(configValueSources, 'onBeforeRender');
+        },
     },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
     dataEnv: {
         env: { client: true },
         eager: true,
-        _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data'),
+        _computed: (pageConfig) => {
+            const { configValueSources } = pageConfig;
+            return !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data');
+        },
     },
     hooksTimeout: {
         env: { server: true, client: true },

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

@@ -12,7 +12,6 @@ exports.isV1Design = isV1Design;
 exports.getConfVal = getConfVal;
 exports.getConfigDefinitionOptional = getConfigDefinitionOptional;
 exports.getVikeConfigFromCliOrEnv = getVikeConfigFromCliOrEnv;
-exports.isOverridden = isOverridden;
 exports.getVikeConfig = getVikeConfig;
 const utils_js_1 = require("../utils.js");
 const configDefinitionsBuiltIn_js_1 = require("./resolveVikeConfigInternal/configDefinitionsBuiltIn.js");
@@ -290,15 +289,16 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
         applyEffectsMetaEnv(configValueSources, configDefinitionsLocal);
         applyEffectsConfVal(configValueSources, configDefinitionsLocal, plusFilesAll);
         sortConfigValueSources(configValueSources, locationId);
-        const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
             ...pageConfigRoute,
             configDefinitions: configDefinitionsLocal,
             plusFiles: plusFilesRelevant,
             configValueSources,
-            configValuesComputed,
         };
+        const configValuesComputed = getComputed(pageConfig);
+        (0, utils_js_1.objectAssign)(pageConfig, { configValuesComputed });
+        (0, utils_js_1.checkType)(pageConfig);
         return pageConfig;
     });
     assertPageConfigs(pageConfigs);
@@ -365,7 +365,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
 }
 function getConfigValues(pageConfig, tolerateMissingValue) {
     const configValues = {};
-    (0, serializeConfigValues_js_1.getConfigValuesBase)(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
+    (0, serializeConfigValues_js_1.getConfigValuesBase)(pageConfig, { isForConfig: true }, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
             (0, utils_js_1.assert)('value' in entry); // Help TS
             const { configValueBase, value, configName } = entry;
@@ -899,12 +899,12 @@ function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEf
         });
     });
 }
-function getComputed(configValueSources, configDefinitions) {
+function getComputed(pageConfig) {
     const configValuesComputed = {};
-    (0, utils_js_1.objectEntries)(configDefinitions).forEach(([configName, configDef]) => {
+    (0, utils_js_1.objectEntries)(pageConfig.configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
-        const value = configDef._computed(configValueSources);
+        const value = configDef._computed(pageConfig);
         if (value === undefined)
             return;
         configValuesComputed[configName] = {
@@ -1100,17 +1100,6 @@ function isGlobalLocation(locationId, plusFilesAll) {
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => (0, filesystemRouting_js_1.isInherited)(locationId, locId));
 }
-function isOverridden(source, configName, pageConfig) {
-    const configDef = pageConfig.configDefinitions[configName];
-    (0, utils_js_1.assert)(configDef);
-    if (configDef.cumulative)
-        return false;
-    const sources = pageConfig.configValueSources[configName];
-    (0, utils_js_1.assert)(sources);
-    const idx = sources.indexOf(source);
-    (0, utils_js_1.assert)(idx >= 0);
-    return idx > 0;
-}
 function resolvePrerenderContext(vikeConfig) {
     const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
     prerenderContext ?? (prerenderContext = {

package/dist/cjs/shared/createGlobalContextShared.js

@@ -10,9 +10,21 @@ const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextF
 const getHook_js_1 = require("./hooks/getHook.js");
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
+const globalObject_ = (0, utils_js_1.getGlobalObject)('shared/createGlobalContextShared.ts', {});
+// TO-DO/eventually use flat globalContext — like flat pageContext
 async function createGlobalContextShared(virtualFileExports, 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 { previousCallPromise } = globalObject_;
+    const { promise, resolve } = (0, utils_js_1.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_.previousCallPromise = promise;
+    await previousCallPromise;
     const globalContext = createGlobalContextBase(virtualFileExports);
     let isNewGlobalContext;
     if (!globalObject.globalContext) {
@@ -55,6 +67,7 @@ addGlobalContextTmp, addGlobalContextAsync) {
             (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext, true);
         }
     }
+    resolve();
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {

package/dist/cjs/shared/modifyUrlSameOrigin.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modifyUrlSameOrigin = modifyUrlSameOrigin;
+// We don't move modifyUrlSameOrigin() to the modifyUrl.ts file because we plan to use modifyUrlSameOrigin() on the client-side:
+// https://github.com/vikejs/vike/blob/c5a2de5e85262771f97851767c00ac35da69c64b/packages/vike/client/runtime-client-routing/navigate.ts#L4
 const utils_js_1 = require("./utils.js");
 function modifyUrlSameOrigin(url, modify) {
     const urlParsed = (0, utils_js_1.parseUrl)(url, '/');
@@ -27,16 +29,19 @@ function modifyUrlSameOrigin(url, modify) {
     const urlModified = (0, utils_js_1.createUrlFromComponents)(urlParsed.origin, pathname, search, hash);
     return urlModified;
 }
-function resolveSearch(urlParsed, search) {
+function resolveSearch(urlParsed, modifySearch) {
     let searchParams;
-    if (search instanceof URLSearchParams) {
+    if (modifySearch instanceof URLSearchParams) {
         // Overwrite
-        searchParams = search;
+        searchParams = modifySearch;
     }
     else {
         // Merge
-        const searchMap = (0, utils_js_1.objectFilter)({ ...urlParsed.search, ...search }, (utils_js_1.isNotNullish_keyVal));
+        const searchMap = (0, utils_js_1.objectFilter)({ ...urlParsed.search, ...(0, utils_js_1.objectFilter)(modifySearch, isNotUndefined) }, (utils_js_1.isNotNullish_keyVal));
         searchParams = new URLSearchParams(searchMap);
     }
     return '?' + searchParams.toString();
 }
+function isNotUndefined(arg) {
+    return arg[1] !== undefined;
+}

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

@@ -12,7 +12,7 @@ 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__';
@@ -21,10 +21,10 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // - parsePageConfigs() 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';

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/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/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`
 }

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

@@ -6,7 +6,7 @@ import { initOnLinkClick } from './initOnLinkClick.js';
 import { scrollRestoration_init } from './scrollRestoration.js';
 import { autoSaveScrollPosition } from './setScrollPosition.js';
 import { initLinkPrefetchHandlers } from './prefetch.js';
-import { initHistoryState, monkeyPatchHistoryAPI } from './history.js';
+import { initHistory } from './history.js';
 async function initClientRouter() {
     // Init navigation history and scroll restoration
     initHistoryAndScroll();
@@ -29,8 +29,7 @@ async function renderFirstPage() {
 }
 function initHistoryAndScroll() {
     scrollRestoration_init();
-    monkeyPatchHistoryAPI();
-    initHistoryState(); // we redundantly call initHistoryState() to ensure it's called early
+    initHistory(); // we redundantly call initHistory() to ensure it's called early
     autoSaveScrollPosition();
     // Handle back-/forward navigation
     initOnPopState();

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

@@ -22,3 +22,5 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/catchInfiniteLoop.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/cast.js';

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

@@ -26,3 +26,5 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/catchInfiniteLoop.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/cast.js';

package/dist/esm/client/shared/createGetGlobalContextClient.js

@@ -20,10 +20,8 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
     getGlobalContext();
     return getGlobalContext;
     async function getGlobalContext() {
-        // Cache
-        if (globalObject.virtualFileExports &&
-            // Don't break HMR
-            globalObject.virtualFileExports === virtualFileExports) {
+        // HMR => virtualFileExports differ
+        if (globalObject.virtualFileExports === virtualFileExports) {
             const globalContext = await globalObject.globalContextPromise;
             return globalContext;
         }