vike 0.4.267 → 0.4.268-commit-45c1759

package/dist/server/runtime/index.js

@@ -1,4 +1,4 @@
-export { renderPageServer as renderPage } from './renderPageServer.js';
+export { renderPageServer_userLand as renderPage } from './renderPageServer.js';
 export { escapeInject, dangerouslySkipEscape } from './renderPageServer/html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './renderPageServer/html/stream.js';
 export { PROJECT_VERSION as version } from '../../utils/PROJECT_VERSION.js';

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

@@ -18,14 +18,14 @@ function analyzePage(pageContext) {
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
-            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: true }),
+            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, environmentName: 'client' }),
             onlyAssets: isClientRuntimeLoaded ? false : true,
             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: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: false }),
+                id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, environmentName: 'server' }),
                 onlyAssets: true,
                 eagerlyImported: false,
             });
@@ -36,7 +36,7 @@ function analyzePage(pageContext) {
             const { env } = configElement
             assert(env)
             const onlyAssets = env === { server: true }
-            const eagerlyImported = env === { server: true, client: 'if-client-routing', eager: true }
+            const eagerlyImported = env === { server: true, client: true, clientRoutingOnly: true, eager: true }
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
                 id: configElement.importPath,

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

@@ -1,4 +1,5 @@
-export { createHttpResponsePage };
+export { createHttpResponsePageHtml };
+export { createHttpResponsePageContent };
 export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
@@ -6,12 +7,12 @@ export { createHttpResponseErrorFallbackJson };
 export { createHttpResponseRedirect };
 export { createHttpResponse404 };
 export { createHttpResponseBaseIsMissing };
-export { createHttpResponseFromUniversalMiddleware };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from './html/renderHtml.js';
-import type { RenderHook } from './execHookOnRenderHtml.js';
-import type { AbortStatusCode, UrlRedirect } from '../../../shared-server-client/route/abort.js';
+import type { StreamReadableWeb } from './html/stream.js';
+import type { Content, RenderHook } from './execHookOnRenderHtml.js';
+import type { AbortStatusCode, UrlRedirect, PageContextAborted } from '../../../shared-server-client/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';
 import type { PageContextBegin } from '../renderPageServer.js';
@@ -24,7 +25,7 @@ type HttpResponse = {
     /** **Deprecated**: use `headers` instead, see https://vike.dev/migration/0.4.134 */
     contentType: string | undefined;
 } & HttpResponseBody;
-declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
+type PageContextHttpResponsePage = {
     pageId: null | string;
     is404: null | boolean;
     errorWhileRendering: null | Error;
@@ -32,14 +33,24 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
     _globalContext: GlobalContextServerInternal;
     abortStatusCode?: AbortStatusCode;
     headersResponse?: Headers;
-}): Promise<HttpResponse>;
+    pageContextsAborted: PageContextAborted[];
+};
+declare function createHttpResponsePageHtml(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: PageContextHttpResponsePage): Promise<HttpResponse>;
+declare function createHttpResponsePageContent(content: Content, renderHook: RenderHook, pageContext: PageContextHttpResponsePage & {
+    urlOriginal: string;
+}): HttpResponse;
 declare function createHttpResponse404(errMsg404: string): HttpResponse;
 declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
 declare function createHttpResponseErrorFallback(pageContext: {
     _globalContext: GlobalContextServerInternal;
+    pageContextsAborted: PageContextAborted[];
 }): HttpResponse;
 declare function createHttpResponseErrorFallback_noGlobalContext(): HttpResponse;
-declare function createHttpResponseErrorFallbackJson(): HttpResponse;
-declare function createHttpResponsePageJson(pageContextSerialized: string): Promise<HttpResponse>;
+declare function createHttpResponseErrorFallbackJson(pageContext: {
+    pageContextsAborted: PageContextAborted[];
+}): HttpResponse;
+declare function createHttpResponsePageJson(pageContextJson: string | StreamReadableWeb, pageContext: {
+    headersResponse?: Headers;
+    pageContextsAborted: PageContextAborted[];
+}): Promise<HttpResponse>;
 declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;
