vike 0.4.222 → 0.4.223-commit-6f064ad

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

@@ -17,7 +17,6 @@ import { preparePageContextForUserConsumptionServerSide } from './preparePageCon
 import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
-import { resolveBaseRuntime } from '../../shared/resolveBase.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -112,14 +111,13 @@ async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr:
     isClientSideNavigation: false
 } } = {}) {
     assert(pageContextInit.urlOriginal);
-    const { baseServer, baseAssets } = resolveBaseRuntime(globalContext);
     const pageContextInitEnhanced = {};
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
         // The following is defined on `pageContext` because we can eventually make these non-global
-        _baseServer: baseServer,
-        _baseAssets: baseAssets,
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
         // TODO/now: add meta.default
         _includeAssetsImportedByServer: globalContext.config.includeAssetsImportedByServer ?? true,
         // TODO/soon: use GloablContext instead

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

@@ -1,11 +1,7 @@
 export { renderPage };
-export { renderPage_addWrapper };
+export { renderPage_addAsyncHookwrapper };
 import { HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
-    pageContextReturn: Awaited<PageContext>;
-}>;
-declare const renderPage_addWrapper: (wrapper: typeof renderPage_wrapper) => void;
 declare function renderPage<PageContextUserAdded extends {}, PageContextInit extends {
     /** @deprecated */
     url?: string;
@@ -14,3 +10,7 @@ declare function renderPage<PageContextUserAdded extends {}, PageContextInit ext
 }>(pageContextInit: PageContextInit): Promise<PageContextInit & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
+declare let asyncHookWrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
+    pageContextReturn: Awaited<PageContext>;
+}>;
+declare function renderPage_addAsyncHookwrapper(wrapper: typeof asyncHookWrapper): void;

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

@@ -1,63 +1,58 @@
 export { renderPage };
-export { renderPage_addWrapper };
+export { renderPage_addAsyncHookwrapper };
 import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, 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 { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError } from './renderPage/createHttpResponse.js';
+import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
 import { log404 } from './renderPage/log404/index.js';
-import { isConfigInvalid } from './renderPage/isConfigInvalid.js';
+import { isVikeConfigInvalid } from './renderPage/isVikeConfigInvalid.js';
 import pc from '@brillout/picocolors';
 import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
-import { resolveBaseRuntime } from '../shared/resolveBase.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
-let renderPage_wrapper = async (_httpRequestId, ret) => ({
-    pageContextReturn: await ret()
-});
-const renderPage_addWrapper = (wrapper) => {
-    renderPage_wrapper = wrapper;
-};
 // `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
-    onSetupRuntime();
     assertIsUrl(pageContextInit.urlOriginal);
-    const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
-    assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (urlPathnameWithBase.endsWith('/favicon.ico'))
-        return getPageContextHttpResponseFavicon404(pageContextInit);
+    onSetupRuntime();
+    const pageContextInvalidRequest = renderInvalidRequest(pageContextInit);
+    if (pageContextInvalidRequest)
+        return pageContextInvalidRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = getUrlPretty(pageContextInit.urlOriginal);
     logHttpRequest(urlOriginalPretty, httpRequestId);
-    const { pageContextReturn } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    const { pageContextReturn } = await asyncHookWrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
     logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn);
     checkType(pageContextReturn);
     assert(pageContextReturn.httpResponse);
     return pageContextReturn;
 }
+// Fallback wrapper if node:async_hooks isn't available
+let asyncHookWrapper = async (_httpRequestId, ret) => ({
+    pageContextReturn: await ret()
+});
+// Add node:async_hooks wrapper
+function renderPage_addAsyncHookwrapper(wrapper) {
+    asyncHookWrapper = wrapper;
+}
 async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    const handleInvalidConfig = (err) => {
-        logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
-        return pageContextWithError;
-    };
-    if (isConfigInvalid) {
+    if (isVikeConfigInvalid) {
         if (1 < 2 // Make TS happy
         ) {
-            return handleInvalidConfig(isConfigInvalid.err);
+            return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
         }
     }
     // Prepare context
@@ -65,22 +60,29 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         await initGlobalContext_renderPage();
     }
     catch (err) {
-        // Errors are expected since assertUsage() is used in both initGlobalContext_renderPage() and getRenderContext().
-        // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
+        // Errors are expected since assertUsage() is used in initGlobalContext_renderPage() such as:
+        // ```bash
+        // Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
+        // ```
+        // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
         return pageContextWithError;
     }
