vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/node/runtime/html/serializeContext.d.ts

@@ -2,17 +2,16 @@ export { getPageContextClientSerialized };
 export { getPageContextClientSerializedAbort };
 export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
-import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { UrlRedirect } from '../../../shared/route/abort.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
 type PageContextSerialization = {
     pageId: string;
     routeParams: Record<string, string>;
     _passToClient: string[];
-    _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     pageProps?: Record<string, unknown>;
     _pageContextInit: Record<string, unknown>;
-    _globalContext: Record<string, any>;
+    _globalContext: GlobalContextServerInternal;
 };
 declare function getPageContextClientSerialized(pageContext: PageContextSerialization): string;
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization): string;

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

@@ -22,7 +22,7 @@ const passToClientBuiltInPageContext = [
     pageContextInitIsPassedToClient,
     'pageId',
     'routeParams',
-    'data' // for data() hook
+    'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
 function getPageContextClientSerialized(pageContext) {
@@ -73,7 +73,7 @@ function serializeObject(obj, objName, passToClient) {
                 // Non-serializable property set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
-                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`,
                 ].join(' ');
                 if (isJsonSerializerError(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -107,7 +107,7 @@ function serializeValue(value, varName) {
 }
 function getPassToClientPageContext(pageContext) {
     let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
-    if (isErrorPage(pageContext.pageId, pageContext._pageConfigs)) {
+    if (isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs)) {
         assert(hasProp(pageContext, 'is404', 'boolean'));
         addIs404ToPageProps(pageContext);
         passToClient.push(...pageToClientBuiltInPageContextError);
@@ -133,7 +133,7 @@ function getPageContextClientSerializedAbort(pageContext) {
         'abortStatusCode',
         'abortReason',
         'is404',
-        'pageProps'
+        'pageProps',
     ].includes(prop));
     if (!pageContext._isLegacyRenderErrorPage) {
         assert(unknownProps.length === 0);
@@ -143,9 +143,9 @@ function getPageContextClientSerializedAbort(pageContext) {
         assertWarning(unknownProps.length === 0, [
             "The following pageContext values won't be available on the client-side:",
             unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
-            'Use `throw render()` instead of `throw RenderErrorPage()`'
+            'Use `throw render()` instead of `throw RenderErrorPage()`',
         ].join('\n'), {
-            onlyOnce: false
+            onlyOnce: false,
         });
     }
     return serializeValue(pageContext);

package/dist/esm/node/runtime/html/stream.d.ts

@@ -50,7 +50,7 @@ declare function getStreamReadableNode(htmlRender: HtmlRender): Promise<null | S
 declare function getStreamReadableWeb(htmlRender: HtmlRender): null | StreamReadableWeb;
 declare function pipeToStreamWritableWeb(htmlRender: HtmlRender, writable: StreamWritableWeb): boolean;
 declare function pipeToStreamWritableNode(htmlRender: HtmlRender, writable: StreamWritableNode): boolean;
-declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }: {
+declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }: {
     injectStringAtBegin?: () => Promise<string>;
     injectStringAfterFirstChunk?: () => string | null;
     injectStringAtEnd?: () => Promise<string>;

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

@@ -19,8 +19,8 @@ export { streamReadableWebToString };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
-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 { 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';
 const debug = createDebugger('vike:stream');
@@ -77,7 +77,7 @@ function stringToStreamReadableWeb(str) {
         start(controller) {
             controller.enqueue(encodeForWebStream(str));
             controller.close();
-        }
+        },
     });
     return readableStream;
 }
@@ -121,7 +121,7 @@ async function streamPipeNodeToString(streamPipeNode) {
             else {
                 resolve();
             }
-        }
+        },
     });
     streamPipeNode(writable);
     return promise;
@@ -138,7 +138,7 @@ function streamPipeWebToString(streamPipeWeb) {
         close() {
             str += getClosingChunk();
             resolve(str);
-        }
+        },
     });
     streamPipeWeb(writable);
     return promise;
@@ -212,7 +212,7 @@ function pipeToStreamWritableNode(htmlRender, writable) {
     checkType(htmlRender);
     assert(false);
 }
-async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
+async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
     let streamOriginalEnded = false;
@@ -310,7 +310,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         },
         onFlush() {
             flushStream();
-        }
+        },
     });
     wrapperCreated = true;
     flushBuffer(); // In case onReadyToWrite() was already called (the flushBuffer() of onReadyToWrite() wasn't called because `wrapperCreated === false`)
@@ -373,7 +373,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         return !enableEagerStreaming && !streamOriginalHasStartedEmitting;
     }
 }
-async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite }) {
+async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, }) {
     if (isStreamFromReactStreamingPackage(streamOriginal)) {
         debug(`onRenderHtml() hook returned ${pc.cyan('react-streaming')} result`);
         const stream = getStreamOfReactStreamingPackage(streamOriginal);
@@ -429,13 +429,13 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 }
                 callback(err);
                 endStream();
-            }
+            },
         });
         // Forward the flush() call
         objectAssign(writableProxy, {
             flush: () => {
                 onFlush();
-            }
+            },
         });
         assert(typeof writableProxy.flush === 'function');
         const pipeOriginal = getStreamPipeNode(streamOriginal);
@@ -492,7 +492,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 abort(err) {
                     onError(err);
                     endStream();
-                }
+                },
             });
         }
         else {
@@ -507,7 +507,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 async onEnd() {
                     await onEnd();
                     endStream();
-                }
+                },
             });
         }
         const pipeOriginal = getStreamPipeWeb(streamOriginal);
@@ -540,15 +540,15 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                     },
                     async onEnd() {
                         await closeStream();
-                    }
+                    },
                 });
             },
             async cancel(...args) {
                 isCancel = true;
                 await readableOriginal.cancel(...args);
-                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therfore closeStream() may already have been called at this point
+                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
                 await closeStream();
-            }
+            },
         });
         const writeChunk = (chunk) => {
             if (
@@ -565,7 +565,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const flushStream = null;
         return {
             streamWrapper: readableProxy,
-            streamWrapperOperations: { writeChunk, flushStream }
+            streamWrapperOperations: { writeChunk, flushStream },
         };
     }
     if (isStreamReadableNode(streamOriginal)) {
@@ -600,12 +600,12 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         });
         return {
             streamWrapper: readableProxy,
-            streamWrapperOperations: { writeChunk, flushStream }
+            streamWrapperOperations: { writeChunk, flushStream },
         };
     }
     assert(false);
 }
-async function handleReadableWeb(readable, { onData, onError, onEnd }) {
+async function handleReadableWeb(readable, { onData, onError, onEnd, }) {
     const reader = readable.getReader();
     while (true) {
         let result;
@@ -640,7 +640,7 @@ const __streamPipeWeb = '__streamPipeWeb';
 function pipeWebStream(pipe) {
     assertWarning(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { [__streamPipeWeb]: pipe };
 }
@@ -675,7 +675,7 @@ const __streamPipeNode = '__streamPipeNode';
 function pipeNodeStream(pipe) {
     assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { [__streamPipeNode]: pipe };
 }
@@ -707,7 +707,7 @@ function isStreamPipeNode(thing) {
 }
 function stampPipe(pipe, pipeType) {
     assertUsage(pipeType, `stampPipe(pipe, pipeType): argument ${pc.cyan('pipeType')} is missing.)`, {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(['web-stream', 'node-stream'].includes(pipeType), `stampPipe(pipe, pipeType): argument ${pc.cyan('pipeType')} should be either ${pc.cyan("'web-stream'")} or ${pc.cyan("'node-stream'")}.`, { showStackTrace: true });
     if (pipeType === 'node-stream') {

package/dist/esm/node/runtime/index-deprecated.js

@@ -1,4 +1,4 @@
-// TODO/soon: point package.json#exports['./server'] to this file.
+// TO-DO/soon: point package.json#exports['./server'] to this file.
 // - Write migration guide, see comment below.
 export * from './index.js';
 import { assertWarning } from './utils.js';
@@ -7,8 +7,8 @@ assertWarning(false, [
     'You have outdated imports:',
     pc.bold(pc.red("  import { something } from 'vike/server'")),
     'Replace them with:',
-    pc.bold(pc.green("  import { something } from 'vike'"))
-    /* Add migration guide, with migration scritps such as `$ rename vike/server vike`
+    pc.bold(pc.green("  import { something } from 'vike'")),
+    /* Add migration guide, with migration scripts such as `$ rename vike/server vike`
     `See ${pc.underline('https://vike.dev/migration/0.4.xxx')}`
     */
 ].join('\n'), { showStackTrace: true, onlyOnce: true });

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

@@ -33,7 +33,7 @@ export const RenderErrorPage = (...args) => {
         pc.red("  import { RenderErrorPage } from 'vike'"),
         'With:',
         pc.green("  import { render } from 'vike/abort'"),
-        'See https://vike.dev/render'
+        'See https://vike.dev/render',
     ].join('\n'), { onlyOnce: true, showStackTrace: true });
     return RenderErrorPage_(...args);
 };

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

@@ -1,5 +1,5 @@
 export declare let logRuntimeError: LogError;
 export declare let logRuntimeInfo: null | LogInfo;
 export { overwriteRuntimeProductionLogger };
-import type { LogError, LogInfo } from '../../plugin/shared/loggerNotProd.js';
+import type { LogError, LogInfo } from '../vite/shared/loggerNotProd.js';
 declare function overwriteRuntimeProductionLogger(logError_: LogError, logInfo_: LogInfo | null): void;

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

@@ -2,7 +2,7 @@
 export let logRuntimeError;
 export let logRuntimeInfo = null; // logInfo is null in production
 export { overwriteRuntimeProductionLogger };
-import { logErrorProd } from './loggerProd.js';
+import { logErrorProd } from './renderPage/loggerProd.js';
 // Set production logger (which is overwritten by loggerNotProd.ts in non-production environments such as development and during pre-rendering)
 logRuntimeError =
     // @ts-expect-error

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

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

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

@@ -1,7 +1,7 @@
 export { analyzePage };
 import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js';
 import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
 async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
@@ -15,16 +15,16 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
-            id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
+            id: getVirtualFileIdPageConfigLazy(pageConfig.pageId, true),
             onlyAssets: isClientRuntimeLoaded ? false : true,
-            eagerlyImported: false
+            eagerlyImported: false,
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
         if (!globalContext._isProduction) {
             clientDependencies.push({
-                id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, false),
+                id: getVirtualFileIdPageConfigLazy(pageConfig.pageId, false),
                 onlyAssets: true,
-                eagerlyImported: false
+                eagerlyImported: false,
             });
         }
         /* Remove?
@@ -48,7 +48,7 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             clientDependencies.push({
                 id: clientEntry,
                 onlyAssets: false,
-                eagerlyImported: false
+                eagerlyImported: false,
             });
         });
         return {
@@ -58,7 +58,7 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             clientDependencies,
             // pageFilesClientSide and pageFilesServerSide are only used for debugging
             pageFilesClientSide: [],
-            pageFilesServerSide: []
+            pageFilesServerSide: [],
         };
     }
     else {

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

@@ -7,7 +7,7 @@ function assertArguments(...args) {
     assertUsage(pageContextInit !== undefined && pageContextInit !== null, prefix + ` argument ${pc.cyan('pageContextInit')} is missing`, { showStackTrace: true });
     const len = args.length;
     assertUsage(len === 1, `${prefix} called with ${len} arguments but renderPage() accepts only one argument.'`, {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(isObject(pageContextInit), `${prefix} called with ${pc.code(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)} but ${pc.code('pageContextInit')} should be an object.`, { showStackTrace: true });
     // TODO/v1-release: remove

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

@@ -2,7 +2,7 @@ export { assertNoInfiniteHttpRedirect };
 import { assert, assertUsage, getGlobalObject, removeUrlOrigin } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
-    redirectGraph: {}
+    redirectGraph: {},
 });
 function assertNoInfiniteHttpRedirect(
 // The exact URL that the user will be redirected to.

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

@@ -1,5 +1,5 @@
 export { getCacheControl };
-import type { PageConfigRuntime } from '../../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../../types/PageConfig.js';
 import type { HttpResponse } from '../createHttpResponse.js';
 type StatusCode = HttpResponse['statusCode'];
 declare function getCacheControl(pageId: string | null, pageConfigs: PageConfigRuntime[], statusCode: StatusCode): string;

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

@@ -8,13 +8,12 @@ export { createHttpResponseBaseIsMissing };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
-import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { RenderHook } from './executeOnRenderHtmlHook.js';
 import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';
-import type { PageFile } from '../../../shared/getPageFiles.js';
 import type { PageContextBegin } from '../renderPage.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
 type HttpResponse = {
     statusCode: 200 | 404 | 500 | RedirectStatusCode | AbortStatusCode;
     headers: [string, string][];
@@ -27,14 +26,13 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
     is404: null | boolean;
     errorWhileRendering: null | Error;
     __getPageAssets: GetPageAssets;
-    _pageConfigs: PageConfigRuntime[];
+    _globalContext: GlobalContextServerInternal;
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse>;
 declare function createHttpResponse404(errMsg404: string): HttpResponse;
 declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
 declare function createHttpResponseError(pageContext: {
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
+    _globalContext: GlobalContextServerInternal;
 }): HttpResponse;
 declare function createHttpResponseErrorWithoutGlobalContext(): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;

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

@@ -14,7 +14,7 @@ import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfin
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
-        const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._pageConfigs);
+        const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs);
         if (pageContext.errorWhileRendering) {
             assert(isError);
         }
