vike 0.4.146 → 0.4.147-commit-f9a91f3

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

@@ -71,19 +71,25 @@ async function runPrerender(options, manuallyTriggered) {
     const doNotPrerenderList = [];
     const vikeConfig = await getVikeConfig(viteConfig, false);
     await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderPageIds = {};
-    const htmlFiles = [];
-    await routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds, concurrencyLimit);
-    warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList);
-    await prerender404(htmlFiles, renderContext, prerenderContext);
+    const prerenderedPageContexts = {};
+    let prerenderedCount = 0;
+    const onComplete = async (htmlFile) => {
+        prerenderedCount++;
+        if (htmlFile.pageId) {
+            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+        }
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+    };
+    await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
+    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
     if (logLevel === 'info') {
-        console.log(`${pc.green(`✓`)} ${htmlFiles.length} HTML documents pre-rendered.`);
+        console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    await Promise.all(htmlFiles.map((htmlFile) => writeHtmlFile(htmlFile, root, outDirClient, concurrencyLimit, options.onPagePrerender, logLevel)));
-    warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
 }
 async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -145,7 +151,7 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
     // V1 design
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
@@ -161,7 +167,8 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'onBeforePrerenderStart',
-            hookFilePath
+            hookFilePath,
+            pageId: pageConfig.pageId
         });
     })));
     // 0.4 design
@@ -184,10 +191,14 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'prerender',
-            hookFilePath
+            hookFilePath,
+            pageId: p.pageId
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId }) => concurrencyLimit(async () => {
+        if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
+            return;
+        }
         const prerenderResult = await hookFn();
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
@@ -406,7 +417,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         addUrlComputedProps(pageContext);
     });
 }
-async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds, concurrencyLimit) {
+async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = getGlobalContext();
     assert(globalContext.isPrerendering);
     // Route all URLs
@@ -466,7 +477,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             throw err;
         }
         const { documentHtml, pageContextSerialized } = res;
-        htmlFiles.push({
+        await onComplete({
             urlOriginal,
             pageContext,
             htmlString: documentHtml,
@@ -474,11 +485,10 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             doNotCreateExtraDirectory: prerenderContext._noExtraDir,
             pageId
         });
-        prerenderPageIds[pageId] = pageContext;
     })));
 }