-    if (isConfigInvalid) {
-        return handleInvalidConfig(isConfigInvalid.err);
+    if (isVikeConfigInvalid) {
+        return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     else {
-        // From now on, globalContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
+        // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
     const globalContext = await getGlobalContextInternal();
     // Check Base URL
-    await assertBaseUrl(pageContextInit, globalContext);
+    {
+        const pageContextHttpResponse = await checkBaseUrl(pageContextInit, globalContext);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
+    }
     // Normalize URL
     {
         const pageContextHttpResponse = await normalizeUrl(pageContextInit, globalContext, httpRequestId);
@@ -248,15 +250,6 @@ function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     });
     return pageContextWithError;
 }
-function getPageContextHttpResponseFavicon404(pageContextInit) {
-    const pageContext = createPageContext(pageContextInit);
-    const httpResponse = createHttpResponseFavicon404();
-    objectAssign(pageContext, {
-        httpResponse
-    });
-    checkType(pageContext);
-    return pageContext;
-}
 function createPageContext(pageContextInit) {
     const pageContext = {
         _isPageContextObject: true
@@ -337,7 +330,6 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
     assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
 async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
-    const { baseServer } = resolveBaseRuntime(globalContext);
     const { trailingSlash, disableUrlNormalization } = globalContext.config;
     if (disableUrlNormalization)
         return null;
@@ -345,7 +337,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     if (isPageContextRequest)
         return null;
-    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, baseServer);
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, globalContext.baseServer);
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -355,8 +347,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     return pageContextHttpResponse;
 }
 async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
-    const { baseServer } = resolveBaseRuntime(globalContext);
-    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
+    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, globalContext.baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
@@ -387,9 +378,8 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
         }
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
-        const { baseServer } = resolveBaseRuntime(globalContext);
         if (!originChanged)
-            urlTarget = prependBase(urlTarget, baseServer);
+            urlTarget = prependBase(urlTarget, globalContext.baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
@@ -452,10 +442,35 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-async function assertBaseUrl(pageContextInit, globalContext) {
-    const { baseServer } = resolveBaseRuntime(globalContext);
+async function checkBaseUrl(pageContextInit, globalContext) {
+    const { baseServer } = globalContext;
     const { urlOriginal } = pageContextInit;
-    const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
-    const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
-    assertUsage(hasBaseServer, `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which doesn't start with Base URL ${pc.code(baseServer)} (https://vike.dev/base-url)`);
+    const { isBaseMissing } = parseUrl(urlOriginal, baseServer);
+    if (!isBaseMissing)
+        return;
+    const pageContext = createPageContext(pageContextInit);
+    const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
+    objectAssign(pageContext, {
+        httpResponse,
+        isBaseMissing: true
+    });
+    checkType(pageContext);
+    return pageContext;
+}
+function renderInvalidRequest(pageContextInit) {
+    const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
+    assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
+    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
+        const pageContext = createPageContext(pageContextInit);
+        const httpResponse = createHttpResponseFavicon404();
+        objectAssign(pageContext, { httpResponse });
+        checkType(pageContext);
+        return pageContext;
+    }
+    return null;
+}
+function renderInvalidVikeConfig(err, pageContextInit, httpRequestId) {
+    logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
+    const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+    return pageContextWithError;
 }

package/dist/esm/node/runtime/universal-middleware.d.ts

@@ -0,0 +1 @@
+export default function universalVikeHandler(request: Request, context: Record<string, unknown>, runtime: Record<string, unknown>): Promise<Response>;

package/dist/esm/node/runtime/universal-middleware.js

@@ -0,0 +1,11 @@
+import { renderPage } from './index.js';
+export default async function universalVikeHandler(request, context, runtime) {
+    const pageContextInit = { ...context, ...runtime, urlOriginal: request.url, headersOriginal: request.headers };
+    const pageContext = await renderPage(pageContextInit);
+    const response = pageContext.httpResponse;
+    const readable = response.getReadableWebStream();
+    return new Response(readable, {
+        status: response.statusCode,
+        headers: response.headers
+    });
+}

package/dist/esm/node/shared/resolveBase.d.ts

@@ -1,15 +1,7 @@
 export { resolveBase };
-export { resolveBaseRuntime };
-export { resolveBaseFromResolvedConfig };
-import type { ResolvedConfig } from 'vite';
-import type { GlobalContext } from '../runtime/globalContext.js';
-declare function resolveBaseFromResolvedConfig(baseServer: string | null, baseAssets: string | null, config: ResolvedConfig): {
-    baseServer: string;
-    baseAssets: string;
-};
+export type { BaseUrlsResolved };
 type BaseUrlsResolved = {
     baseServer: string;
     baseAssets: string;
 };
-declare function resolveBaseRuntime(globalContext: GlobalContext): BaseUrlsResolved;
 declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): BaseUrlsResolved;

