vike 0.4.199 → 0.4.200-commit-de0e6ef

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

@@ -0,0 +1,72 @@
+export { initOnPopState };
+export { onPopState };
+import { assertWarning, getGlobalObject } from './utils.js';
+import { onPopStateBegin } from './history.js';
+import { renderPageClientSide } from './renderPageClientSide.js';
+import { setScrollPosition } from './setScrollPosition.js';
+const globalObject = getGlobalObject('initOnPopState.ts', { listeners: [] });
+function initOnPopState() {
+    // - The popstate event is trigged upon:
+    //   - Back-/forward navigation.
+    //     - By user clicking on his browser's back-/forward navigation (or using a shortcut)
+    //     - By JavaScript: `history.back()` / `history.forward()`
+    //   - URL hash change.
+    //     - Click on `<a href="#some-hash" />`
+    //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
+    //     - `location.hash = 'some-hash'`
+    // - The `event` argument of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', async () => {
+        const { isNewState, previous, current } = onPopStateBegin();
+        const scrollTarget = current.state.scrollPosition || undefined;
+        const isUserPushStateNavigation = current.state.triggeredBy === 'user' || previous.state.triggeredBy === 'user';
+        const isHashNavigation = removeHash(current.url) === removeHash(previous.url) && current.url !== previous.url;
+        // - `isNewState === true` when:
+        //   - Click on `<a href="#some-hash" />` (note that Vike's `initOnLinkClick()` handler skips hash links)
+        //   - `location.hash = 'some-hash'`
+        // - `isNewState === false` when `popstate` was triggered by the user clicking on his browser's forward/backward history button.
+        const isHashNavigationNew = isHashNavigation && isNewState;
+        const isBackwardNavigation = !current.state.timestamp || !previous.state.timestamp ? null : current.state.timestamp < previous.state.timestamp;
+        // We have to scroll ourselves because we use `window.history.scrollRestoration = 'manual'`. So far this seems to work. Alternatives in case it doesn't work:
+        // - Alternative: we use `window.history.scrollRestoration = 'auto'`
+        //   - Problem: I don't think it's possbible to set `window.history.scrollRestoration = 'auto'` only for hash navigation and not for non-hash navigations?
+        //   - Problem: inconsistencies between browsers? For example specification says that setting `window.history.scrollRestoration` only affects the current entry in the session history but this contradicts what people are experiencing in practice.
+        //     - Specification: https://html.spec.whatwg.org/multipage/history.html#the-history-interface
+        //     - Practice: https://stackoverflow.com/questions/70188241/history-scrollrestoration-manual-doesnt-prevent-safari-from-restoring-scrol
+        // - Alternative: we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
+        //   - By using the `hashchange` event.
+        //   - Problem: conflict if user wants to override the browser's default behavior? E.g. for smooth scrolling, or when using hashes for saving states of some fancy animations.
+        if (isHashNavigation) {
+            if (!isHashNavigationNew) {
+                setScrollPosition(scrollTarget);
+            }
+            else {
+                // The browser already scrolled to `#${hash}` => the current scroll position is the right one => we saved it with `enhanceHistoryState()`.
+            }
+            return;
+        }
+        let doNotRenderIfSamePage = isUserPushStateNavigation;
+        let abort;
+        globalObject.listeners.forEach((listener) => {
+            abort || (abort = listener({ previous }));
+        });
+        if (abort) {
+            return;
+        }
+        if (abort === false) {
+            doNotRenderIfSamePage = false;
+        }
+        await renderPageClientSide({ scrollTarget, isBackwardNavigation, doNotRenderIfSamePage });
+    });
+}
+// TODO/eventually: deprecate this onPopState(listener) function and let the user define +onPopState.js instead?
+/** Control back-/forward navigation.
+ *
+ * https://vike.dev/onPopState
+ */
+function onPopState(listener) {
+    assertWarning(false, 'onPopState() is experimental', { onlyOnce: true });
+    globalObject.listeners.push(listener);
+}
+function removeHash(url) {
+    return url.split('#')[0];
+}

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

@@ -12,8 +12,7 @@ type RenderArgs = {
     overwriteLastHistoryEntry?: boolean;
     pageContextsFromRewrite?: PageContextFromRewrite[];
     redirectCount?: number;
-    /** Whether the navigation was triggered by the user land calling `history.pushState()` */
-    isUserLandPushStateNavigation?: boolean;
+    doNotRenderIfSamePage?: boolean;
     isClientSideNavigation?: boolean;
 };
 declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;

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

