vike 0.4.222-commit-207e079 → 0.4.222-commit-5513d32

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

@@ -7,6 +7,9 @@ import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getFullBuildInlineConfig } from '../shared/getFullBuildInlineConfig.js';
 function buildApp() {
     let config;
+    // `builder.buildApp` can be overriden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
+    // In that case, we should'nt `forceExit`.
+    let forceExit = false;
     return [
         {
             name: 'vike:buildApp',
@@ -21,6 +24,10 @@ function buildApp() {
                             assert(builder.environments.ssr);
                             await builder.build(builder.environments.client);
                             await builder.build(builder.environments.ssr);
+                            if (forceExit) {
+                                runPrerender_forceExit();
+                                assert(false);
+                            }
                         }
                     },
                     environments: {
@@ -59,11 +66,8 @@ function buildApp() {
                 if (!isPrerenderAutoRunEnabled(vikeConfig))
                     return;
                 const configInline = getFullBuildInlineConfig(config);
-                const { forceExit } = await runPrerenderFromAutoRun(configInline, config);
-                if (forceExit) {
-                    runPrerender_forceExit();
-                    assert(false);
-                }
+                const res = await runPrerenderFromAutoRun(configInline, config);
+                forceExit = res.forceExit;
             }
         }
     ];

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

@@ -80,6 +80,9 @@ function buildConfig() {
         {
             name: 'vike:buildConfig:pre',
             apply: 'build',
+            applyToEnvironment(env) {
+                return env.name === 'ssr';
+            },
             // Make sure other writeBundle() hooks are called after this writeBundle() hook.
             //  - set_ASSETS_MANIFEST() needs to be called before dist/server/ code is executed.
             //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527

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

@@ -93,7 +93,6 @@ function getIsClientSide(config, options) {
         return !isServerSide;
     }
     else {
-        assert(config.build.ssr === false);
         assert(typeof options?.ssr === 'boolean');
         const isServerSide = options.ssr;
         return !isServerSide;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -9,12 +9,12 @@ export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import type { ResolvedConfig } from 'vite';
-import { type ConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
-    global: ConfigUserFriendly;
+    global: PageConfigUserFriendly;
     pages: PageConfigsUserFriendly;
 };
 declare const vikeConfigDependencies: Set<string>;

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

@@ -19,7 +19,7 @@ import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
-import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 assertIsNotProductionRuntime();
@@ -127,7 +127,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                global: getPageConfigUserFriendlyNew({ configValues: {} }),
+                global: getPageConfigGlobalUserFriendly({ pageConfigGlobalValues: {} }),
                 pages: {}
             };
             return dummyData;
@@ -143,18 +143,12 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     // interop vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
-    const configValuesGlobal = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigUserFriendlyNew({ configValues: configValuesGlobal });
-    // TODO/now DEDUPE
+    const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues });
     // pages
     const pages = objectFromEntries(pageConfigs.map((pageConfig) => {
-        const configValuesLocal = getConfigValues(pageConfig, true);
-        const configValues = { ...configValuesGlobal, ...configValuesLocal };
-        const page = {
-            ...getPageConfigUserFriendlyNew({ configValues }),
-            route: pageConfig.routeFilesystem?.routeString ?? null
-        };
-        return [pageConfig.pageId, page];
+        const pageConfigValues = getConfigValues(pageConfig, true);
+        return getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
     return { pageConfigs, pageConfigGlobal, global, pages };
 }
@@ -219,13 +213,12 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
                 return;
             configValueSources[configName] = sources;
         });
-        const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
+        const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitionsLocal);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
-            isErrorPage,
-            routeFilesystem,
+            ...pageConfigRoute,
             configDefinitions: configDefinitionsLocal,
             plusFiles: plusFilesRelevant,
             configValueSources,

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

@@ -10,7 +10,7 @@
 // - We dedupe errors ourself with getHttpRequestAsyncStore().shouldErrorBeSwallowed()
 export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
-import { renderPage_addWrapper } from '../../runtime/renderPage.js';
+import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
 import { assert, assertIsNotProductionRuntime, isObject, unique } from '../utils.js';
 import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
