vike 0.4.193 → 0.4.195

package/dist/esm/node/runtime/globalContext/loadImportBuild.js

@@ -1,6 +1,6 @@
 export { loadImportBuild };
 export { setImportBuildGetters };
-import { importServerEntry } from '@brillout/vite-plugin-server-entry/importServerEntry.js';
+import { importServerEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { assert } from '../utils.js';
 const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
     getters: null

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.d.ts

@@ -22,7 +22,7 @@ type InjectFilterEntry = {
     isEntry: boolean;
     inject: PreloadFilterInject;
 };
-type Position = 'HTML_BEGIN' | 'HTML_END' | 'STREAM';
+type Position = 'HTML_BEGIN' | 'HTML_END' | 'HTML_STREAM';
 type HtmlTag = {
     htmlTag: string | (() => string);
     position: Position;

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -20,7 +20,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
         if (asset.isEntry && asset.assetType === 'script') {
             // We could allow the user to change the position of <script> but we currently don't:
             //  - Because of mergeScriptEntries()
-            //  - We would need to add STREAM to to PreloadFilterInject
+            //  - We would need to add HTML_STREAM to to PreloadFilterInject
             // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
             return false;
         }
@@ -77,31 +77,36 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
     // ==========
     // JavaScript
     // ==========
-    // - The pageContext JSON should be fully sent before Vike's client runtime starts executing.
+    // - By default, we place the entry <script> towards the end of the HTML for better performance.
+    //   - Performance-wise, it's more interesting to start showing the page (parse HTML and load CSS) before starting loading scripts.
+    //   - But with HTML streaming, in order to support [Progressive Rendering](https://vike.dev/streaming#progressive-rendering), the entry <script> should be injected earlier instead.
+    // - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
+    // - `<script id="vike_pageContext" type="application/json">` (the `pageContext` JSON) should be fully sent before Vike's client runtime starts executing.
     //   - Otherwise, race condition "SyntaxError: Unterminated string in JSON": https://github.com/vikejs/vike/issues/567
-    //   - <script id="vike_pageContext" type="application/json"> must appear before the entry <script> (which loads Vike's client runtime).
-    //   - <script id="vike_pageContext" type="application/json"> can't be async nor defer.
-    // - The entry <script> can't be defer, otherwise progressive hydration while SSR streaming won't work.
-    // - The entry <script> should be towards the end of the HTML as performance-wise it's more interesting to parse <div id="page-view"> before running the entry <script> which initiates the hydration.
-    //   - But with HTML streaming, in order to support [Progressive Rendering](https://vike.dev/streaming#progressive-rendering), the entry <script> should be injected early instead.
+    //   - `<script id="vike_pageContext" type="application/json">` must appear before the entry <script> (which loads Vike's client runtime).
+    //   - `<script id="vike_pageContext" type="application/json">` can't be async nor defer.
+    const positionJavaScriptDefault = 'HTML_END';
     const positionJavaScriptEntry = (() => {
         if (injectScriptsAt !== null) {
             if (pageContext._pageContextPromise) {
                 assertWarning(injectScriptsAt === 'HTML_END' || !isStream, `You're setting injectScriptsAt to ${pc.code(JSON.stringify(injectScriptsAt))} while using HTML streaming with a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) which is contradictory: the pageContext promise is skipped.`, { onlyOnce: true });
             }
+            if (injectScriptsAt === 'HTML_STREAM' && !isStream) {
+                return positionJavaScriptDefault;
+            }
             return injectScriptsAt;
         }
         if (pageContext._pageContextPromise) {
             // - If there is a pageContext._pageContextPromise then <script id="vike_pageContext" type="application/json"> needs to await for it.
             // - pageContext._pageContextPromise is typically resolved only after the page's components are rendered and the stream ended.
             // - https://vike.dev/streaming#initial-data-after-stream-end
-            return 'HTML_END';
+            return positionJavaScriptDefault;
         }
         if (streamFromReactStreamingPackage && !streamFromReactStreamingPackage.hasStreamEnded()) {
             // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary.
-            return 'STREAM';
+            return 'HTML_STREAM';
         }
-        return 'HTML_END';
+        return positionJavaScriptDefault;
     })();
     if (pageContext._pageContextPromise && streamFromReactStreamingPackage) {
         // - Should we show this warning for Solid as well? Solid seems to also support progressive rendering.
@@ -135,7 +140,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
         const htmlTag = inferPreloadTag(asset);
         if (!asset.inject)
             return;
-        // Ideally, instead of this conditional ternary operator, we should add STREAM to PreloadFilterInject (or a better fitting name such as HTML_STREAM)
+        // Ideally, instead of this conditional ternary operator, we should add HTML_STREAM to PreloadFilterInject
         const position = asset.inject === 'HTML_END' ? positionJavaScriptEntry : asset.inject;
         htmlTags.push({ htmlTag, position });
     });
@@ -217,6 +222,6 @@ function getInjectScriptsAt(pageId, pageConfigs) {
     assertUsage(injectScriptsAt === null ||
         injectScriptsAt === 'HTML_BEGIN' ||
         injectScriptsAt === 'HTML_END' ||
-        injectScriptsAt === 'STREAM', `${configDefinedAt} has an invalid value`);
+        injectScriptsAt === 'HTML_STREAM', `${configDefinedAt} has an invalid value`);
     return injectScriptsAt;
 }