-declare function createHttpResponseFromUniversalMiddleware(response: Response, earlyHints?: EarlyHint[]): HttpResponse;

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

@@ -1,4 +1,5 @@
-export { createHttpResponsePage };
+export { createHttpResponsePageHtml };
+export { createHttpResponsePageContent };
 export { createHttpResponsePageJson };
 export { createHttpResponseErrorFallback };
 export { createHttpResponseErrorFallback_noGlobalContext };
@@ -6,20 +7,34 @@ export { createHttpResponseErrorFallbackJson };
 export { createHttpResponseRedirect };
 export { createHttpResponse404 };
 export { createHttpResponseBaseIsMissing };
-export { createHttpResponseFromUniversalMiddleware };
 import { escapeHtml } from '../../../utils/escapeHtml.js';
 import { assert, assertWarning } from '../../../utils/assert.js';
 import { getErrorPageId, isErrorPage } from '../../../shared-server-client/error-page.js';
+import { getContentTypeFromUrl } from '../../../utils/getContentTypeFromUrl.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
 import { getEarlyHints } from './getEarlyHints.js';
 import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
-import { resolveHeadersResponseFinal } from './headersResponse.js';
+import { getHeadersSetCookieAborted, resolveHeadersResponseFinal, resolveHeadersResponseSetCookie, } from './headersResponse.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import '../../assertEnvServer.js';
 const contentTypeJson = 'application/json';
 const contentTypeHtml = 'text/html;charset=utf-8';
 const htmlFallbackLog = 'This HTML was generated by Vike.';
-async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
+async function createHttpResponsePageHtml(htmlRender, renderHook, pageContext) {
+    const statusCode = getStatusCode(pageContext);
+    const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
+    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
+    return createHttpResponse(statusCode, contentTypeHtml, headers, htmlRender, earlyHints, renderHook);
+}
+function createHttpResponsePageContent(content, renderHook, pageContext) {
+    const statusCode = getStatusCode(pageContext);
+    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
+    if (!headers.some(([k]) => k.toLowerCase() === 'content-type')) {
+        headers.push(['Content-Type', getContentTypeFromUrl(pageContext.urlOriginal) ?? 'application/octet-stream']);
+    }
+    return createHttpResponseCommon(statusCode, headers, content, [], renderHook);
+}
+function getStatusCode(pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
         const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs);
@@ -35,9 +50,7 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
             statusCode = pageContext.is404 ? 404 : 500;
         }
     }
-    const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
-    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
-    return createHttpResponse(statusCode, contentTypeHtml, headers, htmlRender, earlyHints, renderHook);
+    return statusCode;
 }
 function createHttpResponse404(errMsg404) {
     const httpResponse = createHttpResponse(404, contentTypeHtml, [], getHtmlFallback(`<p>${errMsg404}.</p>`));
@@ -76,21 +89,26 @@ function createHttpResponseErrorFallback(pageContext) {
             return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
         }
     })();
-    return createHttpResponseError_(reason);
+    // Cookies set before `throw redirect()` or `throw render()` are kept
+    return createHttpResponseError_(reason, getHeadersSetCookieAborted(pageContext));
 }
 function createHttpResponseErrorFallback_noGlobalContext() {
-    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered');
+    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered', []);
 }