@@ -27,7 +27,7 @@ async function installHttpRequestAsyncStore() {
         return;
     }
     asyncLocalStorage = new mod.AsyncLocalStorage();
-    renderPage_addWrapper(async (httpRequestId, renderPage) => {
+    renderPage_addAsyncHookwrapper(async (httpRequestId, renderPage) => {
         assert(asyncLocalStorage);
         const loggedErrors = new Set();
         const markErrorAsLogged = (err) => {

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

@@ -20,7 +20,7 @@ export type { GlobalContextInternal };
 export type { GlobalContextPublic };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import type { ConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 import { type BaseUrlsResolved } from '../shared/resolveBase.js';
 type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages' | 'baseAssets' | 'baseServer'>;
@@ -32,7 +32,7 @@ type GlobalContext = {
     viteConfigRuntime: {
         _baseViteOriginal: null | string;
     };
-    config: ConfigUserFriendly['config'];
+    config: PageConfigUserFriendly['config'];
     pages: PageConfigsUserFriendly;
 } & BaseUrlsResolved & PageRuntimeInfo & ({
     isProduction: false;

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

@@ -124,7 +124,7 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    // globalObject.isProduction isn't set upon production server without vike-server (there isn't any signal we can use)
+    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environement is production or development.)
     if (globalObject.isProduction === undefined)
         setIsProduction(true);
     await initGlobalContext();

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

@@ -1,7 +1,7 @@
 export { executeOnBeforeRenderAndDataHooks };
-import { type PageConfigUserFriendly } from '../../../shared/getPageFiles.js';
+import { type PageConfigUserFriendlyOld } from '../../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 declare function executeOnBeforeRenderAndDataHooks(pageContext: {
     pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageConfigUserFriendly & PageContextForUserConsumptionServerSide): Promise<void>;
+} & PageConfigUserFriendlyOld & PageContextForUserConsumptionServerSide): Promise<void>;

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

@@ -16,7 +16,7 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
     pageId: string;
-} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageConfigUserFriendly & {
+} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

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

@@ -1,6 +1,6 @@
 export { loadUserFilesServerSide };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
-import { getPageConfigUserFriendlyOld } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getPageConfigUserFriendly_oldDesign } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { assert, assertUsage, assertWarning, hasProp, isArrayOfStrings, objectAssign, isArray } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
@@ -100,7 +100,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pag
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const pageContextExports = getPageConfigUserFriendly_oldDesign(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
         pageContextExports,
         pageFilesLoaded: pageFilesServerSide

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

@@ -2,10 +2,10 @@ export { preparePageContextForUserConsumptionServerSide };
 export type { PageContextForUserConsumptionServerSide };
 import { PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-import type { PageConfigUserFriendly } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
+import type { PageConfigUserFriendlyOld } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { PageContextBuiltInServerInternal } from '../../../shared/types.js';
 import type { GlobalContextInternal, GlobalContextPublic } from '../globalContext.js';
-type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & PageConfigUserFriendly & {
+type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & PageConfigUserFriendlyOld & {
     urlOriginal: string;
     /** @deprecated */
     url: string;

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

@@ -63,7 +63,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendly & {
+    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -117,7 +117,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendly & {
+    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -172,7 +172,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendly & {
+    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];
@@ -226,7 +226,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         url: string;
     } & {
         headers: Record<string, string> | null;
-    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendly & {
+    } & import("../../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
         Page: unknown;
         _isHtmlOnly: boolean;
         _passToClient: string[];

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,5 +1,5 @@
 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';
@@ -21,12 +21,6 @@ import { resolveRedirects } from './renderPage/resolveRedirects.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);
@@ -40,12 +34,20 @@ async function renderPage(pageContextInit) {
     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) => {
@@ -64,8 +66,11 @@ 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);
@@ -452,6 +457,6 @@ async function assertBaseUrl(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(urlWithoutPageContextRequestSuffix, baseServer);
+    assertUsage(!isBaseMissing, `${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)`);
 }

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/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/getPageContextUrlComputed.js

@@ -86,8 +86,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/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;
     };

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;