vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

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

@@ -5,6 +5,7 @@ export type { GetPageAssets };
 export type { PageContextGetPageAssets };
 import { type MediaType } from './inferMediaType.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { GlobalContext } from '../globalContext.js';
 import type { ResolveClientEntriesDev } from '../../plugin/shared/resolveClientEntriesDev.js';
 type PageAsset = {
     src: string;
@@ -17,6 +18,7 @@ type PageContextGetPageAssets = {
     _baseServer: string;
     _baseAssets: string | null;
     _includeAssetsImportedByServer: boolean;
+    _globalContext: GlobalContext;
 };
 declare function getPageAssets(pageContext: PageContextGetPageAssets, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;
 declare function setResolveClientEntriesDev(resolveClientEntriesDev: ResolveClientEntriesDev): void;

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

@@ -6,13 +6,13 @@ import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
 import { inferMediaType } from './inferMediaType.js';
 import { getManifestEntry } from './getPageAssets/getManifestEntry.js';
 import { sortPageAssetsForEarlyHintsHeader } from './getPageAssets/sortPageAssetsForEarlyHintsHeader.js';
-import { getGlobalContext } from '../globalContext.js';
 const globalObject = getGlobalObject('getPageAssets.ts', {
     resolveClientEntriesDev: null
 });
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {
-    const globalContext = getGlobalContext();
-    const isDev = !globalContext.isProduction;
+    const globalContext = pageContext._globalContext;
+    const { isProduction } = globalContext;
+    const isDev = !isProduction;
     let assetUrls;
     let clientEntriesSrc;
     if (isDev) {
@@ -55,7 +55,7 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
         pageAsset.src = prependBase(toPosixPath(pageAsset.src), baseServerAssets);
         return pageAsset;
     });
-    sortPageAssetsForEarlyHintsHeader(pageAssets);
+    await sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction);
     return pageAssets;
 }
 function resolveClientEntriesProd(clientEntry, assetsManifest) {

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

@@ -1,4 +1,5 @@
 export { handleErrorWithoutErrorPage };
+import type { GlobalContext } from '../globalContext.js';
 import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageFile } from '../../../shared/getPageFiles.js';
@@ -9,5 +10,6 @@ declare function handleErrorWithoutErrorPage<PageContext extends {
     pageId: null;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
+    _globalContext: GlobalContext;
     urlOriginal: string;
 }>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;

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

@@ -1,6 +1,5 @@
 export { handleErrorWithoutErrorPage };
 import { stringify } from '@brillout/json-serializer/stringify';
-import { getGlobalContext } from '../globalContext.js';
 import { assert, assertWarning, objectAssign } from '../utils.js';
 import { createHttpResponsePage, createHttpResponseError } from './createHttpResponse.js';
 import pc from '@brillout/picocolors';
