vike 0.4.249 → 0.4.250-commit-193dea3

package/dist/server/runtime/renderPageServer/createHttpResponse.d.ts

@@ -1,7 +1,8 @@
 export { createHttpResponsePage };
-export { createHttpResponsePageContextJson };
+export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseErrorFallbackJson };
 export { createHttpResponseRedirect };
 export { createHttpResponse404 };
 export { createHttpResponseBaseIsMissing };
@@ -36,5 +37,6 @@ declare function createHttpResponseErrorFallback(pageContext: {
     _globalContext: GlobalContextServerInternal;
 }): HttpResponse;
 declare function createHttpResponseErrorFallback_noGlobalContext(): HttpResponse;
-declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
+declare function createHttpResponseErrorFallbackJson(): HttpResponse;
+declare function createHttpResponsePageJson(pageContextSerialized: string): Promise<HttpResponse>;
 declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;

package/dist/server/runtime/renderPageServer/createHttpResponse.js

@@ -1,7 +1,8 @@
 export { createHttpResponsePage };
-export { createHttpResponsePageContextJson };
+export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseErrorFallbackJson };
 export { createHttpResponseRedirect };
 export { createHttpResponse404 };
 export { createHttpResponseBaseIsMissing };
@@ -11,6 +12,9 @@ import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHtt
 import { getEarlyHints } from './getEarlyHints.js';
 import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
 import { resolveHeadersResponseFinal } from './headersResponse.js';
+import { stringify } from '@brillout/json-serializer/stringify';
+const contentTypeJson = 'application/json';
+const contentTypeHtml = 'text/html;charset=utf-8';
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
@@ -29,17 +33,17 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
     const headers = resolveHeadersResponseFinal(pageContext, statusCode);