-function createHttpResponseError_(reason) {
-    const httpResponse = createHttpResponse(500, contentTypeHtml, [], getHtmlFallback('<p>An error occurred.</p>', `${htmlFallbackLog} Vike returned this HTML because ${reason}.`));
+function createHttpResponseError_(reason, headers) {
+    const httpResponse = createHttpResponse(500, contentTypeHtml, headers, getHtmlFallback('<p>An error occurred.</p>', `${htmlFallbackLog} Vike returned this HTML because ${reason}.`));
     return httpResponse;
 }
-function createHttpResponseErrorFallbackJson() {
-    const httpResponse = createHttpResponse(500, contentTypeJson, [], stringify({ serverSideError: true }));
+function createHttpResponseErrorFallbackJson(pageContext) {
+    const headers = getHeadersSetCookieAborted(pageContext);
+    const httpResponse = createHttpResponse(500, contentTypeJson, headers, stringify({ serverSideError: true }));
     return httpResponse;
 }
-async function createHttpResponsePageJson(pageContextSerialized) {
-    const httpResponse = createHttpResponse(200, contentTypeJson, [], pageContextSerialized, [], null);
+async function createHttpResponsePageJson(pageContextJson, pageContext) {
+    const headers = resolveHeadersResponseSetCookie(pageContext);
+    headers.push(['Content-Type', contentTypeJson]);
+    // A stream if there are streamed pageContext values, see https://vike.dev/passToClient#streaming
+    const httpResponse = createHttpResponseCommon(200, headers, pageContextJson);
     return httpResponse;
 }
 function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
@@ -98,17 +116,12 @@ function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);
-    const headers = [['Location', url]];
+    const headers = [['Location', url], ...resolveHeadersResponseSetCookie(pageContextInit)];
     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.
     getHtmlFallback(`<p style="display: none">Redirecting to ${escapeHtml(url)}</p>`));
 }
-function createHttpResponseFromUniversalMiddleware(response, earlyHints) {
-    const body = response.body ?? getHtmlFallback('<p style="display: none">No HTTP response body.</p>');
-    const httpResponse = createHttpResponseCommon(response.status, Array.from(response.headers.entries()), body, earlyHints);
-    return httpResponse;
-}
 function getHtmlFallback(bodyHtml, logText = htmlFallbackLog) {
     return `${bodyHtml}<script>console.log(${JSON.stringify(logText)})</script>`;
 }

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

@@ -3,10 +3,10 @@ export { createPageContextServerWithoutGlobalContext };
 export type { PageContextCreatedServer };
 export type { PageContextCreatedServerWithoutGlobalContext };
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextInit, PageContextInitInternal } from '../renderPageServer.js';
+import type { PageContextInit } from '../renderPageServer.js';
 import '../../assertEnvServer.js';
 type PageContextCreatedServer = Awaited<ReturnType<typeof createPageContextServer>>;
