vike 0.4.220 → 0.4.221-commit-8577456

package/dist/esm/node/runtime/html/renderHtml.js

@@ -7,7 +7,6 @@ import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isH
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
 import { processStream, isStream, streamToString } from './stream.js';
 import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';
-import { getGlobalContext } from '../globalContext.js';
 import pc from '@brillout/picocolors';
 function isDocumentHtml(something) {
     if (isTemplateWrapped(something) || isEscapedString(something) || isStream(something)) {
@@ -31,7 +30,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
     }
     if (isTemplateWrapped(documentHtml)) {
         const templateContent = documentHtml._template;
-        const render = await renderTemplate(templateContent, pageContext);
+        const render = renderTemplate(templateContent, pageContext);
         if (!('htmlStream' in render)) {
             objectAssign(pageContext, { _isStream: false });
             const { htmlPartsAll } = render;
@@ -120,7 +119,7 @@ function _dangerouslySkipEscape(arg) {
     });
     return { _escaped: String(arg) };
 }
-async function renderTemplate(templateContent, pageContext) {
+function renderTemplate(templateContent, pageContext) {
     const htmlPartsBegin = [];
     const htmlPartsEnd = [];
     let htmlStream = null;
@@ -151,7 +150,7 @@ async function renderTemplate(templateContent, pageContext) {
         // Process `escapeInject` fragments
         if (isTemplateWrapped(templateVar)) {
             const templateContentInner = templateVar._template;
-            const result = await renderTemplate(templateContentInner, pageContext);
+            const result = renderTemplate(templateContentInner, pageContext);
             if (!('htmlStream' in result)) {
                 result.htmlPartsAll.forEach(addHtmlPart);
             }
@@ -193,7 +192,7 @@ async function renderTemplate(templateContent, pageContext) {
             }
         }
         {
-            const { isProduction } = getGlobalContext();
+            const { isProduction } = pageContext._globalContext;
             if (isHtml(templateVar) &&
                 // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
                 !isProduction) {

package/dist/esm/node/runtime/page-files/setup.js

@@ -1,3 +1,3 @@
 export {};
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 // This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

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

@@ -2,4 +2,5 @@ export { analyzePage };
 import type { PageFile } from '../../../shared/getPageFiles/getPageFileObject.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type AnalysisResult } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string): AnalysisResult;
+import type { GlobalContext } from '../globalContext.js';
+declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string, globalContext: GlobalContext): Promise<AnalysisResult>;

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

@@ -3,9 +3,8 @@ import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClie
 import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
-import { getGlobalContext } from '../globalContext.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
-function analyzePage(pageFilesAll, pageConfig, pageId) {
+async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
     if (pageConfig) {
         const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
@@ -21,7 +20,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
-        if (!getGlobalContext().isProduction) {
+        if (!globalContext.isProduction) {
             clientDependencies.push({
                 id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, false),
                 onlyAssets: true,

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

@@ -1,6 +1,6 @@
 export { getEarlyHints };
+import { isFontFallback } from './isFontFallback.js';
 import { inferEarlyHintLink } from '../html/injectAssets/inferHtmlTags.js';
-import { assert } from '../utils.js';
 function getEarlyHints(assets) {
     const earlyHints = [];
     {
@@ -16,28 +16,3 @@ function getEarlyHints(assets) {
     }
     return earlyHints;
 }
-function isFontFallback(asset, earlyHints) {
-    if (asset.assetType !== 'font') {
-        return false;
-    }
-    const fontUrlBase = removeFileExtentionAndHash(asset.src);
-    return earlyHints.some((hint) => {
-        return hint.assetType === 'font' && removeFileExtentionAndHash(hint.src) === fontUrlBase;
-    });
-}
-function removeFileExtentionAndHash(assetUrl) {
-    assert(!assetUrl.includes('\\'));
-    // The logic below doesn't work for '/assets/chunk-0e184ced.js'
-    assert(!assetUrl.endsWith('.js'));
-    const paths = assetUrl.split('/');
-    {
-        const filename = paths[paths.length - 1];
-        const filenameParts = filename.split('.');
-        assert(filenameParts.length >= 2);
-        // User may set config.build.rollupOptions.output.assetFileNames => we can't assume the filename to be `*.${hash}.${ext}`
-        const filenameBase = filenameParts.slice(0, filenameParts.length === 2 ? -1 : -2);
-        assert(filenameBase.length >= 1);
-        paths[paths.length - 1] = filenameBase.join('.');
-    }
-    return paths.join('/');
-}

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

@@ -1,3 +1,3 @@
 export { sortPageAssetsForEarlyHintsHeader };
 import type { PageAsset } from '../getPageAssets.js';
-declare function sortPageAssetsForEarlyHintsHeader(pageAssets: PageAsset[]): void;
+declare function sortPageAssetsForEarlyHintsHeader(pageAssets: PageAsset[], isProduction: boolean): Promise<void>;

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

@@ -1,11 +1,9 @@
 export { sortPageAssetsForEarlyHintsHeader };
-import { getGlobalContext } from '../../globalContext.js';
 import { higherFirst } from '../../utils.js';
-function sortPageAssetsForEarlyHintsHeader(pageAssets) {
-    const globalContext = getGlobalContext();
+async function sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction) {
     pageAssets.sort(higherFirst(({ assetType }) => {
         // In dev, we load scripts first in order to parallelize I/O and CPU
-        if (!globalContext.isProduction && assetType === 'script') {
+        if (!isProduction && assetType === 'script') {
             return 1;
         }
         let priority = 0;

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

@@ -5,7 +5,8 @@ export type { GetPageAssets };
 export type { PageContextGetPageAssets };
 import { type MediaType } from './inferMediaType.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-import type { ResolveClientEntriesDev } from '../../plugin/resolveClientEntriesDev.js';
+import type { GlobalContext } from '../globalContext.js';
+import type { ResolveClientEntriesDev } from '../../plugin/shared/resolveClientEntriesDev.js';
 type PageAsset = {
     src: string;
     assetType: null | NonNullable<MediaType>['assetType'];
@@ -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/isFontFallback.d.ts

@@ -0,0 +1,3 @@
+export { isFontFallback };
+import type { PageAsset } from './getPageAssets.js';
+declare function isFontFallback(asset: PageAsset, pageAssets: PageAsset[]): boolean;

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

@@ -0,0 +1,27 @@
+export { isFontFallback };
+import { assert } from '../../../utils/assert.js';
+function isFontFallback(asset, pageAssets) {
+    if (asset.assetType !== 'font') {
+        return false;
+    }
+    const fontUrlBase = removeFileExtentionAndHash(asset.src);
+    return pageAssets.some((assetOther) => {
+        return assetOther.assetType === 'font' && removeFileExtentionAndHash(assetOther.src) === fontUrlBase;
+    });
+}
+function removeFileExtentionAndHash(assetUrl) {
+    assert(!assetUrl.includes('\\'));
+    // The logic below doesn't work for '/assets/chunk-0e184ced.js'
+    assert(!assetUrl.endsWith('.js'));
+    const paths = assetUrl.split('/');
+    {
+        const filename = paths[paths.length - 1];
+        const filenameParts = filename.split('.');
+        assert(filenameParts.length >= 2);
+        // User may set config.build.rollupOptions.output.assetFileNames => we can't assume the filename to be `*.${hash}.${ext}`
+        const filenameBase = filenameParts.slice(0, filenameParts.length === 2 ? -1 : -2);
+        assert(filenameBase.length >= 1);
+        paths[paths.length - 1] = filenameBase.join('.');
+    }
+    return paths.join('/');
+}

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 = {
@@ -37,7 +38,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -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;
@@ -88,7 +92,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -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: {
@@ -140,7 +147,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -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;
@@ -191,7 +201,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     } & {
         _objectCreatedByVike: boolean;
         _baseServer: string;
-        _baseAssets: string | null;
+        _baseAssets: string;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -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,25 +246,25 @@ 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;
 } & {
     _objectCreatedByVike: boolean;
     _baseServer: string;
-    _baseAssets: string | null;
+    _baseAssets: string;
     _includeAssetsImportedByServer: boolean;
     _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../../__internal/index.js").PageConfig[];
@@ -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';
@@ -18,6 +17,7 @@ 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
@@ -80,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;
@@ -101,34 +100,39 @@ 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(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: globalContext.baseServer,
-        _baseAssets: globalContext.baseAssets,
-        _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
-        // TODO: use GloablContext instead
+        _baseServer: baseServer,
+        _baseAssets: baseAssets,
+        // TODO/now: add meta.default
+        _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/resolveRedirects.d.ts

@@ -1,4 +1,6 @@
 export { resolveRedirects };
 export { resolveRouteStringRedirect };
+export { redirectsErrPrefix };
+declare const redirectsErrPrefix = "[+redirects]";
 declare function resolveRedirects(redirectsAll: Record<string, string>[], urlPathname: string): null | string;
 declare function resolveRouteStringRedirect(urlSource: string, urlTarget: string, urlPathname: string): null | string;

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

@@ -1,14 +1,14 @@
 export { resolveRedirects };
 // For ./resolveRedirects.spec.ts
 export { resolveRouteStringRedirect };
+export { redirectsErrPrefix };
 import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
 import { assert, assertUsage, assertUsageUrlRedirectTarget, isUrlRedirectTarget } from '../../../shared/utils.js';
 import { resolveUrlPathname } from '../../../shared/route/resolveUrlPathname.js';
 import { assertRouteString, resolveRouteString } from '../../../shared/route/resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
-// TODO/next-major-release: update
-const configSrc = '[vite.config.js > vike({ redirects })]';
+const redirectsErrPrefix = '[+redirects]';
 function resolveRedirects(redirectsAll, urlPathname) {
     const redirects = merge(redirectsAll);
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
@@ -19,9 +19,9 @@ function resolveRedirects(redirectsAll, urlPathname) {
     return null;
 }
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
-    assertRouteString(urlSource, `${configSrc} Invalid`);
+    assertRouteString(urlSource, `${redirectsErrPrefix} Invalid`);
     // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-    assertUsageUrlRedirectTarget(urlTarget, `${configSrc} The URL redirection target`, true);
+    assertUsageUrlRedirectTarget(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
     assertParams(urlSource, urlTarget);
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
@@ -37,7 +37,7 @@ function assertParams(urlSource, urlTarget) {
     routeSegments.forEach((routeSegment) => {
         if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
             const segments = urlSource.split('/');
-            assertUsage(segments.includes(routeSegment), `${configSrc} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
+            assertUsage(segments.includes(routeSegment), `${redirectsErrPrefix} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
         }
     });
 }