package/dist/esm/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -16,7 +16,7 @@ function injectHtmlTags(htmlString, htmlTags, position) {
 }
 // Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
 function injectHtmlTagsUsingStream(htmlTags, streamFromReactStreamingPackage) {
-    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'STREAM'));
+    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'HTML_STREAM'));
     if (htmlFragment) {
         assert(!streamFromReactStreamingPackage.hasStreamEnded());
         streamFromReactStreamingPackage.injectToStream(htmlFragment, { flush: true });

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

@@ -12,7 +12,7 @@ async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
-    assert(htmlTags.filter((snippet) => snippet.position === 'STREAM').length === 0);
+    assert(htmlTags.filter((snippet) => snippet.position === 'HTML_STREAM').length === 0);
     return htmlString;
 }
 function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, injectFilter) {
@@ -39,7 +39,7 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
         if (streamFromReactStreamingPackage)
             return null;
         assert(htmlTags);
-        const tags = htmlTags.filter((h) => h.position === 'STREAM');
+        const tags = htmlTags.filter((h) => h.position === 'HTML_STREAM');
         if (tags.length === 0)
             return null;
         const htmlFragment = joinHtmlTags(tags);

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

@@ -2,14 +2,14 @@ export { assertArguments };
 import { assert, assertUsage, assertWarning, hasProp, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 function assertArguments(...args) {
-    const prefix = `[renderPage(${pc.cyan('pageContextInit')})]`;
+    const prefix = `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage)`;
     const pageContextInit = args[0];
     assertUsage(pageContextInit !== undefined && pageContextInit !== null, prefix + ` argument ${pc.cyan('pageContextInit')} is missing`, { showStackTrace: true });
     const len = args.length;
-    assertUsage(len === 1, `${prefix} You passed ${len} arguments but renderPage() accepts only one argument.'`, {
+    assertUsage(len === 1, `${prefix} called with ${len} arguments but renderPage() accepts only one argument.'`, {
         showStackTrace: true
     });
-    assertUsage(isObject(pageContextInit), `${prefix} ${pc.cyan('pageContextInit')} should be an object, but ${pc.cyan(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)}`, { 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
     if ('url' in pageContextInit) {
         assertWarning(false, '`pageContextInit.url` has been renamed to `pageContextInit.urlOriginal`: replace `renderPage({ url })` with `renderPage({ urlOriginal })`. (See https://vike.dev/migration/0.4.23 for more information.)', { showStackTrace: true, onlyOnce: true });

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

@@ -1,6 +1,8 @@
-export { createHttpResponseObject };
+export { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
-export { createHttpResponseObjectRedirect };
+export { createHttpResponseError };
+export { createHttpResponseRedirect };
+export { createHttpResponseFavicon404 };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
@@ -16,13 +18,15 @@ type HttpResponse = {
     /** **Deprecated**: use `headers` instead, see https://vike.dev/migration/0.4.134 */
     contentType: 'application/json' | 'text/html;charset=utf-8';
 } & HttpResponseBody;
-declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderHook: null | RenderHook, pageContext: {
+declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
     _pageId: null | string;
     is404: null | boolean;
     errorWhileRendering: null | Error;
     __getPageAssets: GetPageAssets;
     _pageConfigs: PageConfigRuntime[];
     abortStatusCode?: AbortStatusCode;
-}): Promise<HttpResponse | null>;
+}): Promise<HttpResponse>;
+declare function createHttpResponseFavicon404(): HttpResponse;
+declare function createHttpResponseError(): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;

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

@@ -1,16 +1,15 @@
-export { createHttpResponseObject };
+export { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
-export { createHttpResponseObjectRedirect };
+export { createHttpResponseError };
+export { createHttpResponseRedirect };
+export { createHttpResponseFavicon404 };
 import { assert, assertWarning } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
 import { getEarlyHints } from './getEarlyHints.js';
-import { getCacheControl } from './createHttpResponseObject/getCacheControl.js';
-import { assertNoInfiniteHttpRedirect } from './createHttpResponseObject/assertNoInfiniteHttpRedirect.js';
-async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
-    if (htmlRender === null) {
-        return null;
-    }
+import { getCacheControl } from './createHttpResponse/getCacheControl.js';
+import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
+async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
         const isError = !pageContext._pageId || isErrorPage(pageContext._pageId, pageContext._pageConfigs);
@@ -33,13 +32,21 @@ async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
     if (cacheControl) {
         headers.push(['Cache-Control', cacheControl]);
     }
-    return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+}
+function createHttpResponseFavicon404() {
+    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], "<p>No favicon.ico found.</p><script>console.log('This HTTP response was generated by Vike.')</script>");
+    return httpResponse;
+}
+function createHttpResponseError() {
+    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], "<p>An error occurred.</p><script>console.log('This HTTP response was generated by Vike. This response is used instead of rendering the error page (https://vike.dev/error-page), either because there isn't error page or because an error occurred while rendering the error page.')</script>");
+    return httpResponse;
 }
 async function createHttpResponsePageContextJson(pageContextSerialized) {
-    const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
-function createHttpResponseObjectRedirect({ url, statusCode }, 
+function createHttpResponseRedirect({ url, statusCode }, 
 // The URL we assume the redirect to be logically based on
 urlLogical) {
     assertNoInfiniteHttpRedirect(url, urlLogical);
@@ -47,12 +54,12 @@ urlLogical) {
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);
     const headers = [['Location', url]];
-    return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
+    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 ${url}</p>`);
+    `<p style="display: none">Redirecting to ${url}</p><script>console.log('This HTTP response was generated by Vike.')</script>`);
 }
-function getHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
+function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
     headers.push(['Content-Type', contentType]);
     assert(renderHook || typeof htmlRender === 'string');
     return {

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

@@ -21,5 +21,5 @@ declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumpt
     _httpRequestId: number | null;
 }): Promise<{
     renderHook: RenderHook;
-    htmlRender: null | HtmlRender;
+    htmlRender: HtmlRender;
 }>;

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

@@ -17,9 +17,6 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
-    if (documentHtml === null || documentHtml === undefined) {
-        return { htmlRender: null, renderHook };
-    }
     const onErrorWhileStreaming = (err) => {
         // Should the stream inject the following?
         // ```
@@ -75,7 +72,7 @@ function getRenderHook(pageContext) {
     return hookFound;
 }
 function processHookReturnValue(hookReturnValue, renderHook) {
-    let documentHtml = null;
+    let documentHtml;
     let pageContextPromise = null;
     let pageContextProvidedByRenderHook = null;
     let injectFilter = null;
@@ -102,7 +99,8 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         assertUsage(isCallable(hookReturnValue.injectFilter), 'injectFilter should be a function');
         injectFilter = hookReturnValue.injectFilter;
     }
-    if (hookReturnValue.documentHtml) {
+    assertUsage(hookReturnValue.documentHtml, `${errPrefix} returned an object that is missing the ${pc.code('documentHtml')} property.`);
+    {
         let val = hookReturnValue.documentHtml;
         const errBegin = `${errPrefix} returned ${pc.cyan('{ documentHtml }')}, but ${pc.cyan('documentHtml')}`;
         if (typeof val === 'string') {

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

@@ -2,7 +2,7 @@ export { handleErrorWithoutErrorPage };
 import { stringify } from '@brillout/json-serializer/stringify';
 import { getGlobalContext } from '../globalContext.js';
 import { assert, assertWarning, objectAssign } from '../utils.js';
-import { createHttpResponseObject } from './createHttpResponseObject.js';
+import { createHttpResponsePage, createHttpResponseError } from './createHttpResponse.js';
 import pc from '@brillout/picocolors';
 // When the user hasn't defined _error.page.js
 async function handleErrorWithoutErrorPage(pageContext) {
@@ -13,13 +13,14 @@ async function handleErrorWithoutErrorPage(pageContext) {
         warnMissingErrorPage(isV1);
     }
     if (!pageContext.isClientSideNavigation) {
-        objectAssign(pageContext, { httpResponse: null });
+        const httpResponse = createHttpResponseError();
+        objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponseObject(stringify({ serverSideError: true }), null, pageContext);
+        const httpResponse = await createHttpResponsePage(stringify({ serverSideError: true }), null, pageContext);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

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

@@ -2,6 +2,6 @@ export { inferMediaType };
 export type { MediaType };
 type MediaType = null | {
     assetType: 'image' | 'script' | 'font' | 'style' | 'audio' | 'video' | 'document' | 'fetch' | 'track' | 'worker' | 'embed' | 'object';
-    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
+    mediaType: 'text/javascript' | 'text/css' | 'image/avif' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
 };
 declare function inferMediaType(href: string): MediaType;

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

@@ -24,6 +24,9 @@ function inferMediaType(href) {
     if (href.endsWith('.svg')) {
         return { assetType: 'image', mediaType: 'image/svg+xml' };
     }
+    if (href.endsWith('.avif')) {
+        return { assetType: 'image', mediaType: 'image/avif' };
+    }
     // Fonts
     if (href.endsWith('.ttf')) {
         return { assetType: 'font', mediaType: 'font/ttf' };

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

@@ -1,2 +1,6 @@
-export declare let isConfigInvalid: boolean;
-export declare const isConfigInvalid_set: (val: boolean) => void;
+export { isConfigInvalid };
+export { isConfigInvalid_set };
+declare let isConfigInvalid: false | {
+    err: unknown;
+};
+declare const isConfigInvalid_set: (val: typeof isConfigInvalid) => void;

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

@@ -1,4 +1,8 @@
-export let isConfigInvalid = false;
-export const isConfigInvalid_set = (val) => {
+export { isConfigInvalid };
+export { isConfigInvalid_set };
+import { assert } from '../utils.js';
+let isConfigInvalid;
+const isConfigInvalid_set = (val) => {
+    assert(val === false || val.err);
     isConfigInvalid = val;
 };

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

@@ -8,13 +8,13 @@ export type { PageContextAfterRender };
 export type { PageContextInitEnhanced };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
-import { HttpResponse } from './createHttpResponseObject.js';
+import { HttpResponse } from './createHttpResponse.js';
 import { PageContext_loadUserFilesServerSide, type PageFiles } from './loadUserFilesServerSide.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import type { Hook } from '../../../shared/hooks/getHook.js';
 type PageContextAfterRender = {
-    httpResponse: null | HttpResponse;
+    httpResponse: HttpResponse;
     errorWhileRendering: null | Error;
 };
 declare function renderPageAlreadyRouted<PageContext extends {

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

@@ -10,7 +10,7 @@ import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAs
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { getGlobalContext } from '../globalContext.js';
-import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
+import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
 import { loadUserFilesServerSide } from './loadUserFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
 import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
@@ -56,16 +56,10 @@ async function renderPageAlreadyRouted(pageContext) {
         return pageContext;
     }
     const renderHookResult = await executeOnRenderHtmlHook(pageContext);
-    if (renderHookResult.htmlRender === null) {
-        objectAssign(pageContext, { httpResponse: null });
-        return pageContext;
-    }
-    else {
-        const { htmlRender, renderHook } = renderHookResult;
-        const httpResponse = await createHttpResponseObject(htmlRender, renderHook, pageContext);
-        objectAssign(pageContext, { httpResponse });
-        return pageContext;
-    }
+    const { htmlRender, renderHook } = renderHookResult;
+    const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
 async function prerenderPage(pageContext) {
     objectAssign(pageContext, {

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

@@ -1,6 +1,6 @@
 export { renderPage };
 export { renderPage_addWrapper };
-import { HttpResponse } from './renderPage/createHttpResponseObject.js';
+import { HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
 declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
     pageContextReturn: Awaited<PageContext>;
@@ -12,5 +12,5 @@ declare function renderPage<PageContextUserAdded extends {}, PageContextInit ext
     /** The URL of the HTTP request */
     urlOriginal: string;
 }>(pageContextInit: PageContextInit): Promise<PageContextInit & {
-    httpResponse: HttpResponse | null;
+    httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;