-function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList) {
-    Object.entries(prerenderPageIds).forEach(([pageId, pageContext]) => {
+function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList) {
+    Object.entries(prerenderedPageContexts).forEach(([pageId, pageContext]) => {
         const doNotPrerenderListEntry = doNotPrerenderList.find((p) => p.pageId === pageId);
         const { urlOriginal, _providedByHook: providedByHook } = pageContext;
         {
@@ -490,7 +500,7 @@ function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList)
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial) {
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
@@ -498,7 +508,7 @@ function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, p
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
     renderContext.allPageIds
-        .filter((pageId) => !prerenderPageIds[pageId])
+        .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
@@ -506,8 +516,8 @@ function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, p
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender-config#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(htmlFiles, renderContext, prerenderContext) {
-    if (!htmlFiles.find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
+    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await prerender404Page(renderContext, prerenderContext.pageContextInit);
@@ -519,7 +529,7 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         if (result) {
             const urlOriginal = '/404';
             const { documentHtml, pageContext } = result;
-            htmlFiles.push({
+            await onComplete({
                 urlOriginal,
                 pageContext,
                 htmlString: documentHtml,
@@ -530,59 +540,57 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         }
     }
 }
-async function writeHtmlFile({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, concurrencyLimit, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
     }
     await Promise.all(writeJobs);
 }
-function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel) {
-    return concurrencyLimit(async () => {
-        let fileUrl;
-        if (fileExtension === '.html') {
-            fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
-        }
-        else {
-            fileUrl = getPageContextRequestUrl(urlOriginal);
-        }
-        assertPosixPath(fileUrl);
-        assert(fileUrl.startsWith('/'));
-        const filePathRelative = fileUrl.slice(1);
-        assert(!filePathRelative.startsWith('/'));
-        assertPosixPath(outDirClient);
-        assertPosixPath(filePathRelative);
-        const filePath = path.posix.join(outDirClient, filePathRelative);
-        if (onPagePrerender) {
-            const prerenderPageContext = {};
-            objectAssign(prerenderPageContext, pageContext);
-            objectAssign(prerenderPageContext, {
-                _prerenderResult: {
-                    filePath,
-                    fileContent
-                }
-            });
-            await onPagePrerender(prerenderPageContext);
-        }
-        else {
-            const { promises } = await import('fs');
-            const { writeFile, mkdir } = promises;
-            await mkdir(path.posix.dirname(filePath), { recursive: true });
-            await writeFile(filePath, fileContent);
-            if (logLevel === 'info') {
-                assertPosixPath(root);
-                assertPosixPath(outDirClient);
-                let outDirClientRelative = path.posix.relative(root, outDirClient);
-                if (!outDirClientRelative.endsWith('/')) {
-                    outDirClientRelative = outDirClientRelative + '/';
-                }
-                console.log(`${pc.dim(outDirClientRelative)}${pc.blue(filePathRelative)}`);
+async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+    let fileUrl;
+    if (fileExtension === '.html') {
+        fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
+    }
+    else {
+        fileUrl = getPageContextRequestUrl(urlOriginal);
+    }
+    assertPosixPath(fileUrl);
+    assert(fileUrl.startsWith('/'));
+    const filePathRelative = fileUrl.slice(1);
+    assert(!filePathRelative.startsWith('/'));
+    assertPosixPath(outDirClient);
+    assertPosixPath(filePathRelative);
+    const filePath = path.posix.join(outDirClient, filePathRelative);
+    if (onPagePrerender) {
+        const prerenderPageContext = {};
+        objectAssign(prerenderPageContext, pageContext);
+        objectAssign(prerenderPageContext, {
+            _prerenderResult: {
+                filePath,
+                fileContent
             }
+        });
+        await onPagePrerender(prerenderPageContext);
+    }
+    else {
+        const { promises } = await import('fs');
+        const { writeFile, mkdir } = promises;
+        await mkdir(path.posix.dirname(filePath), { recursive: true });
+        await writeFile(filePath, fileContent);
+        if (logLevel === 'info') {
+            assertPosixPath(root);
+            assertPosixPath(outDirClient);
+            let outDirClientRelative = path.posix.relative(root, outDirClient);
+            if (!outDirClientRelative.endsWith('/')) {
+                outDirClientRelative = outDirClientRelative + '/';
+            }
+            console.log(`${pc.dim(outDirClientRelative)}${pc.blue(filePathRelative)}`);
         }
-    });
+    }
 }
 function normalizeOnPrerenderHookResult(prerenderResult, prerenderHookFile, hookName) {
     if (Array.isArray(prerenderResult)) {

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.js

@@ -1,7 +1,7 @@
 export { injectAssets__public };
 import { assertUsage, assertWarning, castProp, hasProp } from '../../utils.js';
 import { injectHtmlTagsToString } from '../injectAssets.js';
-// TODO: remove this on next semver major
+// TODO/v1-release: remove
 async function injectAssets__public(htmlString, pageContext) {
     assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });

package/dist/esm/node/runtime/index-common.d.ts

@@ -1,6 +1,7 @@
 export { renderPage } from './renderPage.js';
 export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
+export { PROJECT_VERSION as version } from './utils.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
 declare global {

package/dist/esm/node/runtime/index-common.js

@@ -1,6 +1,7 @@
 export { renderPage } from './renderPage.js';
 export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
+export { PROJECT_VERSION as version } from './utils.js';
 // TODO/v1-release: remove
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 // TODO/v1-release: remove

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

@@ -29,8 +29,8 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           if (configElement.importPath) {
             const { env } = configElement
             assert(env)
-            const onlyAssets = env === 'server-only'
-            const eagerlyImported = env === '_routing-eager'
+            const onlyAssets = env === { server: true }
+            const eagerlyImported = env === { server: true, client: 'if-client-routing', eager: true }
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
                 id: configElement.importPath,

package/dist/esm/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.d.ts

@@ -1,2 +1,2 @@
 export { assertNoInfiniteHttpRedirect };
-declare function assertNoInfiniteHttpRedirect(urlRedirectOriginal: string, urlRedirectPathnameLogical: string): void;
+declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, urlLogical: string): void;

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

@@ -1,24 +1,24 @@
 export { assertNoInfiniteHttpRedirect };
-import { assert, assertUsage, getGlobalObject } from '../../utils.js';
+import { assert, assertUsage, getGlobalObject, isUriWithProtocol } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
-    if (urlRedirectOriginal.startsWith('http')) {
-        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+    if (isUriWithProtocol(urlRedirectTarget)) {
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
-        //    // URL origin is usually missing
+        //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    assert(urlRedirectOriginal.startsWith('/'));
-    assert(urlRedirectPathnameLogical.startsWith('/'));
+    assert(urlRedirectTarget.startsWith('/'));
+    assert(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
-    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
-    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
+    graph[urlRedirectTarget].add(urlLogical);
     validate(graph);
     globalObject.redirectGraph = graph;
 }
@@ -26,6 +26,9 @@ function copy(G) {
     return Object.fromEntries(Object.entries(G).map(([key, val]) => [key, new Set(val)]));
 }
 // Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}
 function check(G, n, path) {
     if (path.includes(n)) {
         const cycle = path.slice(path.indexOf(n)).concat(n);
@@ -33,6 +36,3 @@ function check(G, n, path) {
     }
     G[n]?.forEach((node) => check(G, node, [...path, n]));
 }
-function validate(G) {
-    Object.keys(G).forEach((n) => check(G, n, []));
-}

package/dist/esm/node/runtime/renderPage/createHttpResponseObject.d.ts

@@ -25,4 +25,4 @@ declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderH
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse | null>;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlPathnameLogical: string): HttpResponse;
+declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;

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

@@ -33,9 +33,9 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
     return httpResponse;
 }
 function createHttpResponseObjectRedirect({ url, statusCode }, 
-// The URL pathname we assume the redirect to be logically based on
-urlPathnameLogical) {
-    assertNoInfiniteHttpRedirect(url, urlPathnameLogical);
+// The URL we assume the redirect to be logically based on
+urlLogical) {
+    assertNoInfiniteHttpRedirect(url, urlLogical);
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);

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

@@ -9,8 +9,7 @@ import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObje
 import { logRuntimeError } from './loggerRuntime.js';
 import pc from '@brillout/picocolors';
 async function executeOnRenderHtmlHook(pageContext) {
-    const hookFound = getRenderHook(pageContext);
-    const { renderHook, hookFn } = hookFound;
+    const { renderHook, hookFn } = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: renderHook });
     preparePageContextForUserConsumptionServerSide(pageContext);
     const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);

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

@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 const streamDocs = 'See https://vike.dev/stream for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
-        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} or ${pc.cyan('pageContext.httpResponse.getBody()')} instead`));
+        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
     }
     const body = htmlRender;
     return body;

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, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin } from './utils.js';
+import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -34,17 +34,17 @@ async function renderPage(pageContextInit) {
     assertArguments(...arguments);
     assert(hasProp(pageContextInit, 'urlOriginal', 'string'));
     assertEnv();
-    if (skipRequest(pageContextInit.urlOriginal)) {
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        checkType(pageContextHttpReponseNull);
-        return pageContextHttpReponseNull;
+    if (isIgnoredUrl(pageContextInit.urlOriginal)) {
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        checkType(pageContextHttpResponseNull);
+        return pageContextHttpResponseNull;
     }
     const httpRequestId = getRequestId();
-    const urlToShowToUser = pageContextInit.urlOriginal;
-    logHttpRequest(urlToShowToUser, httpRequestId);
+    const { urlOriginal } = pageContextInit;
+    logHttpRequest(urlOriginal, httpRequestId);
     globalObject.pendingRequestsCount++;
     const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
-    logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn);
+    logHttpResponse(urlOriginal, httpRequestId, pageContextReturn);
     globalObject.pendingRequestsCount--;
     onRequestDone();
     checkType(pageContextReturn);
@@ -54,8 +54,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
     const handleInvalidConfig = () => {
         logRuntimeInfo?.(pc.bold(pc.red("Couldn't load configuration: see error above.")), httpRequestId, 'error');
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
     };
     if (isConfigInvalid) {
         return handleInvalidConfig();
@@ -71,8 +71,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
-        const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
+        return pageContextHttpResponseNull;
     }
     if (isConfigInvalid) {
         return handleInvalidConfig();
@@ -80,15 +80,23 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     else {
         // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
+    // Check Base URL
+    {
+        const pageContextHttpResponse = checkBaseUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
+    }
+    // Normalize URL
     {
-        const pageContextHttpReponse = normalizeUrl(pageContextInit, httpRequestId);
-        if (pageContextHttpReponse)
-            return pageContextHttpReponse;
+        const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
     }
+    // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpReponse = getPermanentRedirect(pageContextInit, httpRequestId);
-        if (pageContextHttpReponse)
-            return pageContextHttpReponse;
+        const pageContextHttpResponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
     }
     return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, []);
 }
@@ -171,8 +179,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-                    return pageContextHttpReponseNull;
+                    const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+                    return pageContextHttpResponseNull;
                 }
                 // `throw redirect()` / `throw render(url)`
                 return handled.pageContextReturn;
@@ -180,18 +188,28 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if (isNewError(errErrorPage, errNominalPage)) {
                 logRuntimeError(errErrorPage, httpRequestId);
             }
-            const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-            return pageContextHttpReponseNull;
+            const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+            return pageContextHttpResponseNull;
         }
         return pageContextErrorPage;
     }
 }
-function logHttpRequest(urlToShowToUser, httpRequestId) {
+function logHttpRequest(urlOriginal, httpRequestId) {
     const clearErrors = globalObject.pendingRequestsCount === 0;
-    logRuntimeInfo?.(`HTTP request: ${pc.bold(urlToShowToUser)}`, httpRequestId, 'info', clearErrors);
+    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
 }
-function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
+function getRequestInfoMessage(urlOriginal) {
+    return `HTTP request: ${pc.bold(urlOriginal)}`;
+}
+function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
     const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
+    {
+        // If URL doesn't include Base URL
+        const { errorWhileRendering } = pageContextReturn;
+        const isSkipped = statusCode === null && (errorWhileRendering === null || errorWhileRendering === undefined);
+        if (isSkipped)
+            return;
+    }
     const isSuccess = statusCode !== null && statusCode >= 200 && statusCode <= 399;
     const isNominal = isSuccess || statusCode === 404;
     const color = (s) => pc.bold(isSuccess ? pc.green(String(s)) : pc.red(String(s)));
@@ -205,39 +223,30 @@ function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
             .find((header) => header[0] === 'Location');
         assert(headerRedirect);
         const urlRedirect = headerRedirect[1];
-        urlToShowToUser = urlRedirect;
+        urlOriginal = urlRedirect;
     }
-    logRuntimeInfo?.(`HTTP ${type} ${pc.bold(urlToShowToUser)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
+    logRuntimeInfo?.(`HTTP ${type} ${pc.bold(urlOriginal)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
 }
 function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    objectAssign(pageContextHttpReponseNull, pageContextInit);
-    objectAssign(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    objectAssign(pageContextHttpResponseNull, pageContextInit);
+    objectAssign(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: err
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    objectAssign(pageContextHttpReponseNull, pageContextInit);
-    objectAssign(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    objectAssign(pageContextHttpResponseNull, pageContextInit);
+    objectAssign(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: null
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 async function renderPageNominal(pageContext) {
     objectAssign(pageContext, { errorWhileRendering: null });
-    // Check Base URL
-    {
-        const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(pageContext.urlOriginal);
-        const hasBaseServer = parseUrl(urlWithoutPageContextRequestSuffix, pageContext._baseServer).hasBaseServer || !!pageContext._urlRewrite;
-        if (!hasBaseServer) {
-            objectAssign(pageContext, { httpResponse: null });
-            return pageContext;
-        }
-    }
     // Route
     {
         const pageContextFromRoute = await route(pageContext);
@@ -303,7 +312,7 @@ function getRequestId() {
     assert(httpRequestId >= 1);
     return httpRequestId;
 }
-function skipRequest(urlOriginal) {
+function isIgnoredUrl(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
     assertWarning(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
     return (urlOriginal.endsWith('/__vite_ping') ||
@@ -312,11 +321,11 @@ function skipRequest(urlOriginal) {
         isViteClientRequest);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization } = getGlobalContext();
+    const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
-    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash);
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash, baseServer);
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -327,10 +336,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = getGlobalContext();
     const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = resolveRedirects(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -340,13 +347,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = addUrlOrigin(urlTarget, origin);
-    assert(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = prependBase(urlTarget, baseServer);
     assert(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -390,10 +396,28 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
+function checkBaseUrl(pageContextInit, httpRequestId) {
+    const { baseServer } = getGlobalContext();
+    const { urlOriginal } = pageContextInit;
+    const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
+    const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
+    if (!hasBaseServer) {
+        logRuntimeInfo?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${pc.bold(urlOriginal)} doesn't start with Base URL ${pc.bold(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
+    }
+    return null;
+}