@@ -10,12 +10,11 @@ import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook, getHook } from '../../shared/hooks/getHook.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
-import { pushHistory } from './history.js';
+import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { setScrollPosition } from './setScrollPosition.js';
-import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
@@ -30,7 +29,7 @@ const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
 })());
 const { firstRenderStartPromise } = globalObject;
 async function renderPageClientSide(renderArgs) {
-    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, doNotRenderIfSamePage, isClientSideNavigation = true } = renderArgs;
     let { scrollTarget } = renderArgs;
     const { previousPageContext } = globalObject;
     addLinkPrefetchHandlers_unwatch();
@@ -120,7 +119,7 @@ async function renderPageClientSide(renderArgs) {
             const isSamePage = pageContextFromRoute.pageId &&
                 previousPageContext?.pageId &&
                 pageContextFromRoute.pageId === previousPageContext.pageId;
-            if (isUserLandPushStateNavigation && isSamePage) {
+            if (doNotRenderIfSamePage && isSamePage) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
             }
@@ -476,8 +475,7 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     if (getCurrentUrl() === url)
         return;
     browserNativeScrollRestoration_disable();
-    pushHistory(url, overwriteLastHistoryEntry);
-    updateState();
+    pushHistoryState(url, overwriteLastHistoryEntry);
 }
 function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
     if (!isErrorFetchingStaticAssets(err)) {

package/dist/esm/node/client/router.d.ts

@@ -1,6 +1,8 @@
 export { navigate };
 export { reload };
 export { prefetch };
+export { onPopState };
 declare const navigate: never;
 declare const reload: never;
 declare const prefetch: never;
+declare const onPopState: never;

package/dist/esm/node/client/router.js

@@ -1,11 +1,13 @@
 export { navigate };
 export { reload };
 export { prefetch };
+export { onPopState };
 import { assertWarning } from '../../utils/assert.js';
 // `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
 const navigate = (() => warnNoEffect('navigate'));
 const reload = (() => warnNoEffect('reload'));
 const prefetch = (() => warnNoEffect('prefetch'));
+const onPopState = (() => { });
 function warnNoEffect(caller) {
     assertWarning(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,

package/dist/esm/node/plugin/plugins/envVars.js

@@ -3,6 +3,7 @@ import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { normalizeId } from '../shared/normalizeId.js';
 // TODO/enventually: (after we implemented vike.config.js)
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -25,9 +26,11 @@ function envVarsPlugin() {
             config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
         },
         transform(code, id, options) {
+            id = normalizeId(id);
             assertPosixPath(id);
             if (id.includes('/node_modules/'))
                 return;
+            assertPosixPath(config.root);
             if (!id.startsWith(config.root))
                 return;
             if (!code.includes('import.meta.env.'))

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -16,6 +16,7 @@ import pc from '@brillout/picocolors';
 import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
+import { normalizeId } from '../shared/normalizeId.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -34,6 +35,7 @@ function extractAssetsPlugin() {
             apply: 'build',
             enforce: 'post',
             async transform(src, id, options) {
+                id = normalizeId(id);
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }

package/dist/esm/node/plugin/plugins/extractExportNamesPlugin.js

@@ -4,6 +4,7 @@ export { extractExportNamesRE };
 import { assert, getFileExtension, viteIsSSR_options, createDebugger, getGlobalObject, assertUsage } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
+import { normalizeId } from '../shared/normalizeId.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebugger('vike:extractExportNames');
 const globalObject = getGlobalObject('extractExportNamesPlugin.ts', {});
@@ -13,6 +14,7 @@ function extractExportNamesPlugin() {
         name: 'vike:extractExportNames',
         enforce: 'post',
         async transform(src, id, options) {
+            id = normalizeId(id);
             const isClientSide = !viteIsSSR_options(options);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);

package/dist/esm/node/plugin/plugins/fileEnv.js

@@ -6,6 +6,7 @@ import pc from '@brillout/picocolors';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { getExportNames } from '../shared/parseEsModule.js';
+import { normalizeId } from '../shared/normalizeId.js';
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -31,6 +32,7 @@ function fileEnv() {
         },
         // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
         async transform(code, id, options) {
+            id = normalizeId(id);
             // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
             if (viteDevServer)
                 return;

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -1,6 +1,6 @@
 export { importBuild };
 export { set_ASSETS_MAP };
-import { serverEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
+import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
@@ -24,15 +24,15 @@ function importBuild() {
                 configVike = await getConfigVike(config);
             }
         },
-        ...serverEntryPlugin({
-            getImporterCode: () => {
-                return getEntryCode(config, configVike);
+        ...serverProductionEntryPlugin({
+            getServerProductionEntry: () => {
+                return getServerProductionEntryCode(config, configVike);
             },
             libraryName: 'Vike'
         })
     ];
 }
-function getEntryCode(config, configVike) {
+function getServerProductionEntryCode(config, configVike) {
     const importPath = getImportPath(config);
     const vikeManifest = getVikeManifest(configVike);
     const importerCode = [

package/dist/esm/node/plugin/plugins/importUserCode/index.js

@@ -6,7 +6,7 @@ import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js'
 import { assert, assertPosixPath, getOutDirs, getVirtualFileId, isDev3, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
+import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile, isV1Design } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
@@ -18,16 +18,17 @@ function importUserCode() {
         name: 'vike:importUserCode',
         config(_, env) {
             isDev = isDev3(env);
-            return {
-                experimental: {
-                    // TODO/v1-release: remove
-                    importGlobRestoreExtension: true
-                }
-            };
         },
         async configResolved(config_) {
             configVike = await getConfigVike(config_);
             config = config_;
+            // TODO/v1-release: remove
+            {
+                assert(isDev !== undefined);
+                const isV1 = await isV1Design(config, isDev);
+                if (!isV1)
+                    config.experimental.importGlobRestoreExtension = true;
+            }
         },
         resolveId(id) {
             if (isVirtualFileId(id)) {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js

@@ -2,7 +2,7 @@ export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
 export { isTemporaryBuildFile };
-import { build, formatMessages } from 'esbuild';
+import { build, formatMessages, version } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
@@ -14,6 +14,8 @@ import 'source-map-support/register.js';
 import { getFilePathAbsoluteUserRootDir } from '../../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 const debug = createDebugger('vike:pointer-imports');
+console.log('esbuild version', version);
+console.log('require.resolve("vike-react/config")', require.resolve('vike-react/config'));
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
@@ -83,7 +85,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         metafile: true,
         bundle: true
     };
-    let pointerImports = {};
+    const pointerImports = {};
     options.plugins = [
         // Determine whether an import should be:
         //  - A pointer import
@@ -93,6 +95,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
             setup(build) {
                 // https://github.com/brillout/esbuild-playground
                 build.onResolve({ filter: /.*/ }, async (args) => {
+                    console.log('onResolve()', JSON.stringify(args, null, 2));
                     if (args.kind !== 'import-statement')
                         return;
                     // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
@@ -101,14 +104,23 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                         return;
                     const { path, ...opts } = args;
                     opts.pluginData = { [useEsbuildResolver]: true };
-                    const resolved = await build.resolve(path, opts);
+                    let resolved = await build.resolve(path, opts);
                     if (resolved.errors.length > 0) {
+                        let resolvedWithNode;
+                        try {
+                            resolvedWithNode = require.resolve(args.path, { paths: [args.resolveDir] });
+                        }
+                        catch { }
+                        if (resolvedWithNode)
+                            resolved = { path: resolvedWithNode };
+                    }
+                    if (resolved.errors && resolved.errors.length > 0) {
                         /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs whereas esbuild refers to the source +config.ts file.
                         pointerImports[args.path] = false
                         return { external: true }
                         */
-                        cleanEsbuildErrors(resolved.errors);
                         // Let esbuild throw the error
+                        cleanEsbuildErrors(resolved.errors);
                         return resolved;
                     }
                     assert(resolved.path);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -21,7 +21,7 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const { pageId, isForClientSide } = result;
     const { pageConfigs } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
-    assert(pageConfig);
+    assert(pageConfig, { id, pageId });
     const configVike = await getConfigVike(config);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);

package/dist/esm/node/plugin/shared/normalizeId.d.ts

@@ -0,0 +1,2 @@
+export { normalizeId };
+declare function normalizeId(id: string): string;

package/dist/esm/node/plugin/shared/normalizeId.js

@@ -0,0 +1,7 @@
+export { normalizeId };
+import { toPosixPath } from '../utils.js';
+// In principle Vite/Rollup should always normalize the `id` in `transform(code, id)` but it seems to not always do it.
+// https://github.com/vikejs/vike/issues/1935
+function normalizeId(id) {
+    return toPosixPath(id);
+}

package/dist/esm/node/prerender/runPrerender.js

@@ -577,7 +577,9 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     assertPosixPath(fileUrl);
     assert(fileUrl.startsWith('/'));
     const filePathRelative = fileUrl.slice(1);
-    assert(!filePathRelative.startsWith('/'));
+    assert(!filePathRelative.startsWith('/'), 
+    // Let's remove this debug info after we add a assertUsage() avoiding https://github.com/vikejs/vike/issues/1929
+    { urlOriginal, fileUrl });
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);

package/dist/esm/node/runtime/globalContext/loadImportBuild.js

@@ -1,6 +1,6 @@
 export { loadImportBuild };
 export { setImportBuildGetters };
-import { importServerEntry } from '@brillout/vite-plugin-server-entry/runtime';
+import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { assert } from '../utils.js';
 const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
     getters: null
@@ -10,7 +10,7 @@ function setImportBuildGetters(getters) {
 }
 async function loadImportBuild(outDir) {
     if (!buildGetters.getters) {
-        await importServerEntry(outDir);
+        await importServerProductionEntry({ outDir });
         assert(buildGetters.getters);
     }
     const [pageFiles, assetsManifest, pluginManifest] = await Promise.all([

package/dist/esm/node/runtime/renderPage.js

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -374,19 +374,29 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         urlTarget = urlTargetExternal;
     }
     else {
-        if (origin)
-            urlTarget = addUrlOrigin(urlTarget, origin);
-        if (urlTarget === urlWithoutBase)
+        let originChanged = false;
+        if (origin) {
+            const urlModified = setUrlOrigin(urlTarget, origin);
+            if (urlModified !== false) {
+                originChanged = true;
+                urlTarget = urlModified;
+            }
+        }
+        if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
-        urlTarget = prependBase(urlTarget, baseServer);
+        if (!originChanged)
+            urlTarget = prependBase(urlTarget, baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
-    logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
+    logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
+function normalize(url) {
+    return url || '/';
+}
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
 pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit) {

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.199";
+export declare const PROJECT_VERSION: "0.4.200-commit-de0e6ef";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.199';
+export const PROJECT_VERSION = '0.4.200-commit-de0e6ef';

package/dist/esm/utils/getCurrentUrl.d.ts

@@ -1,4 +1,4 @@
 export { getCurrentUrl };
 declare function getCurrentUrl(options?: {
     withoutHash: true;
-}): string;
+}): `/${string}`;

package/dist/esm/utils/parseUrl-extras.d.ts

@@ -4,7 +4,7 @@ export { normalizeUrlPathname };
 export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
-export { addUrlOrigin };
+export { setUrlOrigin };
 export { getUrlPretty };
 declare function prependBase(url: string, baseServer: string): string;
 declare function removeBaseServer(url: string, baseServer: string): string;
@@ -15,5 +15,5 @@ declare function removeUrlOrigin(url: string): {
     urlModified: string;
     origin: string | null;
 };
-declare function addUrlOrigin(url: string, origin: string | null): string;
+declare function setUrlOrigin(url: string, origin: string | null): false | string;
 declare function getUrlPretty(url: string): string;

package/dist/esm/utils/parseUrl-extras.js

@@ -4,7 +4,7 @@ export { normalizeUrlPathname };
 export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
-export { addUrlOrigin };
+export { setUrlOrigin };
 export { getUrlPretty };
 import { assertUrlComponents, createUrlFromComponents, isBaseServer, parseUrl } from './parseUrl.js';
 import { assert } from './assert.js';
@@ -94,9 +94,10 @@ function removeUrlOrigin(url) {
     const urlModified = createUrlFromComponents(null, pathnameOriginal, searchOriginal, hashOriginal);
     return { urlModified, origin };
 }
-function addUrlOrigin(url, origin) {
+function setUrlOrigin(url, origin) {
     const { origin: originCurrent, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
-    assert(originCurrent === null);
+    if (origin === originCurrent)
+        return false;
     assert(origin === null || origin.startsWith('http'));
     const urlModified = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
     return urlModified;

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.199";
+    projectVersion: "0.4.200-commit-de0e6ef";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.199",
+  "version": "0.4.200-commit-de0e6ef",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -125,14 +125,13 @@
     "@brillout/json-serializer": "^0.5.13",
     "@brillout/picocolors": "^1.0.15",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.4.11",
+    "@brillout/vite-plugin-server-entry": "^0.5.0",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
     "esbuild": "^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0",
     "fast-glob": "^3.0.0",
     "semver": "^7.0.0",
-    "sirv": "^2.0.0",
     "source-map-support": "^0.5.0"
   },
   "peerDependencies": {
@@ -232,16 +231,8 @@
     "@types/resolve": "^1.20.6",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
-    "acorn": "^8.11.2",
-    "cac": "^6.7.14",
-    "es-module-lexer": "^1.4.1",
-    "esbuild": "^0.23.0",
-    "fast-glob": "^3.3.2",
     "react-streaming": "^0.3.43",
     "rimraf": "^5.0.5",
-    "semver": "^7.6.3",
-    "sirv": "^2.0.4",
-    "source-map-support": "^0.5.21",
     "typescript": "^5.6.2",
     "vite": "^5.4.0"
   },

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

@@ -1,4 +0,0 @@
-export { onBrowserHistoryNavigation };
-export { updateState };
-declare function onBrowserHistoryNavigation(): void;
-declare function updateState(): void;

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

@@ -1,63 +0,0 @@
-export { onBrowserHistoryNavigation };
-export { updateState };
-import { getCurrentUrl, getGlobalObject } from './utils.js';
-import { initHistoryState, getHistoryState } from './history.js';
-import { renderPageClientSide } from './renderPageClientSide.js';
-import { setScrollPosition } from './setScrollPosition.js';
-const globalObject = getGlobalObject('onBrowserHistoryNavigation.ts', { previousState: getState() });
-function onBrowserHistoryNavigation() {
-    // - The popstate event is trigged upon:
-    //   - Back-/forward navigation.
-    //     - By user clicking on his browser's back-/forward navigation (or using a shortcut)
-    //     - By JavaScript: `history.back()` / `history.forward()`
-    //   - URL hash change.
-    //     - By user clicking on a hash link `<a href="#some-hash" />`
-    //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
-    //     - By JavaScript: `location.hash = 'some-hash'`
-    // - The `event` argument of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
-    window.addEventListener('popstate', async () => {
-        const currentState = getState();
-        const scrollTarget = currentState.historyState.scrollPosition || undefined;
-        const isUserLandPushStateNavigation = currentState.historyState.triggeredBy === 'user';
-        const isHashNavigation = currentState.urlWithoutHash === globalObject.previousState.urlWithoutHash;
-        const isBackwardNavigation = !currentState.historyState.timestamp || !globalObject.previousState.historyState.timestamp
-            ? null
-            : currentState.historyState.timestamp < globalObject.previousState.historyState.timestamp;
-        globalObject.previousState = currentState;
-        if (isHashNavigation && !isUserLandPushStateNavigation) {
-            // - `history.state` is uninitialized (`null`) when:
-            //   - The user's code runs `window.location.hash = '#section'`.
-            //   - The user clicks on an anchor link `<a href="#section">Section</a>` (because Vike's `initOnLinkClick()` handler skips hash links).
-            // - `history.state` is `null` when uninitialized: https://developer.mozilla.org/en-US/docs/Web/API/History/state
-            // - Alternatively, we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
-            //   - Problem: we cannot intercept `window.location.hash = '#section'`. (Or maybe we can with the `hashchange` event?)
-            //   - Other potential problem: would there be a conflict when the user wants to override the browser's default behavior? E.g. for smooth scrolling, or when using hashes for saving states of some fancy animations.
-            // - Another alternative: we use the browser's scroll restoration mechanism (see `browserNativeScrollRestoration_enable()` below).
-            //   - Problem: not clear when to call `browserNativeScrollRestoration_disable()`/`browserNativeScrollRestoration_enable()`
-            //   - Other potential problem are inconsistencies between browsers: specification says that setting `window.history.scrollRestoration` only affects the current entry in the session history. But this seems to contradict what folks saying.
-            //     - Specification: https://html.spec.whatwg.org/multipage/history.html#the-history-interface
-            //     - https://stackoverflow.com/questions/70188241/history-scrollrestoration-manual-doesnt-prevent-safari-from-restoring-scrol
-            if (window.history.state === null) {
-                // The browser already scrolled to `#${hash}` => the current scroll position is the right one => we save it with `initHistoryState()`.
-                initHistoryState();
-                globalObject.previousState = getState();
-            }
-            else {
-                // If `history.state !== null` then it means that `popstate` was triggered by the user clicking on his browser's forward/backward history button.
-                setScrollPosition(scrollTarget);
-            }
-        }
-        else {
-            await renderPageClientSide({ scrollTarget, isBackwardNavigation, isUserLandPushStateNavigation });
-        }
-    });
-}
-function getState() {
-    return {
-        urlWithoutHash: getCurrentUrl({ withoutHash: true }),
-        historyState: getHistoryState()
-    };
-}
-function updateState() {
-    globalObject.previousState = getState();
-}