@@ -10,7 +9,7 @@ async function handleErrorWithoutErrorPage(pageContext) {
     assert(pageContext.errorWhileRendering || pageContext.is404);
     {
         const isV1 = pageContext._pageConfigs.length > 0;
-        warnMissingErrorPage(isV1);
+        await warnMissingErrorPage(isV1, pageContext._globalContext.isProduction);
     }
     if (!pageContext.isClientSideNavigation) {
         const httpResponse = createHttpResponseError(pageContext);
@@ -25,9 +24,8 @@ async function handleErrorWithoutErrorPage(pageContext) {
         return pageContext;
     }
 }
-function warnMissingErrorPage(isV1) {
-    const globalContext = getGlobalContext();
-    if (!globalContext.isProduction) {
+async function warnMissingErrorPage(isV1, isProduction) {
+    if (!isProduction) {
         const msg = [
             `No ${isV1 ? 'error page' : pc.cyan('_error.page.js')} found,`,
             'we recommend defining one',

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

@@ -6,10 +6,12 @@ import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
+import type { GlobalContext } from '../globalContext.js';
 type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
+    _globalContext: GlobalContext;
 };
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {

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

@@ -1,20 +1,21 @@
 export { loadUserFilesServerSide };
-import { getPageFilesServerSide, getPageConfigUserFriendly } from '../../../shared/getPageFiles.js';
+import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
+import { getPageConfigUserFriendlyOld } 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';
 import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
-import { getGlobalContext } from '../globalContext.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 async function loadUserFilesServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
+    const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext.pageId, !getGlobalContext().isProduction),
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext.pageId, !globalContext.isProduction),
         analyzePageClientSideInit(pageContext._pageFilesAll, pageContext.pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
-    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext.pageId);
+    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await analyzePage(pageContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);
     const isV1Design = !!pageConfig;
     const passToClient = [];
     const errMsg = ' should be an array of strings.';
@@ -99,7 +100,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = getPageConfigUserFriendly(pageFilesServerSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesServerSide, pageConfigLoaded);
     return {
         pageContextExports,
         pageFilesLoaded: pageFilesServerSide

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

@@ -1,10 +1,12 @@
 export { log404 };
 export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared/route/index.js';
+import type { GlobalContext } from '../../globalContext.js';
 declare function log404(pageContext: {
     urlPathname: string;
     errorWhileRendering: null | Error;
     isClientSideNavigation: boolean;
     _pageRoutes: PageRoutes;
+    _globalContext: GlobalContext;
 }): Promise<void>;
 declare function getRoutesInfo(pageRoutes: PageRoutes): string | null;

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

@@ -2,7 +2,6 @@ export { log404 };
 // Exported for ./index.spec.ts
 export { getRoutesInfo };
 import { noRouteMatch } from '../../../../shared/route/noRouteMatch.js';
-import { getGlobalContext } from '../../globalContext.js';
 import { assert, assertUsage, assertInfo, compareString, stripAnsi, getTerminalWidth, truncateString } from '../../utils.js';
 import pc from '@brillout/picocolors';
 async function log404(pageContext) {
@@ -13,7 +12,7 @@ async function log404(pageContext) {
     'No page found. Create at least one /pages/some-page/+Page.js file.'
     */
     );
-    const globalContext = getGlobalContext();
+    const globalContext = pageContext._globalContext;
     if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
         const routesInfo = getRoutesInfo(pageRoutes);
         let msg = `URL ${pc.cyan(urlPathname)} ${noRouteMatch}`;

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

@@ -4,6 +4,7 @@ import { PageContextUrlInternal } from '../../../shared/getPageContextUrlCompute
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageConfigUserFriendly } from '../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { PageContextBuiltInServerInternal } from '../../../shared/types.js';
+import type { GlobalContext, GlobalContextPublic } from '../globalContext.js';
 type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & PageConfigUserFriendly & {
     urlOriginal: string;
     /** @deprecated */
@@ -17,5 +18,7 @@ type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal
     is404: null | boolean;
     isClientSideNavigation: boolean;
     pageProps?: Record<string, unknown>;
+    _globalContext: GlobalContext;
+    globalContext: GlobalContextPublic;
 } & Record<string, unknown>;
 declare function preparePageContextForUserConsumptionServerSide(pageContext: PageContextForUserConsumptionServerSide): void;

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

@@ -5,6 +5,7 @@ export { getPageContextInitEnhanced };
 export type { PageContextAfterRender };
 export type { PageContextInitEnhanced };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
+import type { GlobalContext } from '../globalContext.js';
 import { HttpResponse } from './createHttpResponse.js';
 import { PageContext_loadUserFilesServerSide, type PageFiles } from './loadUserFilesServerSide.js';
 type PageContextAfterRender = {
@@ -45,6 +46,9 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _allPageIds: string[];
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        _globalContext: GlobalContext;
+        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+        globalContext: import("../globalContext.js").GlobalContextPublic;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -96,6 +100,9 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _allPageIds: string[];
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        _globalContext: GlobalContext;
+        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+        globalContext: import("../globalContext.js").GlobalContextPublic;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -130,7 +137,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _urlHandler: null;
     };
 }>;
-declare function prerender404Page(pageContextInit_: Record<string, unknown> | null): Promise<{
+declare function prerender404Page(pageContextInit_: Record<string, unknown> | null, globalContext: GlobalContext): Promise<{
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
@@ -148,6 +155,9 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         _allPageIds: string[];
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        _globalContext: GlobalContext;
+        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+        globalContext: import("../globalContext.js").GlobalContextPublic;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -199,6 +209,9 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         _allPageIds: string[];
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        _globalContext: GlobalContext;
+        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+        globalContext: import("../globalContext.js").GlobalContextPublic;
         _pageContextInit: {
             urlOriginal: string;
             headersOriginal?: unknown;
@@ -233,18 +246,18 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
         _urlHandler: null;
     };
 } | null>;
-type PageContextInitEnhanced = ReturnType<typeof getPageContextInitEnhanced>;
+type PageContextInitEnhanced = Awaited<ReturnType<typeof getPageContextInitEnhanced>>;
 declare function getPageContextInitEnhanced(pageContextInit: {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
-}, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
+}, globalContext: GlobalContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
     ssr?: {
         urlRewrite: null | string;
         urlHandler: null | ((url: string) => string);
         isClientSideNavigation: boolean;
     };
-}): {
+}): Promise<{
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
@@ -259,6 +272,9 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     _allPageIds: string[];
     _pageRoutes: import("../../../__internal/index.js").PageRoutes;
     _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+    _globalContext: GlobalContext;
+    /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+    globalContext: import("../globalContext.js").GlobalContextPublic;
     _pageContextInit: {
         urlOriginal: string;
         headersOriginal?: unknown;
@@ -273,4 +289,4 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     url: string;
 } & {
     headers: Record<string, string> | null;
-};
+}>;

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

@@ -7,7 +7,6 @@ import { getHtmlString } from '../html/renderHtml.js';
 import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAssign } from '../utils.js';
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
-import { getGlobalContext } from '../globalContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
 import { loadUserFilesServerSide } from './loadUserFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
@@ -81,8 +80,7 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }
-async function prerender404Page(pageContextInit_) {
-    const globalContext = getGlobalContext();
+async function prerender404Page(pageContextInit_, globalContext) {
     const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
     if (!errorPageId) {
         return null;
@@ -102,20 +100,19 @@ async function prerender404Page(pageContextInit_) {
     };
     objectAssign(pageContextInit, pageContextInit_);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit);
+        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
     objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     return prerenderPage(pageContext);
 }
-function getPageContextInitEnhanced(pageContextInit, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
 } } = {}) {
     assert(pageContextInit.urlOriginal);
-    const globalContext = getGlobalContext();
-    const { baseServer, baseAssets } = resolveBaseRuntime();
+    const { baseServer, baseAssets } = resolveBaseRuntime(globalContext);
     const pageContextInitEnhanced = {};
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
@@ -124,14 +121,18 @@ function getPageContextInitEnhanced(pageContextInit, { ssr: { urlRewrite, urlHan
         _baseServer: baseServer,
         _baseAssets: baseAssets,
         // TODO/now: add meta.default
-        _includeAssetsImportedByServer: globalContext.vikeConfig.global.config.includeAssetsImportedByServer ?? true,
-        // TODO: use GloablContext instead
+        _includeAssetsImportedByServer: globalContext.config.includeAssetsImportedByServer ?? true,
+        // TODO/soon: use GloablContext instead
         _pageFilesAll: globalContext.pageFilesAll,
         _pageConfigs: globalContext.pageConfigs,
         _pageConfigGlobal: globalContext.pageConfigGlobal,
         _allPageIds: globalContext.allPageIds,
         _pageRoutes: globalContext.pageRoutes,
         _onBeforeRouteHook: globalContext.onBeforeRouteHook,
+        _globalContext: globalContext,
+        // TODO/now: add PageContext['globalContext']
+        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+        globalContext: globalContext.globalContext_public,
         _pageContextInit: pageContextInit,
         _urlRewrite: urlRewrite,
         _urlHandler: urlHandler,

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

@@ -4,7 +4,7 @@ import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPag
 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 { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
+import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
 import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
@@ -76,25 +76,26 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         return handleInvalidConfig(isConfigInvalid.err);
     }
     else {
-        // From now on, gloablContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
+        // From now on, globalContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
+    const globalContext = await getGlobalContextInternal();
     // Check Base URL
-    assertBaseUrl(pageContextInit);
+    await assertBaseUrl(pageContextInit, globalContext);
     // Normalize URL
     {
-        const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId);
+        const pageContextHttpResponse = await normalizeUrl(pageContextInit, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
     // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpResponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        const pageContextHttpResponse = await getPermanentRedirect(pageContextInit, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
-    return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, []);
+    return await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, []);
 }
-async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageContextsFromRewrite) {
+async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, pageContextsFromRewrite) {
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, 
     // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
@@ -106,7 +107,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
         objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
     }
     {
-        const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, pageContextNominalPageInit._urlRewrite, httpRequestId);
+        const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
         objectAssign(pageContextNominalPageInit, pageContextInitEnhanced);
     }
     let errNominalPage;
@@ -138,10 +139,10 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
         assert(pageContextNominalPageSuccess === undefined);
         assert(pageContextNominalPageInit);
         assert(hasProp(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPageInit, httpRequestId);
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPageInit, httpRequestId);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if (isAbortError(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit);
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -154,7 +155,6 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const globalContext = getGlobalContext();
             const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
             if (!errorPageId) {
                 objectAssign(pageContextErrorPageInit, { pageId: null });
@@ -171,7 +171,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageCon
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if (isAbortError(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit);
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
                 // throw render(abortStatusCode)
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
@@ -287,8 +287,8 @@ async function renderPageNominal(pageContext) {
     assert(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, null, httpRequestId);
+async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
+    const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
     assert(errNominalPage);
     const pageContext = {};
     objectAssign(pageContext, pageContextInitEnhanced);
@@ -303,9 +303,9 @@ async function getPageContextErrorPageInit(pageContextInit, errNominalPage, page
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
-function getPageContextInitEnhancedSSR(pageContextInit, urlRewrite, httpRequestId) {
+async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, {
+    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -336,10 +336,9 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
         return;
     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')}`);
 }
-function normalizeUrl(pageContextInit, httpRequestId) {
-    const globalContext = getGlobalContext();
-    const { baseServer } = resolveBaseRuntime();
-    const { trailingSlash, disableUrlNormalization } = globalContext.vikeConfig.global.config;
+async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
+    const { baseServer } = resolveBaseRuntime(globalContext);
+    const { trailingSlash, disableUrlNormalization } = globalContext.config;
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
@@ -355,14 +354,13 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
-function getPermanentRedirect(pageContextInit, httpRequestId) {
-    const globalContext = getGlobalContext();
-    const { baseServer } = resolveBaseRuntime();
+async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
+    const { baseServer } = resolveBaseRuntime(globalContext);
     const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
-        const urlTarget = resolveRedirects(globalContext.vikeConfig.global.config.redirects ?? [], urlPathname);
+        const urlTarget = resolveRedirects(globalContext.config.redirects ?? [], urlPathname);
         if (urlTarget === null)
             return null;
         if (!isUrl(urlTarget)) {
@@ -389,7 +387,7 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         }
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
-        const { baseServer } = resolveBaseRuntime();
+        const { baseServer } = resolveBaseRuntime(globalContext);
         if (!originChanged)
             urlTarget = prependBase(urlTarget, baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
@@ -405,13 +403,12 @@ function normalize(url) {
 }
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
-pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
-    logAbortErrorHandled(errAbort, getGlobalContext().isProduction, pageContextNominalPageInit);
+pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
+    logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
     if (pageContextNominalPageInit.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const globalContext = getGlobalContext();
             const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
@@ -432,7 +429,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRewrite) {
-        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, httpRequestId, [
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, [
             ...pageContextsFromRewrite,
             pageContextAbort
         ]);
@@ -455,8 +452,8 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-function assertBaseUrl(pageContextInit) {
-    const { baseServer } = resolveBaseRuntime();
+async function assertBaseUrl(pageContextInit, globalContext) {
+    const { baseServer } = resolveBaseRuntime(globalContext);
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);

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

@@ -15,6 +15,7 @@ export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';
+export * from '../../utils/objectAssignSafe.js';
 export * from '../../utils/objectReplace.js';
 export * from '../../utils/PromiseType.js';
 export * from '../../utils/compareString.js';

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

@@ -19,6 +19,7 @@ export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';
+export * from '../../utils/objectAssignSafe.js';
 export * from '../../utils/objectReplace.js';
 export * from '../../utils/PromiseType.js';
 export * from '../../utils/compareString.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -1,13 +1,15 @@
 export { createDevMiddleware };
 import { createServer } from 'vite';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
+import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
 /*
  * Create server middleware for development with HMR and lazy-transpiling.
  *
  * https://vike.dev/createDevMiddleware
  */
 async function createDevMiddleware(options = {}) {
-    const viteConfig = {
+    setGlobalContext_isProduction(false);
+    const viteConfigFromOptions = {
         ...options.viteConfig,
         server: {
             ...options.viteConfig?.server,
@@ -15,8 +17,8 @@ async function createDevMiddleware(options = {}) {
         }
     };
     if (options.root)
-        viteConfig.root = options.root;
-    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfig, 'dev');
+        viteConfigFromOptions.root = options.root;
+    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfigFromOptions, 'dev');
     const server = await createServer(viteConfigEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };

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

@@ -2,6 +2,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;
@@ -10,5 +11,5 @@ type BaseUrlsResolved = {
     baseServer: string;
     baseAssets: string;
 };
-declare function resolveBaseRuntime(): BaseUrlsResolved;
+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

@@ -3,17 +3,15 @@ export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
 import pc from '@brillout/picocolors';
-import { getGlobalContext } from '../runtime/globalContext.js';
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     let baseViteOriginal = config._baseViteOriginal;
     assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
     return resolveBase(baseViteOriginal, baseServer, baseAssets);
 }
-function resolveBaseRuntime() {
-    const globalContext = getGlobalContext();
+function resolveBaseRuntime(globalContext) {
     const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
-    const baseServerUnresolved = globalContext.vikeConfig.global.config.baseServer ?? null;
-    const baseAssetsUnresolved = globalContext.vikeConfig.global.config.baseAssets ?? null;
+    const baseServerUnresolved = globalContext.config.baseServer ?? null;
+    const baseAssetsUnresolved = globalContext.config.baseAssets ?? null;
     return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
 }
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {

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

@@ -0,0 +1,13 @@
+export { getPageConfigsRuntime };
+export { getAllPageIds };
+import type { PageFile } from './getPageFiles.js';
+import { type ConfigUserFriendly } 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;
+};
+declare function getAllPageIds(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string[];

package/dist/esm/shared/getPageConfigsRuntime.js

@@ -0,0 +1,18 @@
+export { getPageConfigsRuntime };
+export { getAllPageIds };
+import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
+import { getPageConfigUserFriendlyNew } 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);
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig };
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}