package/dist/esm/node/shared/resolveBase.js

@@ -1,19 +1,6 @@
 export { resolveBase };
-export { resolveBaseRuntime };
-export { resolveBaseFromResolvedConfig };
 import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
 import pc from '@brillout/picocolors';
-function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
-    let baseViteOriginal = config._baseViteOriginal;
-    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
-    return resolveBase(baseViteOriginal, baseServer, baseAssets);
-}
-function resolveBaseRuntime(globalContext) {
-    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
-    const baseServerUnresolved = globalContext.config.baseServer ?? null;
-    const baseAssetsUnresolved = globalContext.config.baseAssets ?? null;
-    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
-}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;

package/dist/esm/shared/getPageConfigsRuntime.d.ts

@@ -1,14 +1,14 @@
 export { getPageConfigsRuntime };
 export { getAllPageIds };
 import type { PageFile } from './getPageFiles.js';
-import { type ConfigUserFriendly, type PageConfigsUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
+import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from './page-configs/PageConfig.js';
 declare function getPageConfigsRuntime(virtualFileExports: unknown): {
     pageFilesAll: PageFile[];
     allPageIds: string[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
-    globalConfig: ConfigUserFriendly;
+    globalConfig: PageConfigUserFriendly;
     pageConfigsUserFriendly: PageConfigsUserFriendly;
 };
 declare function getAllPageIds(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string[];

package/dist/esm/shared/getPageConfigsRuntime.js

@@ -1,21 +1,15 @@
 export { getPageConfigsRuntime };
 export { getAllPageIds };
 import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
-import { getPageConfigUserFriendlyNew } from './page-configs/getPageConfigUserFriendly.js';
+import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
 import { unique } from './utils.js';
 function getPageConfigsRuntime(virtualFileExports) {
     const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
     // TODO/now: re-use this call, instead of calling it twice
-    const globalConfig = getPageConfigUserFriendlyNew(pageConfigGlobal);
-    // TODO/now DEDUPE
+    const globalConfig = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues: pageConfigGlobal.configValues });
     const pageConfigsUserFriendly = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        const configValues = { ...pageConfigGlobal.configValues, ...pageConfig.configValues };
-        const page = {
-            ...getPageConfigUserFriendlyNew({ configValues }),
-            route: pageConfig.routeFilesystem?.routeString ?? null
-        };
-        return [pageConfig.pageId, page];
+        return getPageConfigUserFriendly(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
     }));
     return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly };
 }

package/dist/esm/shared/getPageContextRequestUrl.js

@@ -6,7 +6,7 @@ import { urlToFile } from '../utils/urlToFile.js';
 const pageContextJsonFileExtension = '.pageContext.json';
 // `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/vikejs/vike/issues/443
 const doNotCreateExtraDirectory = false;