-declare function createPageContextServer(pageContextInit: PageContextInitInternal & {
+declare function createPageContextServer(pageContextInit: PageContextInit & {
     headers?: Record<string, unknown>;
 }, globalContext: GlobalContextServerInternal, args: {
     requestId: number;
@@ -24,12 +24,6 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
     isPrerendering: boolean;
     _requestId: number;
 } & PageContextInit & {
-    _nodeDev?: {
-        req: import("http").IncomingMessage;
-        res: import("http").ServerResponse;
-    };
-    _reqWeb?: Request;
-} & {
     _globalContext: ({
         config: import("../../../types/index.js").ConfigResolved;
         _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
@@ -53,6 +47,10 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
         _pageFilesAll: import("../../__internal/index.js").PageFile[];
         _pageConfigs: import("../../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;
@@ -62,6 +60,7 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer | undefined;
+        devMiddleware: import("vite").Connect.Server | null;
         viteConfig: import("vite").ResolvedConfig | undefined;
     } | {
         isClientSide: false;
@@ -70,6 +69,7 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
         _isProduction: true;
         assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -80,12 +80,11 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
         _isProduction: true;
         assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: false;
         viteConfig: null;
     }) & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -96,6 +95,9 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        middlewares: import("../universal-middleware/core.js").Middleware[];
     })) & {
         prerenderContext: import("../../../types/index.js").PrerenderContext | undefined;
     };
@@ -103,12 +105,6 @@ declare function createPageContextServer(pageContextInit: PageContextInitInterna
     _baseServer: string;
     _baseAssets: string;
     _pageContextInit: PageContextInit & {
-        _nodeDev?: {
-            req: import("http").IncomingMessage;
-            res: import("http").ServerResponse;
-        };
-        _reqWeb?: Request;
-    } & {
         headers?: Record<string, unknown>;
     };
     _urlHandler: ((url: string) => string) | null;
@@ -137,10 +133,4 @@ declare function createPageContextServerWithoutGlobalContext(pageContextInit: Pa
     isClientSide: false;
     isPrerendering: boolean;
     _requestId: number;
-} & PageContextInit & {
-    _nodeDev?: {
-        req: import("http").IncomingMessage;
-        res: import("http").ServerResponse;
-    };
-    _reqWeb?: Request;
-};
+} & PageContextInit;

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

@@ -3,9 +3,10 @@ export { inferNonceAttr };
 export { addCspResponseHeader };
 export type { PageContextCspNonce };
 import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { PageContextPublicMinimum } from '../../../shared-server-client/getPageContextPublicShared.js';
 import type { PageContextServer } from '../../../types/PageContext.js';
 import '../../assertEnvServer.js';
-declare function resolvePageContextCspNone(pageContext: PageContextConfig & Partial<PageContextCspNonce>): Promise<null | {
+declare function resolvePageContextCspNone(pageContext: PageContextConfig & PageContextPublicMinimum & Partial<PageContextCspNonce>): Promise<null | {
     cspNonce: string | null;
 }>;
 type PageContextCspNonce = Pick<PageContextServer, 'cspNonce'>;

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

@@ -3,6 +3,7 @@ export { inferNonceAttr };
 export { addCspResponseHeader };
 import { import_ } from '@brillout/import';
 import { assert } from '../../../utils/assert.js';
+import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import '../../assertEnvServer.js';
 async function resolvePageContextCspNone(pageContext) {
     if (pageContext.cspNonce)
@@ -14,7 +15,7 @@ async function resolvePageContextCspNone(pageContext) {
             pageContextAddendum.cspNonce = await generateNonce();
         }
         else {
-            pageContextAddendum.cspNonce = await csp.nonce(pageContext);
+            pageContextAddendum.cspNonce = await csp.nonce(getPageContextPublicServer(pageContext));
         }
     }
     return pageContextAddendum;

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

@@ -23,7 +23,7 @@ function execHookOnError(err, pageContext) {
     const hooks = getHooksFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
     for (const hook of hooks) {
         try {
-            execHookSingleSync(hook, globalContext, pageContext, getPageContextPublicServer, () => hook.hookFn(err, pageContext));
+            execHookSingleSync(hook, globalContext, pageContext, getPageContextPublicServer, (pageContextPublic) => hook.hookFn(err, pageContextPublic));
         }
         catch (hookErr) {
             console.error(hookErr);

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

@@ -1,14 +1,17 @@
 export { execHookOnRenderHtml };
 export type { RenderHook };
+export type { Content };
 import { type HtmlRender } from './html/renderHtml.js';
 import { type HookInternal } from '../../../shared-server-client/hooks/getHook.js';
 import type { PageAsset } from './getPageAssets.js';
+import { type StreamReadableWeb } from './html/stream.js';
 import type { PageContextSerialization } from './html/serializeContext.js';
 import { type PageContextExecHook } from '../../../shared-server-client/hooks/execHook.js';
 import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
 import type { PageContextInternalServer } from '../../../types/PageContext.js';
 import '../../assertEnvServer.js';
 type GetPageAssets = () => Promise<PageAsset[]>;
+type Content = string | Uint8Array | StreamReadableWeb;
 type RenderHook = HookInternal & {
     hookName: HookName;
 };
@@ -19,7 +22,13 @@ declare function execHookOnRenderHtml(pageContext: PageContextConfig & PageConte
     _isHtmlOnly: boolean;
     _baseServer: string;
     _requestId: number;
+    content?: unknown;
 }): Promise<{
     renderHook: RenderHook;
     htmlRender: HtmlRender;
+    content: null;
+} | {
+    renderHook: RenderHook;
+    htmlRender: null;
+    content: Content;
 }>;

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

@@ -6,7 +6,7 @@ import { isCallable } from '../../../utils/isCallable.js';
 import { assert, assertUsage, assertWarning } from '../../../utils/assert.js';
 import { isObject } from '../../../utils/isObject.js';
 import { objectAssign } from '../../../utils/objectAssign.js';
-import { isStream } from './html/stream.js';
+import { awaitFirstChunk, isStream, isStreamReadableWeb } from './html/stream.js';
 import { assertPageContextProvidedByUser } from '../../../shared-server-client/assertPageContextProvidedByUser.js';
 import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import { assertHookReturnedObject } from '../../../shared-server-client/assertHookReturnedObject.js';
@@ -18,9 +18,6 @@ async function execHookOnRenderHtml(pageContext) {
     const hook = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: hook });
     const { hookReturn } = await execHookSingleWithReturn(hook, pageContext, getPageContextPublicServer);
-    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
-    Object.assign(pageContext, pageContextProvidedByRenderHook);
-    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
     const onErrorWhileStreaming = (err) => {
         // Should the stream inject the following?
         // ```
@@ -31,9 +28,24 @@ async function execHookOnRenderHtml(pageContext) {
             pageContext.errorWhileRendering = err;
         }
     };
+    // The render hook sets `pageContext.content` instead of returning `documentHtml`
+    if (hookReturn === undefined && pageContext.content !== undefined) {
+        const content = await getContent(pageContext.content, onErrorWhileStreaming);
+        return { content, htmlRender: null, renderHook: hook };
+    }
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
+    Object.assign(pageContext, pageContextProvidedByRenderHook);
+    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
     const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
     assert(typeof htmlRender === 'string' || isStream(htmlRender));
-    return { htmlRender, renderHook: hook };
+    return { htmlRender, content: null, renderHook: hook };
+}
+async function getContent(content, onErrorWhileStreaming) {
+    if (typeof content === 'string' || content instanceof Uint8Array)
+        return content;
+    assertUsage(isStreamReadableWeb(content), `${pc.code('pageContext.content')} is a value that isn't a string, a Uint8Array, nor a ReadableStream, see https://vike.dev/pageContext#content`);
+    // Errors before the first chunk => error page
+    return await awaitFirstChunk(content, onErrorWhileStreaming);
 }
 function getRenderHook(pageContext) {
     let hookFound;
@@ -67,10 +79,6 @@ function processHookReturnValue(hookReturnValue, renderHook) {
     let pageContextPromise = null;
     let pageContextProvidedByRenderHook = null;
     let injectFilter = null;
-    if (isDocumentHtml(hookReturnValue)) {
-        documentHtml = hookReturnValue;
-        return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
-    }
     const errPrefix = `The ${renderHook.hookName}() hook defined at ${renderHook.hookFilePath}`;
     const errSuffix = `a string generated with ${pc.cyan('escapeInject`<html>...</html>`')} or the value returned by ${pc.cyan('dangerouslySkipEscape()')}, see https://vike.dev/escapeInject`;
     if (typeof hookReturnValue === 'string') {
@@ -81,6 +89,10 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         ].join(' '), { onlyOnce: true });
         hookReturnValue = dangerouslySkipEscape(hookReturnValue);
     }
+    if (isDocumentHtml(hookReturnValue)) {
+        documentHtml = hookReturnValue;
+        return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
+    }
     const wrongReturnValue = `should return the value ${pc.cyan('documentHtml')} or an object ${pc.cyan('{ documentHtml }')} where ${pc.cyan('documentHtml')} is ${errSuffix}`;
     assertUsage(isObject(hookReturnValue), `${errPrefix} ${wrongReturnValue}`);
     assertHookReturnedObject(hookReturnValue, ['documentHtml', 'pageContext', 'injectFilter'], errPrefix);

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

@@ -20,8 +20,8 @@ type HttpResponseBody = {
     /** @deprecated */
     pipeToWebWritable: StreamPipeWeb;
 };
-declare function getHttpResponseBody(htmlRender: HtmlRender, renderHook: null | RenderHook): string;
-declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender, renderHook: null | RenderHook): {
+declare function getHttpResponseBody(htmlRender: HtmlRender | Uint8Array, renderHook: null | RenderHook): string;
+declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender | Uint8Array, renderHook: null | RenderHook): {
     pipe(writable: StreamWritableNode | StreamWritableWeb): void;
     getReadableWebStream(): StreamReadableWeb;
     getReadableNodeStream(): Promise<import("stream").Readable>;

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

@@ -40,11 +40,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             assertUsage(false, `The argument ${pc.cyan('writable')} passed to ${pc.cyan('pageContext.httpResponse.pipe(writable)')} doesn't seem to be ${getStreamName('writable', 'web')} nor ${getStreamName('writable', 'node')}.`);
         },
         getReadableWebStream() {
-            const webStream = getStreamReadableWeb(htmlRender);
-            if (webStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableWebStream()', getFixMsg('readable', 'web')));
-            }
-            return webStream;
+            return getStreamReadableWeb(htmlRender);
         },
         async getReadableNodeStream() {
             const nodeStream = await getStreamReadableNode(htmlRender);
@@ -53,7 +49,16 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
             return nodeStream;
         },
+        // Decodes the body as UTF-8 text
         async getBody() {
+            if (htmlRender instanceof Uint8Array) {
+                try {
+                    return new TextDecoder('utf-8', { fatal: true }).decode(htmlRender);
+                }
+                catch {
+                    assertUsage(false, getErrMsg(htmlRender, renderHook, 'getBody()', `The Uint8Array isn't UTF-8 text: use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
+                }
+            }
             const body = await getHtmlString(htmlRender);
             return body;
         },
@@ -71,11 +76,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
         getWebStream() {
             assertWarning(false, '`pageContext.httpResponse.getWebStream(res)` is outdated, use `pageContext.httpResponse.getReadableWebStream(res)` instead. ' +
                 streamDocs, { onlyOnce: true, showStackTrace: true });
-            const webStream = getStreamReadableWeb(htmlRender);
-            if (webStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getWebStream()', getFixMsg('readable', 'web')));
-            }
-            return webStream;
+            return getStreamReadableWeb(htmlRender);
         },
         // TO-DO/next-major-release: remove
         pipeToWebWritable(writable) {
@@ -99,7 +100,8 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
     function getFixMsg(kind, type) {
         const streamName = getStreamName(kind, type);
         assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
-        assert(renderHook);
+        if (!renderHook)
+            return `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`;
         const { hookFilePath, hookName } = renderHook;
         return `Make sure the ${hookName}() hook defined by ${hookFilePath} provides ${streamName} instead`;
     }
@@ -112,7 +114,9 @@ function getErrMsg(htmlRender, renderHook, method, msgAddendum) {
         .join('. ');
 }
 function getErrMsgBody(htmlRender, renderHook) {
-    assert(renderHook);
+    // E.g. a pageContext.json response with streamed pageContext values
+    if (!renderHook)
+        return `HTTP response body is ${getHookReturnType(htmlRender)}`;
     const { hookFilePath, hookName } = renderHook;
     const hookReturnType = getHookReturnType(htmlRender);
     assert(['a ', 'an ', 'the '].some((s) => hookReturnType.startsWith(s)));
@@ -124,6 +128,9 @@ function getHookReturnType(htmlRender) {
     if (typeof htmlRender === 'string') {
         return 'an HTML string';
     }
+    else if (htmlRender instanceof Uint8Array) {
+        return 'a Uint8Array';
+    }
     else if (isStream(htmlRender)) {
         return inferStreamName(htmlRender);
     }

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

@@ -0,0 +1,8 @@
+export { getPageContextJson };
+export { getPageContextJsonFile };
+import { type PageContextSerialization } from './html/serializeContext.js';
+import type { PageContext_logRuntime } from '../loggerRuntime.js';
+import '../../assertEnvServer.js';
+type PageContextForJson = PageContextSerialization & NonNullable<PageContext_logRuntime>;
+declare function getPageContextJson(pageContext: PageContextForJson): string | ReadableStream<Uint8Array>;
+declare function getPageContextJsonFile(pageContext: PageContextSerialization, lines: null | string[]): string;

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

@@ -0,0 +1,47 @@
+// The body of `.pageContext.json` requests (client-side navigation) and of pre-rendered `index.pageContext.json` files.
+//
+// - Without streamed pageContext values: the serialized pageContext, as is.
+// - With streamed pageContext values (see shared-server-client/streamedValues.ts): a JSON array, written line by line
+//   so that the client can read it while it streams:
+//     [{"pageId":"/pages/index","data":"!VikePromise:0"}
+//     ,{"s":0,"v":{"title":"Hello"}}
+//     ]
+export { getPageContextJson };
+export { getPageContextJsonFile };
+import { getPageContextClientSerialized } from './html/serializeContext.js';
+import { pumpStreamedValues } from './streamedValues/pump.js';
+import '../../assertEnvServer.js';
+const textEncoder = new TextEncoder();
+function getPageContextJson(pageContext) {
+    const { pageContextSerialized, streamedValues } = getPageContextClientSerialized(pageContext, false);
+    if (streamedValues.length === 0)
+        return pageContextSerialized;
+    let pump;
+    let isCancelled = false;
+    return new ReadableStream({
+        start(controller) {
+            const enqueue = (line) => controller.enqueue(textEncoder.encode(line + '\n'));
+            // Sent right away: the client runs its hooks while the values are still being produced
+            enqueue('[' + pageContextSerialized);
+            pump = pumpStreamedValues(pageContext, streamedValues, (line) => enqueue(',' + line), { failFast: false });
+            pump.done.then(() => {
+                if (isCancelled)
+                    return;
+                enqueue(']');
+                controller.close();
+            });
+        },
+        // E.g. the user navigated away
+        cancel() {
+            isCancelled = true;
+            pump.cancel();
+        },
+    });
+}
+// Pre-rendering: the lines were collected while rendering the HTML (see html/streamedValuesHtml.ts)
+function getPageContextJsonFile(pageContext, lines) {
+    const { pageContextSerialized } = getPageContextClientSerialized(pageContext, false);
+    if (!lines)
+        return pageContextSerialized;
+    return ['[' + pageContextSerialized, ...lines.map((line) => ',' + line), ']'].map((line) => line + '\n').join('');
+}

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

@@ -1,6 +1,7 @@
 export { handleErrorWithoutErrorPage };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextCreatedServer } from './createPageContextServer.js';
+import type { PageContextAborted } from '../../../shared-server-client/route/abort.js';
 import '../../assertEnvServer.js';
 declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreatedServer & {
     errorWhileRendering: null | Error;
@@ -8,6 +9,7 @@ declare function handleErrorWithoutErrorPage<PageContext extends PageContextCrea
     pageId: null;
     _globalContext: GlobalContextServerInternal;
     urlOriginal: string;
+    pageContextsAborted: PageContextAborted[];
 }>(pageContext: PageContext): PageContext & {
     httpResponse: import("./createHttpResponse.js").HttpResponse;
 };

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

@@ -20,7 +20,7 @@ function handleErrorWithoutErrorPage(pageContext) {
     else {
         const __getPageAssets = async () => [];
         objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = createHttpResponseErrorFallbackJson();
+        const httpResponse = createHttpResponseErrorFallbackJson(pageContext);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }

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

@@ -1,6 +1,6 @@
 export { handlePageContextRequestUrl };
 import { pageContextJsonFileExtension, doNotCreateExtraDirectory, } from '../../../shared-server-client/getPageContextRequestUrl.js';
-import { modifyUrl } from '../../../shared-server-client/modifyUrl.js';
+import { modifyUrlSameOrigin } from '../../../shared-server-client/modifyUrlSameOrigin.js';
 import { slice } from '../../../utils/slice.js';
 import { baseServer } from '../../../utils/urlToFile.js';
 import { assert } from '../../../utils/assert.js';
@@ -46,7 +46,7 @@ function processUrl(urlParsed, url) {
     if (pathnameModified === '')
         pathnameModified = '/';
     const searchVikeArgs = search?._vike;
-    const urlWithoutPageContextRequestSuffix = modifyUrl(url, {
+    const urlWithoutPageContextRequestSuffix = modifyUrlSameOrigin(url, {
         pathname: pathnameModified,
         search: {
             _vike: searchVikeArgs ? null : undefined,