-    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+    return createHttpResponse(statusCode, contentTypeHtml, headers, htmlRender, earlyHints, renderHook);
 }
 function createHttpResponse404(errMsg404) {
-    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
+    const httpResponse = createHttpResponse(404, contentTypeHtml, [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
     return httpResponse;
 }
 function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
     const httpResponse = createHttpResponse(
     // We use the error code `500` to signal a failing state because this HTTP response should never be used, see https://vike.dev/base-url#setup
     // In other words: this HTTP response is expected to be generated but isn't expected to be actually used.
-    500, 'text/html;charset=utf-8', [], `
+    500, contentTypeHtml, [], `
 <h1>Error: Base URL is missing</h1>
 <p>
   <a href="https://vike.dev/renderPage"><code>renderPage(pageContextInit)</code></a> called with <code>pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}</code> which doesn't start with the Base URL <code>${baseServer}</code>.
@@ -74,11 +78,15 @@ function createHttpResponseErrorFallback_noGlobalContext() {
     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 HTML was generated by Vike. Vike returned this HTML because ${reason}.`)})</script>`);
+    const httpResponse = createHttpResponse(500, contentTypeHtml, [], `<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) {
-    const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+function createHttpResponseErrorFallbackJson() {
+    const httpResponse = createHttpResponse(500, contentTypeJson, [], stringify({ serverSideError: true }));
+    return httpResponse;
+}
+async function createHttpResponsePageJson(pageContextSerialized) {
+    const httpResponse = createHttpResponse(200, contentTypeJson, [], pageContextSerialized, [], null);
     return httpResponse;
 }
 function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
@@ -87,7 +95,7 @@ function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);
     const headers = [['Location', url]];
-    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
+    return createHttpResponse(statusCode, contentTypeHtml, 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 HTML was generated by Vike.')</script>`);

package/dist/server/runtime/renderPageServer/createPageContextServerSide.d.ts

@@ -1,9 +1,11 @@
 export { createPageContextServerSide };
 export { createPageContextServerSideWithoutGlobalContext };
-export type { PageContextCreated };
+export type { PageContextCreatedServer };
+export type { PageContextCreatedServerMinimum };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPageServer.js';
-type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
+type PageContextCreatedServerMinimum = ReturnType<typeof createPageContextServerSideWithoutGlobalContext>;
+type PageContextCreatedServer = Awaited<ReturnType<typeof createPageContextServerSide>>;
 declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
     requestId: number;
 } & ({
@@ -146,6 +148,7 @@ declare function createPageContextServerSide(pageContextInit: PageContextInit, g
 } & {
     headers: Record<string, string> | null;
 };
+/** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
 declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit, requestId: number): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/server/runtime/renderPageServer/createPageContextServerSide.js

@@ -41,6 +41,7 @@ function createPageContextServerSide(pageContextInit, globalContext, args) {
     updateType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }
+/** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
 function createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId) {
     const pageContext = createPageContext(pageContextInit, false, requestId);
     return pageContext;

package/dist/server/runtime/renderPageServer/csp.js

@@ -32,6 +32,7 @@ async function generateNonce() {
     return cryptoModule.randomBytes(16).toString('base64url');
 }
 function inferNonceAttr(pageContext) {
+    // No need to escape the injected HTML — pageContext.cspNone is controlled by the developer, not by the website visitor (I wouldn't know why the developer would set +csp.none to a value coming from the database)
     const nonceAttr = pageContext.cspNonce ? ` nonce="${pageContext.cspNonce}"` : '';
     return nonceAttr;
 }
@@ -41,5 +42,6 @@ function addCspResponseHeader(pageContext, headersResponse) {
         return;
     if (headersResponse.get('Content-Security-Policy'))
         return;
+    // No need to sanitize the injected header — see comment above about not escaping HTML
     headersResponse.set('Content-Security-Policy', `script-src 'self' 'nonce-${pageContext.cspNonce}'`);
 }

package/dist/server/runtime/renderPageServer/execHookOnError.d.ts

@@ -1,3 +1,3 @@
 export { execHookOnError };
-import type { PageContext_logRuntime } from '../loggerRuntime.js';
-declare function execHookOnError(err: unknown, pageContext: PageContext_logRuntime): void;
+import type { PageContextCreatedServerMinimum } from './createPageContextServerSide.js';
+declare function execHookOnError(err: unknown, pageContext: PageContextCreatedServerMinimum | null): void;

package/dist/server/runtime/renderPageServer/handleErrorWithoutErrorPage.d.ts

@@ -1,12 +1,12 @@
 export { handleErrorWithoutErrorPage };
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
-declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreated & {
+import type { PageContextCreatedServer } from './createPageContextServerSide.js';
+declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreatedServer & {
     errorWhileRendering: null | Error;
     is404: null | boolean;
     pageId: null;
     _globalContext: GlobalContextServerInternal;
     urlOriginal: string;
-}>(pageContext: PageContext): Promise<PageContext & {
+}>(pageContext: PageContext): PageContext & {
     httpResponse: import("./createHttpResponse.js").HttpResponse;
-}>;
+};

package/dist/server/runtime/renderPageServer/handleErrorWithoutErrorPage.js

@@ -1,10 +1,9 @@
 export { handleErrorWithoutErrorPage };
-import { stringify } from '@brillout/json-serializer/stringify';
 import { assert, assertWarning, objectAssign } from '../../utils.js';
-import { createHttpResponsePage, createHttpResponseErrorFallback } from './createHttpResponse.js';
+import { createHttpResponseErrorFallback, createHttpResponseErrorFallbackJson } from './createHttpResponse.js';
 import pc from '@brillout/picocolors';
 // When the user hasn't defined _error.page.js
-async function handleErrorWithoutErrorPage(pageContext) {
+function handleErrorWithoutErrorPage(pageContext) {
     assert(pageContext.pageId === null);
     assert(pageContext.errorWhileRendering || pageContext.is404);
     {
@@ -19,7 +18,7 @@ async function handleErrorWithoutErrorPage(pageContext) {
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponsePage(stringify({ serverSideError: true }), null, pageContext);
+        const httpResponse = createHttpResponseErrorFallbackJson();
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

package/dist/server/runtime/renderPageServer/html/serializeContext.d.ts

@@ -6,10 +6,10 @@ export type { PassToClient };
 export type { PassToClientPublic };
 import type { UrlRedirect } from '../../../../shared-server-client/route/abort.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
-import type { PageContextCreated } from '../createPageContextServerSide.js';
+import type { PageContextCreatedServer } from '../createPageContextServerSide.js';
 import type { PageContextBegin } from '../../renderPageServer.js';
 import type { PageContextCspNonce } from '../csp.js';
-type PageContextSerialization = PageContextCreated & {
+type PageContextSerialization = PageContextCreatedServer & {
     pageId: string;
     routeParams: Record<string, string>;
     _passToClient: PassToClient;

package/dist/server/runtime/renderPageServer/html/stream.js

@@ -242,7 +242,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         writeStream(injectedChunk); // Adds injectedChunk to buffer
         flushStream(); // Sets shouldFlushStream to true
     }
-    // We call onStreamEvent() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
+    // We call onStreamDataOrEnd() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
     const onStreamDataOrEnd = (cb) => {
         assert(streamOriginalEnded === false);
         streamOriginalHasStartedEmitting = true;
@@ -277,26 +277,23 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                 }
             });
         },
-        async onEnd(
-        /* Should we use this `isCancel`? Maybe we can skip `injectStringAtEnd()`?
-        isCancel,
-        //*/
-        ) {
+        async onEnd(isCancel) {
             try {
                 assert(!onEndWasCalled);
                 onEndWasCalled = true;
                 debug('stream end');
-                // We call onStreamEvent() also here in case the stream didn't emit any data
+                // We call onStreamDataOrEnd() also here in case the stream didn't emit any data
                 onStreamDataOrEnd(() => {
                     streamOriginalEnded = true;
                 });
-                if (injectStringAtEnd) {
+                if (injectStringAtEnd && !isCancel) {
                     const injectedChunk = await injectStringAtEnd();
                     writeStream(injectedChunk);
                 }
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 assert(isReady());
-                flushBuffer();
+                if (!isCancel)
+                    flushBuffer();
                 streamClosed = true;
                 debug('stream ended');
             }
@@ -526,7 +523,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 return;
             await onEnd(isCancel);
             isClosed = true;
-            controllerProxy.close();
+            if (!isCancel)
+                controllerProxy.close();
         };
         let controllerProxy;
         assertReadableStreamConstructor();
@@ -546,6 +544,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 });
             },
             async cancel(...args) {
+                debug('stream cancelled');
                 isCancel = true;
                 await readableOriginal.cancel(...args);
                 // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
@@ -553,9 +552,9 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             },
         });
         const writeChunk = (chunk) => {
-            if (
-            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
-            !isClosed) {
+            if (!isCancel &&
+                // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
+                !isClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
                 debugWithChunk('data written (Web Readable)', chunk);
             }

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.d.ts

@@ -8,8 +8,8 @@ import { type PageAsset } from './getPageAssets.js';
 import type { PageConfigRuntime } from '../../../types/PageConfig.js';
 import type { PassToClient } from './html/serializeContext.js';
 import type { PageContextAfterRoute } from '../../../shared-server-client/route/index.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
-type PageContext_loadPageConfigsLazyServerSide = PageContextCreated & PageContextAfterRoute & {
+import type { PageContextCreatedServer } from './createPageContextServerSide.js';
+type PageContext_loadPageConfigsLazyServerSide = PageContextCreatedServer & PageContextAfterRoute & {
     is404: boolean | null;
     pageId: string;
 };

package/dist/server/runtime/renderPageServer/log404/index.d.ts

@@ -2,8 +2,8 @@ export { log404 };
 export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared-server-client/route/index.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
-import type { PageContextCreated } from '../createPageContextServerSide.js';
-declare function log404(pageContext: PageContextCreated & {
+import type { PageContextCreatedServer } from '../createPageContextServerSide.js';
+declare function log404(pageContext: PageContextCreatedServer & {
     urlPathname: string;
     errorWhileRendering: null | Error;
     _globalContext: GlobalContextServerInternal;

package/dist/server/runtime/renderPageServer/renderPageServerAfterRoute.d.ts

@@ -5,7 +5,7 @@ export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared-server-client/getPageContextUrlComputed.js';
 import { HttpResponse } from './createHttpResponse.js';
 import { type PageContext_loadPageConfigsLazyServerSide, type PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
+import type { PageContextCreatedServer } from './createPageContextServerSide.js';
 import type { PageContextBegin } from '../renderPageServer.js';
 type PageContextAfterRender = {
     httpResponse: HttpResponse;
@@ -18,7 +18,7 @@ declare function renderPageServerAfterRoute<PageContext extends {
     routeParams: Record<string, string>;
     errorWhileRendering: null | Error;
     _requestId: number;
-} & PageContextCreated & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+} & PageContextCreatedServer & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry>[0]): Promise<{
     documentHtml: string;
     pageContextSerialized: null;
@@ -348,7 +348,7 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
         pageContextsAborted: never[];
     };
 }>;
-declare function prerenderPageEntry(pageContext: PageContextCreated & PageConfigsLazy & {
+declare function prerenderPageEntry(pageContext: PageContextCreatedServer & PageConfigsLazy & {
     routeParams: Record<string, string>;
     pageId: string;
     _requestId: number;

package/dist/server/runtime/renderPageServer/renderPageServerAfterRoute.js

@@ -5,7 +5,7 @@ import { getErrorPageId } from '../../../shared-server-client/error-page.js';
 import { getHtmlString } from './html/renderHtml.js';
 import { assert, assertUsage, updateType, hasProp, objectAssign, isSameErrorMessage } from '../../utils.js';
 import { getPageContextClientSerialized } from './html/serializeContext.js';
-import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
+import { createHttpResponsePage, createHttpResponsePageJson } from './createHttpResponse.js';
 import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
 import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
@@ -46,7 +46,7 @@ async function renderPageServerAfterRoute(pageContext) {
             objectAssign(pageContext, { [isServerSideError]: true });
         }
         const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
-        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

package/dist/server/runtime/renderPageServer.js

@@ -6,7 +6,7 @@ import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertW
 import { getPageContextAddendumAbort, isAbortError, logAbort, addNewPageContextAborted, } from '../../shared-server-client/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPageServer/handlePageContextRequestUrl.js';
-import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, } from './renderPageServer/createHttpResponse.js';
+import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageJson, createHttpResponseErrorFallback, createHttpResponseErrorFallback_noGlobalContext, createHttpResponseBaseIsMissing, } from './renderPageServer/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { assertArguments } from './renderPageServer/assertArguments.js';
 import { log404 } from './renderPageServer/log404/index.js';
@@ -40,7 +40,7 @@ async function renderPageServer(pageContextInit) {
     const pageContextFinish = !asyncLocalStorage ? await render() : await asyncLocalStorage.run(asyncStore, render);
     logHttpResponse(urlOriginalPretty, pageContextFinish);
     checkType(pageContextFinish);
-    assert(pageContextFinish.httpResponse);
+    assertPageContextFinish(pageContextFinish);
     return pageContextFinish;
 }
 async function renderPageServerEntryOnce(pageContextInit, requestId, asyncStore) {
@@ -63,8 +63,8 @@ async function renderPageServerEntryOnce(pageContextInit, requestId, asyncStore)
         //   ```
         // - initGlobalContext_renderPage() depends on +onCreateGlobalContext hooks
         assert(!isAbortError(err));
-        const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
-        logRuntimeError(err, pageContext_logRuntime);
+        const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+        logRuntimeError(err, pageContext);
         const pageContextHttpErrorFallback = getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, requestId);
         return pageContextHttpErrorFallback;
     }
@@ -131,7 +131,7 @@ async function renderPageServerEntryRecursive(pageContextBegin, globalContext, r
         const errorPageId = getErrorPageId(pageContextNominalPageBegin._globalContext._pageFilesAll, pageContextNominalPageBegin._globalContext._pageConfigs);
         if (!errorPageId) {
             assert(hasProp(pageContextNominalPageBegin, 'pageId', 'null')); // Help TS
-            return await handleErrorWithoutErrorPage(pageContextNominalPageBegin);
+            return handleErrorWithoutErrorPage(pageContextNominalPageBegin);
         }
         objectAssign(pageContextNominalPageBegin, { pageId: errorPageId });
     }
@@ -182,7 +182,7 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
         const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
         if (!errorPageId) {
             objectAssign(pageContextErrorPageInit, { pageId: null });
-            return await handleErrorWithoutErrorPage(pageContextErrorPageInit);
+            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
         }
         objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
     }
@@ -216,8 +216,8 @@ async function renderPageServerEntryRecursive_onError(err, pageContextBegin, pag
     return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, pageContextInit, requestId) {
-    const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
-    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext_logRuntime, 'info');
+    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext, 'info');
 }
 /* Alternative icons:
 const arrowRight = pc.dim('»')
@@ -430,7 +430,7 @@ pageContextNominalPageBegin, requestId, pageContextErrorPageInit, globalContext)
         else {
             pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort, false);
         }
-        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
         objectAssign(pageContext, { httpResponse });
         return { pageContextReturn: pageContext };
     }
@@ -486,19 +486,11 @@ function getPageContextSkipRequest(pageContextInit, requestId) {
     return pageContext;
 }
 function getPageContextInvalidVikeConfig(err, pageContextInit, requestId) {
-    const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
-    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), pageContext_logRuntime, 'error');
+    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId);
+    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), pageContext, 'error');
     const pageContextHttpErrorFallback = getPageContextHttpErrorFallback_noGlobalContext(err, pageContextInit, requestId);
     return pageContextHttpErrorFallback;
 }
-/** Use this as last resort — prefer passing richer `pageContext` objects to the runtime logger */
-function getPageContext_logRuntimeEarly(pageContextInit, requestId) {
-    const pageContext_logRuntime = {
-        ...pageContextInit,
-        _requestId: requestId,
-    };
-    return pageContext_logRuntime;
-}
 function fork(pageContext) {
     const pageContextNew = forkPageContext(pageContext);
     if (pageContext._asyncStore)
@@ -506,3 +498,11 @@ function fork(pageContext) {
     assert(pageContextNew._asyncStore === pageContext._asyncStore);
     return pageContextNew;
 }
+function assertPageContextFinish(pageContextFinish) {
+    assert(pageContextFinish.httpResponse);
+    if (pageContextFinish.isClientSideNavigation) {
+        const headers = new Headers(pageContextFinish.httpResponse.headers);
+        const contentType = headers.get('Content-Type');
+        assert(contentType?.toLowerCase() === 'application/json');
+    }
+}

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -18,7 +18,11 @@ import type { PageContextForPublicUsageServer } from '../../server/runtime/rende
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextExecHook = PageContextConfig & PageContextForPublicUsage;
+import type { PageContextCreatedClient } from '../../client/runtime-client-routing/createPageContextClientSide.js';
+import type { PageContextCreatedServer } from '../../server/runtime/renderPageServer/createPageContextServerSide.js';
+import type { PageContextCreatedClient_ServerRouting } from '../../client/runtime-server-routing/createPageContextClientSide.js';
+type PageContextExecHook = PageContextCreated & PageContextConfig & PageContextForPublicUsage;
+type PageContextCreated = PageContextCreatedServer | PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;

package/dist/types/Config/ConfigResolved.d.ts

@@ -1,8 +1,9 @@
 export type { ConfigResolved };
-import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
+import type { ConfigBuiltIn, ConfigBuiltInResolved } from '../Config.js';
+import type { ImportStringList } from '../../node/vite/shared/importString.js';
 type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
 type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
 type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
 type WithoutImportString<T> = {
-    [K in keyof T]: Exclude<T[K], ImportString>;
+    [K in keyof T]: Exclude<T[K], ImportStringList>;
 };