@@ -29,14 +29,14 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
     const headers = [];
-    const cacheControl = getCacheControl(pageContext.pageId, pageContext._pageConfigs, statusCode);
+    const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs, statusCode);
     if (cacheControl) {
         headers.push(['Cache-Control', cacheControl]);
     }
     return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
 }
 function createHttpResponse404(errMsg404) {
-    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], `<p>${errMsg404}.</p><script>console.log('This HTTP response was generated by Vike.')</script>`);
+    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
     return httpResponse;
 }
 function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
@@ -64,7 +64,7 @@ function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
 }
 function createHttpResponseError(pageContext) {
     const reason = (() => {
-        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+        const errorPageId = getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (errorPageId) {
             return "the error page (https://vike.dev/error-page) couldn't be rendered (for example if an error occurred while rendering the error page)";
         }
@@ -75,11 +75,10 @@ function createHttpResponseError(pageContext) {
     return createHttpResponseError_(reason);
 }
 function createHttpResponseErrorWithoutGlobalContext() {
-    const reason = 'no error page (https://vike.dev/error-page) could be rendered';
-    return createHttpResponseError_(reason);
+    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered');
 }
 function createHttpResponseError_(reason) {
-    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTTP response was generated by Vike. Vike returned this response because ${reason}.`)})</script>`);
+    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTML was generated by Vike. Vike returned this HTML because ${reason}.`)})</script>`);
     return httpResponse;
 }
 async function createHttpResponsePageContextJson(pageContextSerialized) {
@@ -95,7 +94,7 @@ function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
     return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
     // For bots / programmatic crawlig: show what's going on.
     // For users: showing a blank page is probably better than a flickering text.
-    `<p style="display: none">Redirecting to ${escapeHtml(url)}</p><script>console.log('This HTTP response was generated by Vike.')</script>`);
+    `<p style="display: none">Redirecting to ${escapeHtml(url)}</p><script>console.log('This HTML was generated by Vike.')</script>`);
 }
 function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
     headers.push(['Content-Type', contentType]);