-// See node/renderPage/handlePageContextRequestUrl.ts
+// See also node/renderPage/handlePageContextRequestUrl.ts
 function getPageContextRequestUrl(url) {
     const pageContextRequestUrl = urlToFile(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
     return pageContextRequestUrl;

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -37,26 +37,29 @@ function getUrlParsed(pageContext) {
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
     // Determine logical URL
-    // TODO/soon: revert https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
-    const assertUrlResolved = (src) => assert(urlResolved && typeof urlResolved === 'string', { src, urlResolved });
+    const assertUrlResolved = (src) => assert(typeof urlResolved === 'string', 
+    // TODO/eventually: remove debug logs, see:
+    // - https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
+    // - https://github.com/vikejs/vike/commit/5c7810f3080ab62536950f26e019bb2a3a517082
+    { src, urlResolved });
     let urlResolved;
-    let baseToBeRemoved;
+    let isBaseToBeRemoved;
     if (pageContext.urlLogical) {
         // Set by onBeforeRoute()
         urlResolved = pageContext.urlLogical;
-        baseToBeRemoved = false;
+        isBaseToBeRemoved = false;
         assertUrlResolved(1);
     }
     else if (pageContext._urlRewrite) {
         // Set by `throw render()`
         urlResolved = pageContext._urlRewrite;
-        baseToBeRemoved = false;
+        isBaseToBeRemoved = false;
         assertUrlResolved(2);
     }
     else {
         // Set by renderPage()
         urlResolved = pageContext.urlOriginal;
-        baseToBeRemoved = true;
+        isBaseToBeRemoved = true;
         assertUrlResolved(3);
     }
     assertUrlResolved(4);
@@ -69,7 +72,7 @@ function getUrlParsed(pageContext) {
     // - We assume there isn't any Base URL to the URLs set by the user at `throw render()` and onBeforeRoute()
     //   - This makes sense because the Base URL is merely a setting: ideally the user should write code that doesn't know anything about it (so that the user can remove/add/change Base URL without having to modify any code).
     // - pageContext.urlOriginal is the URL of the HTTP request and thus contains the Base URL.
-    const baseServer = !baseToBeRemoved ? '/' : pageContext._baseServer;
+    const baseServer = !isBaseToBeRemoved ? '/' : pageContext._baseServer;
     // Parse URL
     return parseUrl(urlResolved, baseServer);
 }
@@ -86,8 +89,8 @@ function urlGetter() {
 }
 function urlParsedGetter() {
     const { 
-    // remove hasBaseServer as it isn't part of UrlPublic
-    hasBaseServer: _, ...urlParsed } = getUrlParsed(this);
+    // remove isBaseMissing as it isn't part of UrlPublic
+    isBaseMissing: _, ...urlParsed } = getUrlParsed(this);
     const hashIsAvailable = isBrowser();
     const warnHashNotAvailable = (prop) => {
         assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });

package/dist/esm/shared/getPageFiles.d.ts

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, PageConfigUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
+export type { ExportsAll, PageConfigUserFriendlyOld } from './page-configs/getPageConfigUserFriendly.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';

package/dist/esm/shared/hooks/getHook.d.ts

@@ -9,7 +9,7 @@ export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
-import type { PageConfigUserFriendly } from '../getPageFiles.js';
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
 import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
@@ -26,10 +26,10 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHook(pageContext: PageConfigUserFriendly, hookName: HookName): null | Hook;
+declare function getHook(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
-declare function assertHook<TPageContext extends PageConfigUserFriendly, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
+declare function assertHook<TPageContext extends PageConfigUserFriendlyOld, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;
 };
 declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;

package/dist/esm/shared/hooks/getHook.js

@@ -11,7 +11,7 @@ import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('getHook.ts', {});
+const globalObject = getGlobalObject('hooks/getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;

package/dist/esm/shared/page-configs/Config.d.ts

@@ -32,6 +32,7 @@ export type { OnRenderHtmlAsync };
 export type { OnRenderHtmlSync };
 export type { RouteAsync };
 export type { RouteSync };
+export type { Route };
 export type { KeepScrollPosition };
 import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/PrefetchSetting.js';
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
@@ -223,6 +224,7 @@ type RouteSync = (pageContext: PageContextServer | PageContextClient) => {
     routeParams?: Record<string, string>;
     precedence?: number;
 } | boolean;
+type Route = string | RouteSync | RouteAsync;
 /** Whether the page scrolls to the top upon navigation.
  *
  * https://vike.dev/keepScrollPosition
@@ -239,7 +241,7 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: string | RouteAsync | RouteSync | ImportString;
+    route?: Route | ImportString;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -1,6 +1,8 @@
 export type { PageConfigRuntime };
 export type { PageConfigRuntimeLoaded };
 export type { PageConfigBuildTime };
+export type { PageConfigCommon };
+export type { PageConfigRoute };
 export type { ConfigEnv };
 export type { ConfigEnvInternal };
 export type { PageConfigGlobalRuntime };
@@ -23,8 +25,13 @@ import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode
 import type { PlusFile, PlusFilesByLocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
 type PageConfigCommon = {
     pageId: string;
-    isErrorPage?: true;
-    routeFilesystem?: {
+} & PageConfigRoute;
+type PageConfigRoute = {
+    isErrorPage: true;
+    routeFilesystem?: undefined;
+} | {
+    isErrorPage?: undefined;
+    routeFilesystem: {
         routeString: string;
         definedBy: string;
     };
@@ -87,10 +94,11 @@ type ConfigValueSource = {
     locationId: LocationId;
     isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
-    valueIsImportedAtRuntime: boolean;
+    valueIsLoadedWithImport: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
-    valueIsDefinedByPlusFile: boolean;
+    /** Whether the config value is defined by a +{configName}.js file */
+    valueIsDefinedByPlusValueFile: boolean;
 } & ({
     valueIsLoaded: false;
 } | {

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.d.ts

@@ -1,8 +1,9 @@
-export { getPageConfigUserFriendlyOld };
-export { getPageConfigUserFriendlyNew };
-export type { ConfigUserFriendly };
-export type { PageConfigUserFriendly };
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendly_oldDesign };
+export { getPageConfigGlobalUserFriendly };
 export type { PageConfigsUserFriendly };
+export type { PageConfigUserFriendly };
+export type { PageConfigUserFriendlyOld };
 export type { Source };
 export type { Sources };
 export type { From };
@@ -10,9 +11,10 @@ export type { ExportsAll };
 export type { ConfigEntries };
 import type { FileType } from '../getPageFiles/fileTypes.js';
 import type { PageFile } from '../getPageFiles/getPageFileObject.js';
-import type { ConfigValues, PageConfigGlobalRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
+import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
 import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
 import type { ConfigResolved } from './Config/PageContextConfig.js';
+import type { Route } from './Config.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
@@ -33,7 +35,7 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type PageConfigUserFriendly = {
+type PageConfigUserFriendlyOld = {
     config: ConfigResolved;
     source: Source;
     sources: Sources;
@@ -74,18 +76,24 @@ type SourceConfigsComputed = {
     type: 'configsComputed';
     value: unknown;
 };
-type PageConfigsUserFriendly = Record<string, // pageId
-// pageId
-ConfigUserFriendly & {
-    route: string | null;
-}>;
-type ConfigUserFriendly = {
+type PageConfigUserFriendly = {
     config: ConfigResolved;
     _source: Source;
     _sources: Sources;
     _from: From;
 };
-declare function getPageConfigUserFriendlyNew(pageConfig: {
-    configValues: ConfigValues;
-}): ConfigUserFriendly;
-declare function getPageConfigUserFriendlyOld(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null, pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendly;
+type PageConfigsUserFriendly = Record<string, // pageId
+PageConfigUserFriendlyWithRoute>;
+type WithRoute = {
+    route: Route;
+    isErrorPage?: undefined;
+} | {
+    route?: undefined;
+    isErrorPage: true;
+};
+type PageConfigUserFriendlyWithRoute = PageConfigUserFriendly & WithRoute;
+declare function getPageConfigUserFriendly(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
+declare function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }: {
+    pageConfigGlobalValues: ConfigValues;
+}): PageConfigUserFriendly;
+declare function getPageConfigUserFriendly_oldDesign(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null, pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;