vike 0.4.236 → 0.4.237-commit-8749e81

package/dist/cjs/utils/isRunnableDevEnvironment.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRunnableDevEnvironment = isRunnableDevEnvironment;
+// We use this instead of `import { isRunnableDevEnvironment } from 'vite'` because:
+// - Vite's isRunnableDevEnvironment() isn't reliable in monorepos where multiple Vite instances can be used simultaneously (it uses `instanceof RunnableDevEnvironment` which fails)
+// - We can use this in Vike's server production runtime without having to load the 'vite' package
+function isRunnableDevEnvironment(environment) {
+    return !!environment && 'runner' in environment && !!environment.runner;
+}

package/dist/cjs/utils/virtualFileId.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVirtualFileId = isVirtualFileId;
+exports.addVirtualFileIdPrefix = addVirtualFileIdPrefix;
+exports.removeVirtualFileIdPrefix = removeVirtualFileIdPrefix;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const idBase = 'virtual:vike:';
+// https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+const prefix = '\0';
+function isVirtualFileId(id) {
+    if (id.startsWith(idBase))
+        return true;
+    if (id.startsWith(prefix + idBase))
+        return true;
+    // https://github.com/vikejs/vike/issues/1985
+    (0, assert_js_1.assertUsage)(!id.includes(idBase), `Encountered a module ID ${picocolors_1.default.cyan(id)} that is unexpected. Are you using a tool that modifies the ID of modules? For example, the baseUrl setting in tsconfig.json cannot be used.`);
+    return false;
+}
+function addVirtualFileIdPrefix(id) {
+    (0, assert_js_1.assert)(isVirtualFileId(id));
+    if (!id.startsWith(prefix)) {
+        id = prefix + id;
+    }
+    (0, assert_js_1.assert)(id.startsWith(prefix));
+    return id;
+}
+function removeVirtualFileIdPrefix(id) {
+    if (id.startsWith(prefix)) {
+        id = id.slice(prefix.length);
+    }
+    (0, assert_js_1.assert)(!id.startsWith(prefix));
+    return id;
+}

package/dist/esm/client/node.js

@@ -1,4 +1,4 @@
-import { assertUsage } from './runtime-server-routing/utils.js';
+import { assertUsage } from '../utils/assert.js';
 assertUsage(false, [
     'Server imports are forbidden on the client-side:',
     "  import { something } from 'vike/server'",

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,14 +23,14 @@ 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;
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;

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,14 +43,14 @@ 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;
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;
@@ -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,14 +257,14 @@ 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;
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;
@@ -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,11 +20,11 @@ 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;
 } & {
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-}>;
+} & Record<string, any>>;

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

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/prefetch/getPrefetchSettings.d.ts

@@ -1,10 +1,10 @@
 export { getPrefetchSettings };
 export { PAGE_CONTEXT_MAX_AGE_DEFAULT };
 export type { PrefetchSettingResolved };
-import type { VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../../shared/getPageFiles.js';
 declare const PAGE_CONTEXT_MAX_AGE_DEFAULT = 5000;
 type PrefetchSettingResolved = {
     staticAssets: false | 'hover' | 'viewport';
     pageContext: false | number;
 };
-declare function getPrefetchSettings(pageContext: VikeConfigPublicPageLazy, linkTag: null | HTMLElement): PrefetchSettingResolved;
+declare function getPrefetchSettings(pageContext: VikeConfigPublicPageLazyLoaded, linkTag: null | HTMLElement): PrefetchSettingResolved;

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

@@ -7,14 +7,14 @@ export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { type PageContextCreated } from './createPageContextClientSide.js';
 import { type PageContextFromServerHooks, getPageContextFromServerHooks } from './getPageContextFromHooks.js';
-import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 type ResultPageContextFromServer = Awaited<ReturnType<typeof getPageContextFromServerHooks>>;
 type PageContextForPrefetch = PageContextCreated & {
     pageId: string;
 };
 declare function getPageContextPrefetched(pageContext: {
     urlPathname: string;
-} & VikeConfigPublicPageLazy): null | PageContextFromServerHooks;
+} & VikeConfigPublicPageLazyLoaded): null | PageContextFromServerHooks;
 declare function populatePageContextPrefetchCache(pageContext: PageContextForPrefetch, result: ResultPageContextFromServer): void;
 /**
  * Programmatically prefetch client assets.

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

@@ -60,8 +60,8 @@ async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge)
     const result = await getPageContextFromServerHooks(pageContextLink, false);
     setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
 }
-function populatePageContextPrefetchCache(pageContext /*& VikeConfigPublicPageLazy*/, result) {
-    // TO-DO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use VikeConfigPublicPageLazy as it isn't available here.)
+function populatePageContextPrefetchCache(pageContext /*& VikeConfigPublicPageLazyLoaded*/, result) {
+    // TO-DO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use VikeConfigPublicPageLazyLoaded as it isn't available here.)
     if (!isBrilloutDocpress())
         return;
     setPageContextPrefetchCache(pageContext, result, null);

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

@@ -1,9 +1,9 @@
 export { preparePageContextForPublicUsageClient };
 export type { PageContextForPublicUsageClient };
-import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 import type { PageContextInternalClient_ClientRouting } from '../../types/PageContext.js';
 import type { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
-type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ClientRouting & VikeConfigPublicPageLazy & {
+type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ClientRouting & VikeConfigPublicPageLazyLoaded & {
     urlOriginal: string;
 };
 declare function preparePageContextForPublicUsageClient<PageContext extends PageContextForPublicUsageClient>(pageContext: PageContext): PageContext & {