vike 0.4.238 → 0.4.239-commit-050a4a3

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

@@ -0,0 +1,46 @@
+export { resolveHeadersResponseEarly };
+export { resolveHeadersResponseFinal };
+import { addCspResponseHeader } from './csp.js';
+import { isCallable } from '../utils.js';
+import { cacheControlDisable, getCacheControl } from './getCacheControl.js';
+function resolveHeadersResponseFinal(pageContext, statusCode) {
+    const headersResponse = pageContext.headersResponse || new Headers();
+    // 5xx error pages are temporary and shouldn't be cached.
+    // This overrides any previously set Cache-Control value.
+    if (statusCode >= 500)
+        headersResponse.set('Cache-Control', cacheControlDisable);
+    const headers = [];
+    headersResponse.forEach((value, key) => {
+        headers.push([key, value]);
+    });
+    return headers;
+}
+async function resolveHeadersResponseEarly(pageContext) {
+    const headersResponse = await resolveHeadersResponseConfig(pageContext);
+    if (!headersResponse.get('Cache-Control')) {
+        const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs);
+        if (cacheControl)
+            headersResponse.set('Cache-Control', cacheControl);
+    }
+    addCspResponseHeader(pageContext, headersResponse);
+    const pageContextAddendum = {
+        headersResponse,
+    };
+    return pageContextAddendum;
+}
+async function resolveHeadersResponseConfig(pageContext) {
+    const headersMerged = new Headers();
+    await Promise.all((pageContext.config.headersResponse ?? []).map(async (headers) => {
+        let headersInit;
+        if (isCallable(headers)) {
+            headersInit = await headers(pageContext);
+        }
+        else {
+            headersInit = headers;
+        }
+        new Headers(headersInit).forEach((value, key) => {
+            headersMerged.append(key, value);
+        });
+    }));
+    return headersMerged;
+}

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/getHtmlTags.d.ts

@@ -4,7 +4,7 @@ export type { PreloadFilter };
 export type { InjectFilterEntry };
 import type { PageContextInjectAssets } from '../injectAssets.js';
 import type { StreamFromReactStreamingPackage } from '../stream/react-streaming.js';