@@ -112,6 +111,6 @@ function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyH
         get body() {
             return getHttpResponseBody(htmlRender, renderHook);
         },
-        ...getHttpResponseBodyStreamHandlers(htmlRender, renderHook)
+        ...getHttpResponseBodyStreamHandlers(htmlRender, renderHook),
     };
 }

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

@@ -4,7 +4,7 @@ export type { PageContextCreated };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPage.js';
 type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
-declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } }: {
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, { isPrerendering, ssr: { urlHandler, isClientSideNavigation }, }: {
     isPrerendering: false;
     ssr: {
         urlHandler: null | ((url: string) => string);
@@ -19,7 +19,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
 } & {
     isClientSide: false;
     isPrerendering: boolean;
-} & Pick<import("../../../shared/types.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     url?: string;
     headers?: Record<string, string>;
 } & {
@@ -28,19 +28,18 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
-        _userFriendlyConfigsGlobal: import("../../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
+        _vikeConfigPublicGlobal: {
+            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/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-                route: import("../../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
+            [k: string]: import("../../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
     } & ({
         _isProduction: false;
@@ -67,7 +66,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
         _isProduction: true;
-        assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
         viteConfigRuntime: {
             root: string;
@@ -89,7 +88,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _isPrerendering: false;
         viteConfig: null;
         _isProduction: true;
-        assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
         viteConfigRuntime: {
             root: string;
@@ -108,20 +107,19 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
         _pageRoutes: import("../../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
     });
+    _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
     _baseServer: string;
     _baseAssets: string;
-    _includeAssetsImportedByServer: boolean;
-    _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
-    _pageConfigs: import("../../../__internal/index.js").PageConfig[];
-    _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-    _allPageIds: string[];
-    _pageRoutes: import("../../../__internal/index.js").PageRoutes;
-    _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
     _pageContextInit: PageContextInit;
     _urlRewrite: null;
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
-} & import("../../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & {
+} & {
+    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;
+} & {
     urlParsed: import("../utils.js").UrlPublic;
     urlPathname: string;
     url: string;
@@ -134,7 +132,7 @@ declare function createPageContextServerSideWithoutGlobalContext(pageContextInit
 } & {
     isClientSide: false;
     isPrerendering: boolean;
-} & Pick<import("../../../shared/types.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     url?: string;
     headers?: Record<string, string>;
 };

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

@@ -5,30 +5,22 @@ import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComp
 import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
 async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
     urlHandler: null,
-    isClientSideNavigation: false
-} }) {
+    isClientSideNavigation: false,
+}, }) {
     assert(pageContextInit.urlOriginal);
     const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
     objectAssign(pageContextCreated, {
         _globalContext: globalContext,
-        // The following is defined on `pageContext` because we can eventually make these non-global
+        _pageFilesAll: globalContext._pageFilesAll, // TODO/v1-release: remove
+        // We use pageContext._baseServer and pageContext._baseAssets instead of pageContext._globalContext.baseServer and pageContext._globalContext.baseAssets because the Base URLs can (eventually one day if needed) be made non-global
         _baseServer: globalContext.baseServer,
         _baseAssets: globalContext.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,
         _pageContextInit: pageContextInit,
         _urlRewrite: null,
         _urlHandler: urlHandler,
-        isClientSideNavigation
+        isClientSideNavigation,
     });
-    objectAssign(pageContextCreated, globalContext._userFriendlyConfigsGlobal);
+    objectAssign(pageContextCreated, globalContext._vikeConfigPublicGlobal);
     // pageContext.urlParsed
     const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
     objectAssign(pageContextCreated, pageContextUrlComputed);
@@ -49,7 +41,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, { isP
         }
         objectAssign(pageContextCreated, { headers });
     }
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._userFriendlyConfigsGlobal);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }
@@ -61,7 +53,7 @@ function createPageContext(pageContextInit, isPrerendering) {
     const pageContext = createPageContextObject();
     objectAssign(pageContext, {
         isClientSide: false,
-        isPrerendering
+        isPrerendering,
     });
     objectAssign(pageContext, pageContextInit);
     return pageContext;