-import type { PageAsset } from '../../renderPage/getPageAssets.js';
+import type { PageAsset } from '../../getPageAssets.js';
 type PreloadFilter = null | ((assets: InjectFilterEntry[]) => InjectFilterEntry[]);
 type PreloadFilterInject = false | 'HTML_BEGIN' | 'HTML_END';
 /** Filter what assets vike injects in the HTML.

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/getHtmlTags.js

@@ -1,15 +1,16 @@
 export { getHtmlTags };
-import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../utils.js';
+import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../../utils.js';
 import { getGlobalContextClientSerialized, getPageContextClientSerialized, } from '../serializeContext.js';
 import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
-import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
+import { getPageConfig } from '../../../../../shared/page-configs/helpers.js';
+import { getConfigValueRuntime } from '../../../../../shared/page-configs/getConfigValueRuntime.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
-import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../../../shared/htmlElementIds.js';
-import { isFontFallback } from '../../renderPage/isFontFallback.js';
+import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
+import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../../../../shared/htmlElementIds.js';
+import { isFontFallback } from '../../isFontFallback.js';
+import { inferNonceAttr } from '../../csp.js';
 const stamp = '__injectFilterEntry';
 async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     assert([true, false].includes(pageContext._isHtmlOnly));
@@ -76,7 +77,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
         .forEach((asset) => {
         if (!asset.inject)
             return;
-        const htmlTag = asset.isEntry ? inferAssetTag(asset) : inferPreloadTag(asset);
+        const htmlTag = asset.isEntry ? inferAssetTag(asset, pageContext) : inferPreloadTag(asset);
         htmlTags.push({ htmlTag, position: asset.inject });
     });
     // ==========
@@ -137,7 +138,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
         });
     }
     // The JavaScript entry <script> tag
-    const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript);
+    const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript, pageContext);
     if (scriptEntry) {
         htmlTags.push({
             htmlTag: scriptEntry,
@@ -158,9 +159,9 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
     });
     return htmlTags;
 }
-function mergeScriptEntries(pageAssets, viteDevScript) {
+function mergeScriptEntries(pageAssets, viteDevScript, pageContext) {
     const scriptEntries = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
-    let scriptEntry = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset)).join('')}`;
+    let scriptEntry = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset, pageContext)).join('')}`;
     // We merge scripts to avoid the infamous HMR preamble error.
     // - Infamous HMR preamble error:
     //   ```browser-console
@@ -178,12 +179,13 @@ function mergeScriptEntries(pageAssets, viteDevScript) {
     //   ```
     // - Maybe an alternative would be to make Vike's client runtime entry <script> tag non-async. Would that work? Would it be a performance issue?
     //   - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
-    scriptEntry = mergeScriptTags(scriptEntry);
+    scriptEntry = mergeScriptTags(scriptEntry, pageContext);
     return scriptEntry;
 }
 function getPageContextJsonScriptTag(pageContext) {
     const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext, true));
-    const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json">${pageContextClientSerialized}</script>`;
+    const nonceAttr = inferNonceAttr(pageContext);
+    const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json"${nonceAttr}>${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
     // @ts-expect-error
     pageContext._pageContextHtmlTag = htmlTag;
@@ -191,7 +193,8 @@ function getPageContextJsonScriptTag(pageContext) {
 }
 function getGlobalContextJsonScriptTag(pageContext) {
     const globalContextClientSerialized = sanitizeJson(getGlobalContextClientSerialized(pageContext, true));
-    const htmlTag = `<script id="${htmlElementId_globalContext}" type="application/json">${globalContextClientSerialized}</script>`;
+    const nonceAttr = inferNonceAttr(pageContext);
+    const htmlTag = `<script id="${htmlElementId_globalContext}" type="application/json"${nonceAttr}>${globalContextClientSerialized}</script>`;
     return htmlTag;
 }
 function assertInjectFilterEntries(injectFilterEntries) {

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/getViteDevScript.d.ts

@@ -1,5 +1,5 @@
 export { getViteDevScript };
-import type { GlobalContextServerInternal } from '../../globalContext.js';
+import type { GlobalContextServerInternal } from '../../../globalContext.js';
 declare function getViteDevScript(pageContext: {
     _globalContext: GlobalContextServerInternal;
 }): Promise<string>;

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/getViteDevScript.js

@@ -1,5 +1,5 @@
 export { getViteDevScript };
-import { assert, assertUsage, assertWarning, getViteRPC } from '../../utils.js';
+import { assert, assertUsage, assertWarning, getViteRPC } from '../../../utils.js';
 import pc from '@brillout/picocolors';
 const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {

package/dist/esm/node/runtime/renderPage/html/injectAssets/inferHtmlTags.d.ts

@@ -0,0 +1,10 @@
+export { inferAssetTag };
+export { inferPreloadTag };
+export { inferEarlyHintLink };
+export { scriptCommonAttrs };
+import type { PageAsset } from '../../getPageAssets.js';
+import { type PageContextCspNonce } from '../../csp.js';
+declare const scriptCommonAttrs = "type=\"module\" async";
+declare function inferPreloadTag(pageAsset: PageAsset): string;
+declare function inferAssetTag(pageAsset: PageAsset, pageContext: PageContextCspNonce): string;
+declare function inferEarlyHintLink(pageAsset: PageAsset): string;

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/inferHtmlTags.js

@@ -1,10 +1,11 @@
 export { inferAssetTag };
 export { inferPreloadTag };
 export { inferEarlyHintLink };
-export { scriptAttrs };
-import { assert } from '../../utils.js';
+export { scriptCommonAttrs };
+import { assert } from '../../../utils.js';
+import { inferNonceAttr } from '../../csp.js';
 // We can't use `defer` here. With `defer`, the entry script won't start before `</body>` has been parsed, preventing progressive hydration during SSR streaming, see https://github.com/vikejs/vike/pull/1271
-const scriptAttrs = 'type="module" async';
+const scriptCommonAttrs = 'type="module" async';
 function inferPreloadTag(pageAsset) {
     const { src, assetType, mediaType } = pageAsset;
     const rel = getRel(pageAsset);
@@ -20,11 +21,12 @@ function inferPreloadTag(pageAsset) {
         .join(' ');
     return `<link ${attributes}>`;
 }
-function inferAssetTag(pageAsset) {
+function inferAssetTag(pageAsset, pageContext) {
     const { src, assetType, mediaType } = pageAsset;
     if (assetType === 'script') {
         assert(mediaType === 'text/javascript');
-        return `<script src="${src}" ${scriptAttrs}></script>`;
+        const nonceAttr = inferNonceAttr(pageContext);
+        return `<script src="${src}" ${scriptCommonAttrs}${nonceAttr}></script>`;
     }
     if (assetType === 'style') {
         // WARNING: if changing following line, then also update https://github.com/vikejs/vike/blob/fae90a15d88e5e87ca9fcbb54cf2dc8773d2f229/vike/client/shared/removeFoucBuster.ts#L29

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/injectAssets__public.js

@@ -1,5 +1,5 @@
 export { injectAssets__public };
-import { assertUsage, assertWarning, castProp, hasProp } from '../../utils.js';
+import { assertUsage, assertWarning, castProp, hasProp } from '../../../utils.js';
 import { injectHtmlTagsToString } from '../injectAssets.js';
 // TO-DO/next-major-release: remove
 async function injectAssets__public(htmlString, pageContext) {

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/injectHtmlTags.js

@@ -6,7 +6,7 @@ export { joinHtmlTags };
 // Only needed for unit tests
 export { injectAtOpeningTag };
 export { injectAtClosingTag };
-import { assert, assertUsage, slice } from '../../utils.js';
+import { assert, assertUsage, slice } from '../../../utils.js';
 function injectHtmlTags(htmlString, htmlTags, position) {
     const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === position));
     if (htmlFragment) {

package/dist/esm/node/runtime/renderPage/html/injectAssets/mergeScriptTags.d.ts

@@ -0,0 +1,3 @@
+export { mergeScriptTags };
+import { type PageContextCspNonce } from '../../csp.js';
+declare function mergeScriptTags(scriptTagsHtml: string, pageContext: PageContextCspNonce): string;

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets/mergeScriptTags.js

@@ -1,10 +1,11 @@
 export { mergeScriptTags };
-import { assert } from '../../utils.js';
-import { scriptAttrs } from './inferHtmlTags.js';
+import { inferNonceAttr } from '../../csp.js';
+import { assert } from '../../../utils.js';
+import { scriptCommonAttrs } from './inferHtmlTags.js';
 const scriptRE = /(<script\b(?:\s[^>]*>|>))(.*?)<\/script>/gims;
 const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
-function mergeScriptTags(scriptTagsHtml) {
+function mergeScriptTags(scriptTagsHtml, pageContext) {
     let scriptTag = '';
     const scripts = parseScripts(scriptTagsHtml);
     // We need to merge module scripts to ensure execution order
@@ -33,7 +34,8 @@ function mergeScriptTags(scriptTagsHtml) {
                 }
             });
             if (contents.length > 0) {
-                scriptTag += `<script ${scriptAttrs}>\n${contents.join('\n')}\n</script>`;
+                const nonceAttr = inferNonceAttr(pageContext);
+                scriptTag += `<script ${scriptCommonAttrs}${nonceAttr}>\n${contents.join('\n')}\n</script>`;
             }
         }
     }

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets.d.ts

@@ -2,12 +2,12 @@ export { injectHtmlTagsToString };
 export { injectHtmlTagsToStream };
 export type { PageContextInjectAssets };
 export type { PageContextPromise };
-import type { PageAsset } from '../renderPage/getPageAssets.js';
+import type { PageAsset } from '../getPageAssets.js';
 import type { HtmlPart } from './renderHtml.js';
 import { type PreloadFilter } from './injectAssets/getHtmlTags.js';
 import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import type { PageContextSerialization } from './serializeContext.js';
-import type { GlobalContextServerInternal } from '../globalContext.js';
+import type { GlobalContextServerInternal } from '../../globalContext.js';
 type PageContextInjectAssets = {
     urlPathname: string;
     __getPageAssets: () => Promise<PageAsset[]>;

package/dist/esm/node/runtime/{html → renderPage/html}/injectAssets.js

@@ -1,7 +1,7 @@
 export { injectHtmlTagsToString };
 export { injectHtmlTagsToStream };
-import { assert, isCallable, isPromise } from '../utils.js';
-import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
+import { assert, isCallable, isPromise } from '../../utils.js';
+import { assertPageContextProvidedByUser } from '../../../../shared/assertPageContextProvidedByUser.js';
 import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream, } from './injectAssets/injectHtmlTags.js';
 import { getHtmlTags } from './injectAssets/getHtmlTags.js';
 import { getViteDevScript } from './injectAssets/getViteDevScript.js';

package/dist/esm/node/runtime/{html → renderPage/html}/propKeys.js

@@ -1,7 +1,7 @@
 export { getPropVal };
 export { setPropVal };
 export { getPropKeys };
-import { isObject } from '../utils.js';
+import { isObject } from '../../utils.js';
 // Get a nested property from an object using a dot-separated path such as 'user.id'
 function getPropVal(obj, prop) {
     const keys = getPropKeys(prop);

package/dist/esm/node/runtime/{html → renderPage/html}/renderHtml.d.ts

@@ -9,7 +9,7 @@ export type { DocumentHtml };
 export type { TemplateWrapped };
 import type { PageContextInjectAssets } from './injectAssets.js';
 import { StreamProviderAny, StreamTypePatch, StreamProviderNormalized } from './stream.js';
-import type { PageAsset } from '../renderPage/getPageAssets.js';
+import type { PageAsset } from '../getPageAssets.js';
 import type { PreloadFilter } from './injectAssets/getHtmlTags.js';
 type DocumentHtml = TemplateWrapped | EscapedString | StreamProviderAny;
 type HtmlRender = string | StreamProviderNormalized;

package/dist/esm/node/runtime/{html → renderPage/html}/renderHtml.js

@@ -3,7 +3,7 @@ export { dangerouslySkipEscape };
 export { renderDocumentHtml };
 export { isDocumentHtml };
 export { getHtmlString };
-import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign, } from '../utils.js';
+import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign, } from '../../utils.js';
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
 import { processStream, isStream, streamToString, } from './stream.js';
 import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';

package/dist/esm/node/runtime/{html → renderPage/html}/serializeContext.d.ts

@@ -4,10 +4,11 @@ export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
 export type { PassToClient };
 export type { PassToClientPublic };
-import type { UrlRedirect } from '../../../shared/route/abort.js';
-import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextCreated } from '../renderPage/createPageContextServerSide.js';
-import type { PageContextBegin } from '../renderPage.js';
+import type { UrlRedirect } from '../../../../shared/route/abort.js';
+import type { GlobalContextServerInternal } from '../../globalContext.js';
+import type { PageContextCreated } from '../createPageContextServerSide.js';
+import type { PageContextBegin } from '../../renderPage.js';
+import type { PageContextCspNonce } from '../csp.js';
 type PageContextSerialization = PageContextCreated & {
     pageId: string;
     routeParams: Record<string, string>;
@@ -17,7 +18,7 @@ type PageContextSerialization = PageContextCreated & {
     _pageContextInit: Record<string, unknown>;
     _globalContext: GlobalContextServerInternal;
     _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
-};
+} & PageContextCspNonce;
 declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
 type PassToClient = string[];

package/dist/esm/node/runtime/{html → renderPage/html}/serializeContext.js

@@ -2,13 +2,13 @@ export { getPageContextClientSerialized };
 export { getPageContextClientSerializedAbort };
 export { getGlobalContextClientSerialized };
 import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../utils.js';
-import { isErrorPage } from '../../../shared/error-page.js';
-import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../../utils.js';
+import { isErrorPage } from '../../../../shared/error-page.js';
+import { addIs404ToPageProps } from '../../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
-import { NOT_SERIALIZABLE } from '../../../shared/NOT_SERIALIZABLE.js';
-import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
-import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
+import { NOT_SERIALIZABLE } from '../../../../shared/NOT_SERIALIZABLE.js';
+import { pageContextInitIsPassedToClient } from '../../../../shared/misc/pageContextInitIsPassedToClient.js';
+import { isServerSideError } from '../../../../shared/misc/isServerSideError.js';
 import { getPropKeys, getPropVal, setPropVal } from './propKeys.js';
 const passToClientBuiltInPageContext = [
     'abortReason',

package/dist/esm/node/runtime/{html → renderPage/html}/stream/react-streaming.js

@@ -2,7 +2,7 @@
 export { isStreamFromReactStreamingPackage };
 export { streamFromReactStreamingPackageToString };
 export { getStreamOfReactStreamingPackage };
-import { assert, assertUsage, hasProp, isVikeReactApp } from '../../utils.js';
+import { assert, assertUsage, hasProp, isVikeReactApp } from '../../../utils.js';
 import { streamPipeNodeToString, streamReadableWebToString } from '../stream.js';
 function streamFromReactStreamingPackageToString(stream) {
     if (stream.pipe) {

package/dist/esm/node/runtime/{html → renderPage/html}/stream.js

@@ -19,7 +19,7 @@ export { streamReadableWebToString };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
-import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, isBug, } from '../utils.js';
+import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, isBug, } from '../../utils.js';
 import { getStreamOfReactStreamingPackage, isStreamFromReactStreamingPackage, streamFromReactStreamingPackageToString, } from './stream/react-streaming.js';
 import { import_ } from '@brillout/import';
 import pc from '@brillout/picocolors';

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

@@ -1,11 +1,12 @@
 export { loadPageConfigsLazyServerSide };
 export type { PageContext_loadPageConfigsLazyServerSide };
 export type { PageConfigsLazy };
-import { type VikeConfigPublicPageLazyLoaded } from '../../../shared/getPageFiles.js';
+export type { PageContextAfterPageEntryLoaded };
+import { type PageContextConfig } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { type PageAsset } from './getPageAssets.js';
 import type { PageConfigRuntime } from '../../../types/PageConfig.js';
-import type { PassToClient } from '../html/serializeContext.js';
+import type { PassToClient } from './html/serializeContext.js';
 import type { PageContextAfterRoute } from '../../../shared/route/index.js';
 import type { PageContextCreated } from './createPageContextServerSide.js';
 type PageContext_loadPageConfigsLazyServerSide = PageContextCreated & PageContextAfterRoute & {
@@ -24,23 +25,51 @@ declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPage
     headers?: Record<string, string>;
 } & {
     _globalContext: {
-        isGlobalContext: true;
-        _isOriginalObject: true;
-        _virtualFileExportsGlobalEntry: unknown;
-        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: PageConfigRuntime[];
-        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        _vikeConfigPublicGlobal: {
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../../types/index.js").ConfigResolved;
+                    _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
             config: import("../../../types/index.js").ConfigResolved;
             _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
             _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
             _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
         };
-        config: import("../../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
+            [k: string]: {
+                config: import("../../../types/index.js").ConfigResolved;
+                _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
         };
+        config: import("../../../types/index.js").ConfigResolved;
+        _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
     } & (({
         _isProduction: false;
         _isPrerendering: false;
@@ -92,6 +121,20 @@ declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPage
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
 } & {
+    pages: {
+        [k: string]: {
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
     config: import("../../../types/index.js").ConfigResolved;
     _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
     _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
@@ -107,15 +150,19 @@ declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPage
     pageId: string;
 } & {
     _pageConfig: PageConfigRuntime | null;
-} & {
-    _pageConfig: null | PageConfigRuntime;
-} & VikeConfigPublicPageLazyLoaded & {
+} & PageContextConfig & {
     _pageConfig: null | PageConfigRuntime;
+} & {
+    cspNonce: string | null;
 } & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: PassToClient;
+} & {
     headersResponse: Headers;
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;
 }>;
+type PageContextAfterPageEntryLoaded = PageContext_loadPageConfigsLazyServerSide & {
+    _pageConfig: null | PageConfigRuntime;
+} & PageContextConfig;

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

@@ -1,6 +1,6 @@
 export { loadPageConfigsLazyServerSide };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
-import { resolveVikeConfigPublicPageLazyLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolvePageContextConfig } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign, updateType, } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
@@ -8,13 +8,14 @@ import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { loadAndParseVirtualFilePageEntry } from '../../../shared/page-configs/loadAndParseVirtualFilePageEntry.js';
 import { execHookServer } from './execHookServer.js';
-import { getCacheControl } from './getCacheControl.js';
+import { resolveHeadersResponseEarly } from './headersResponse.js';
+import { resolvePageContextCspNone } from './csp.js';
 async function loadPageConfigsLazyServerSide(pageContext) {
     objectAssign(pageContext, {
         _pageConfig: findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId),
     });
     // Load the page's + files
-    updateType(pageContext, await loadPageUserFiles(pageContext));
+    objectAssign(pageContext, await loadPageUserFiles(pageContext));
     // Resolve new computed pageContext properties
     updateType(pageContext, await resolvePageContext(pageContext));
     // Execute +onCreatePageContext
@@ -53,12 +54,13 @@ async function resolvePageContext(pageContext) {
             passToClient.push(...valS);
         });
     }
+    objectAssign(pageContext, await resolvePageContextCspNone(pageContext));
     objectAssign(pageContext, {
         Page: pageContext.exports.Page,
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
-        headersResponse: resolveHeadersResponse(pageContext),
     });
+    objectAssign(pageContext, await resolveHeadersResponseEarly(pageContext));
     objectAssign(pageContext, {
         __getPageAssets: async () => {
             if ('_pageAssets' in pageContext) {
@@ -101,43 +103,20 @@ async function resolvePageContext(pageContext) {
     return pageContext;
 }
 async function loadPageUserFiles(pageContext) {
-    const [{ configPublicPageLazy }] = await Promise.all([
-        loadPageUserFiles_v1Design(pageContext),
+    const [{ pageContextAddendum }] = await Promise.all([
+        (async () => {
+            const pageFilesServerSide = getPageFilesServerSide(pageContext._pageFilesAll, pageContext.pageId);
+            const isDev = !pageContext._globalContext._isProduction;
+            const pageConfigLoaded = !pageContext._pageConfig
+                ? null
+                : await loadAndParseVirtualFilePageEntry(pageContext._pageConfig, isDev);
+            await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
+            const pageContextAddendum = resolvePageContextConfig(pageFilesServerSide, pageConfigLoaded, pageContext._globalContext._pageConfigGlobal);
+            return { pageContextAddendum };
+        })(),
         analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
             sharedPageFilesAlreadyLoaded: true,
         }),
     ]);
-    objectAssign(pageContext, configPublicPageLazy);
-    return pageContext;
-}
-async function loadPageUserFiles_v1Design(pageContext) {
-    const pageFilesServerSide = getPageFilesServerSide(pageContext._pageFilesAll, pageContext.pageId);
-    const isDev = !pageContext._globalContext._isProduction;
-    const pageConfigLoaded = !pageContext._pageConfig
-        ? null
-        : await loadAndParseVirtualFilePageEntry(pageContext._pageConfig, isDev);
-    await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const configPublicPageLazy = resolveVikeConfigPublicPageLazyLoaded(pageFilesServerSide, pageConfigLoaded, pageContext._globalContext._pageConfigGlobal);
-    return {
-        configPublicPageLazy,
-        pageFilesLoaded: pageFilesServerSide,
-    };
-}
-function resolveHeadersResponse(pageContext) {
-    const headersResponse = mergeHeaders(pageContext.config.headersResponse);
-    if (!headersResponse.get('Cache-Control')) {
-        const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs);
-        if (cacheControl)
-            headersResponse.set('Cache-Control', cacheControl);
-    }
-    return headersResponse;
-}
-function mergeHeaders(headersList = []) {
-    const headersMerged = new Headers();
-    headersList.forEach((headers) => {
-        new Headers(headers).forEach((value, key) => {
-            headersMerged.append(key, value);
-        });
-    });
-    return headersMerged;
+    return pageContextAddendum;
 }

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

@@ -1,10 +1,10 @@
 export { preparePageContextForPublicUsageServer };
 export type { PageContextForPublicUsageServer };
 import type { PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
-import type { VikeConfigPublicPageLazyLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import type { PageContextConfig } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import type { PageContextInternalServer } from '../../../types/PageContext.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPublicPageLazyLoaded & {
+type PageContextForPublicUsageServer = PageContextInternalServer & PageContextConfig & {
     urlOriginal: string;
     /** @deprecated */
     url: string;