vike 0.4.266 → 0.4.267-commit-7884d91

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;

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

@@ -53,7 +53,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;
         },
@@ -99,7 +108,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 +122,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 +136,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/headersResponse.d.ts

@@ -1,11 +1,20 @@
 export { resolveHeadersResponseEarly };
 export { resolveHeadersResponseFinal };
+export { resolveHeadersResponseSetCookie };
+export { getHeadersSetCookieAborted };
 import { PageContextCspNonce } from './csp.js';
 import type { PageContextAfterPageEntryLoaded } from './loadPageConfigsLazyServerSide.js';
+import type { PageContextAborted } from '../../../shared-server-client/route/abort.js';
 import '../../assertEnvServer.js';
-declare function resolveHeadersResponseFinal(pageContext: {
+type PageContextHeadersResponse = {
     headersResponse?: Headers;
-}, statusCode: number): [string, string][];
+    pageContextsAborted: PageContextAborted[];
+};
+declare function resolveHeadersResponseFinal(pageContext: PageContextHeadersResponse, statusCode: number): [string, string][];
+declare function resolveHeadersResponseSetCookie(pageContext: PageContextHeadersResponse): [string, string][];
+declare function getHeadersSetCookieAborted(pageContext: {
+    pageContextsAborted: PageContextAborted[];
+}): [string, string][];
 declare function resolveHeadersResponseEarly(pageContext: PageContextAfterPageEntryLoaded & PageContextCspNonce): Promise<{
     headersResponse: Headers;
 }>;

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

@@ -1,21 +1,41 @@
 export { resolveHeadersResponseEarly };
 export { resolveHeadersResponseFinal };
+export { resolveHeadersResponseSetCookie };
+export { getHeadersSetCookieAborted };
 import { addCspResponseHeader } from './csp.js';
 import { isCallable } from '../../../utils/isCallable.js';
 import { cacheControlDisable, getCacheControl } from './getCacheControl.js';
+import { getPageContextPublicServer } from './getPageContextPublicServer.js';
 import '../../assertEnvServer.js';
+// Headers of HTML page responses
 function resolveHeadersResponseFinal(pageContext, statusCode) {
     const headersResponse = pageContext.headersResponse || new Headers();
     // 5xx error pages are temporary and shouldn't be cached.
     // This overrides any previously set Cache-Control value.
     if (statusCode >= 500)
         headersResponse.set('Cache-Control', cacheControlDisable);
-    const headers = [];
+    const headers = getHeadersSetCookieAborted(pageContext);
     headersResponse.forEach((value, key) => {
         headers.push([key, value]);
     });
     return headers;
 }
+// Headers of `pageContext.json` and redirect responses: only `Set-Cookie` applies to them, the other headers (e.g. `Cache-Control` and `Content-Security-Policy`) are about the HTML page.
+function resolveHeadersResponseSetCookie(pageContext) {
+    const headersResponse = pageContext.headersResponse || new Headers();
+    const headers = getHeadersSetCookieAborted(pageContext);
+    headersResponse.getSetCookie().forEach((value) => {
+        headers.push(['set-cookie', value]);
+    });
+    return headers;
+}
+// Cookies set before `throw redirect()` or `throw render()` are kept. They're sent first, so that a cookie set again later wins.
+function getHeadersSetCookieAborted(pageContext) {
+    return pageContext.pageContextsAborted.flatMap((pageContextAborted) => {
+        const { headersResponse } = pageContextAborted;
+        return (headersResponse?.getSetCookie() ?? []).map((value) => ['set-cookie', value]);
+    });
+}
 async function resolveHeadersResponseEarly(pageContext) {
     const headersResponse = await resolveHeadersResponseConfig(pageContext);
     if (!headersResponse.get('Cache-Control')) {
@@ -34,7 +54,7 @@ async function resolveHeadersResponseConfig(pageContext) {
     await Promise.all((pageContext.config.headersResponse ?? []).map(async (headers) => {
         let headersInit;
         if (isCallable(headers)) {
-            headersInit = await headers(pageContext);
+            headersInit = await headers(getPageContextPublicServer(pageContext));
         }
         else {
             headersInit = headers;

package/dist/server/runtime/renderPageServer/html/injectAssets/getHtmlTags.js

@@ -2,7 +2,7 @@ export { getHtmlTags };
 import { assert, assertWarning, assertUsage } from '../../../../../utils/assert.js';
 import { freezePartial } from '../../../../../utils/freezePartial.js';
 import { isObject } from '../../../../../utils/isObject.js';
-import { getGlobalContextClientSerialized, getPageContextClientSerialized, } from '../serializeContext.js';
+import { getGlobalContextClientSerialized } from '../serializeContext.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
 import { getPageConfig } from '../../../../../shared-server-client/page-configs/helpers.js';
@@ -12,6 +12,7 @@ import { getConfigDefinedAt } from '../../../../../shared-server-client/page-con
 import { htmlElementId_globalContext, htmlElementId_pageContext, } from '../../../../../shared-server-client/htmlElementIds.js';
 import { isFontFallback } from '../../isFontFallback.js';
 import { inferNonceAttr } from '../../csp.js';
+import { serializePageContextHtml } from '../streamedValuesHtml.js';
 import '../../../../assertEnvServer.js';
 const stamp = '__injectFilterEntry';
 async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
@@ -128,7 +129,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
-            getPageContextJsonScriptTag(pageContext),
+            getPageContextJsonScriptTag(pageContext, streamFromReactStreamingPackage),
             position: positionJavaScriptEntry,
         });
         // <script id="vike_globalContext" type="application/json">
@@ -184,8 +185,8 @@ function mergeScriptEntries(pageAssets, viteDevScript, pageContext) {
     scriptEntry = mergeScriptTags(scriptEntry, pageContext);
     return scriptEntry;
 }
-function getPageContextJsonScriptTag(pageContext) {
-    const pageContextClientSerialized = getPageContextClientSerialized(pageContext, true);
+function getPageContextJsonScriptTag(pageContext, streamFromReactStreamingPackage) {
+    const pageContextClientSerialized = serializePageContextHtml(pageContext, streamFromReactStreamingPackage);
     const nonceAttr = inferNonceAttr(pageContext);
     const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json"${nonceAttr}>${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus

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

@@ -7,6 +7,7 @@ import type { HtmlPart } from './renderHtml.js';
 import { type PreloadFilter } from './injectAssets/getHtmlTags.js';
 import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import type { PageContextSerialization } from './serializeContext.js';
+import { type PageContextStreamedValuesHtml } from './streamedValuesHtml.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
 import '../../../assertEnvServer.js';
 type PageContextInjectAssets = {
@@ -22,7 +23,7 @@ type PageContextInjectAssets = {
     _baseServer: string;
     is404: null | boolean;
     _globalContext: GlobalContextServerInternal;
-} & PageContextSerialization;
+} & PageContextSerialization & PageContextStreamedValuesHtml;
 declare function injectHtmlTagsToString(htmlParts: HtmlPart[], pageContext: PageContextInjectAssets & {
     _isStream: false;
 }, injectFilter: PreloadFilter): Promise<string>;
@@ -31,6 +32,6 @@ declare function injectHtmlTagsToStream(pageContext: PageContextInjectAssets & {
 }, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage, injectFilter: PreloadFilter): {
     injectAtStreamBegin: (htmlPartsBegin: HtmlPart[]) => Promise<string>;
     injectAtStreamAfterFirstChunk: () => null | string;
-    injectAtStreamEnd: (htmlPartsEnd: HtmlPart[]) => Promise<string>;
+    injectAtStreamEnd: (htmlPartsEnd: HtmlPart[], writeHtml: (html: string) => void) => Promise<string>;
 };
 type PageContextPromise = null | Promise<unknown> | (() => void | Promise<unknown>);

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

@@ -6,6 +6,7 @@ import { assert } from '../../../../utils/assert.js';
 import { assertPageContextProvidedByUser } from '../../../../shared-server-client/assertPageContextProvidedByUser.js';
 import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream, } from './injectAssets/injectHtmlTags.js';
 import { getHtmlTags } from './injectAssets/getHtmlTags.js';
+import { getStreamedValuesHtml, writeStreamedValuesHtmlAtStreamEnd, } from './streamedValuesHtml.js';
 import { getViteDevScript } from './injectAssets/getViteDevScript.js';
 import '../../../assertEnvServer.js';
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
@@ -16,6 +17,10 @@ async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
     assert(htmlTags.filter((snippet) => snippet.position === 'HTML_STREAM').length === 0);
+    const streamedValuesHtml = await getStreamedValuesHtml(pageContext);
+    if (streamedValuesHtml !== null) {
+        htmlString = injectToHtmlEnd(htmlString, [{ htmlTag: streamedValuesHtml, position: 'HTML_END' }]);
+    }
     return htmlString;
 }
 function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, injectFilter) {
@@ -48,12 +53,13 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
         const htmlFragment = joinHtmlTags(tags);
         return htmlFragment;
     }
-    async function injectAtStreamEnd(htmlPartsEnd) {
+    async function injectAtStreamEnd(htmlPartsEnd, writeHtml) {
         assert(htmlTags);
         await resolvePageContextPromise(pageContext);
         const pageAssets = await pageContext.__getPageAssets();
         let htmlEnd = htmlPartsToString(htmlPartsEnd, pageAssets);
         htmlEnd = injectToHtmlEnd(htmlEnd, htmlTags);
+        htmlEnd = await writeStreamedValuesHtmlAtStreamEnd(pageContext, htmlEnd, writeHtml);
         return htmlEnd;
     }
 }

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

@@ -13,6 +13,7 @@ import { objectAssign } from '../../../../utils/objectAssign.js';
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
 import { processStream, isStream, streamToString, } from './stream.js';
 import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';
+import { cancelStreamedValuesHtml } from './streamedValuesHtml.js';
 import pc from '@brillout/picocolors';
 import '../../../assertEnvServer.js';
 function isDocumentHtml(something) {
@@ -61,6 +62,7 @@ async function renderHtmlStream(streamOriginal, injectString, pageContext, onErr
     const processStreamOptions = {
         onErrorWhileStreaming,
         enableEagerStreaming: pageContext.enableEagerStreaming,
+        onCancel: () => cancelStreamedValuesHtml(pageContext),
     };
     if (injectString) {
         let streamFromReactStreamingPackage = null;
@@ -71,8 +73,8 @@ async function renderHtmlStream(streamOriginal, injectString, pageContext, onErr
         processStreamOptions.injectStringAtBegin = async () => {
             return await injectAtStreamBegin(injectString.htmlPartsBegin);
         };
-        processStreamOptions.injectStringAtEnd = async () => {
-            return await injectAtStreamEnd(injectString.htmlPartsEnd);
+        processStreamOptions.injectStringAtEnd = async (writeHtml) => {
+            return await injectAtStreamEnd(injectString.htmlPartsEnd, writeHtml);
         };
         processStreamOptions.injectStringAfterFirstChunk = () => {
             return injectAtStreamAfterFirstChunk();

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

@@ -9,6 +9,7 @@ import type { GlobalContextServerInternal } from '../../globalContext.js';
 import type { PageContextCreatedServer } from '../createPageContextServer.js';
 import type { PageContextBegin } from '../../renderPageServer.js';
 import type { PageContextCspNonce } from '../csp.js';
+import { type StreamedValue } from '../streamedValues/registry.js';
 import '../../../assertEnvServer.js';
 type PageContextSerialization = PageContextCreatedServer & {
     pageId: string;
@@ -20,7 +21,10 @@ type PageContextSerialization = PageContextCreatedServer & {
     _globalContext: GlobalContextServerInternal;
     _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
 } & PageContextCspNonce;
-declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
+declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): {
+    pageContextSerialized: string;
+    streamedValues: StreamedValue[];
+};
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
 type PassToClient = string[];
 type PassToClientPublic = (string | {

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

@@ -7,12 +7,12 @@ import { getPropAccessNotation } from '../../../../utils/getPropAccessNotation.j
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
 import { hasProp } from '../../../../utils/hasProp.js';
 import { isErrorPage } from '../../../../shared-server-client/error-page.js';
-import { addIs404ToPageProps } from '../../../../shared-server-client/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 import { NOT_SERIALIZABLE } from '../../../../shared-server-client/NOT_SERIALIZABLE.js';
 import { pageContextInitIsPassedToClient } from '../../../../shared-server-client/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../../../shared-server-client/misc/isServerSideError.js';
 import { getPropKeys, getPropVal, setPropVal } from './propKeys.js';
+import { getReplacer } from '../streamedValues/registry.js';
 import { assertRouteParams } from '../../../../shared-server-client/route/resolveRouteFunction.js';
 import '../../../assertEnvServer.js';
 const passToClientBuiltInPageContext = [
@@ -30,6 +30,8 @@ const passToClientBuiltInPageContext = [
     'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
+// Streamed pageContext values (see shared-server-client/streamedValues.ts) are serialized as placeholders and returned:
+// the caller sends them after the serialized pageContext.
 function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
     const res = applyPassToClient(passToClientPageContext, pageContext);
@@ -38,8 +40,9 @@ function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     if (pageContextClientProps.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
-    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
-    return pageContextClientSerialized;
+    const { replacer, streamedValues } = getReplacer(pageContext);
+    const pageContextSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript, replacer);
+    return { pageContextSerialized, streamedValues };
 }
 function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClient = pageContext._passToClient;
@@ -49,10 +52,10 @@ function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript, replacer) {
     let serialized;
     try {
-        serialized = serializeValue(obj, isHtmlJsonScript);
+        serialized = serializeValue(obj, isHtmlJsonScript, undefined, replacer);
     }
     catch (err) {
         const h = (s) => pc.cyan(s);
@@ -65,7 +68,7 @@ function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
             const { value } = res;
             const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
-                serializeValue(value, isHtmlJsonScript, varName);
+                serializeValue(value, isHtmlJsonScript, varName, replacer);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -103,7 +106,7 @@ function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
             obj[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
-            serialized = serializeValue(obj, isHtmlJsonScript);
+            serialized = serializeValue(obj, isHtmlJsonScript, undefined, replacer);
         }
         catch (err) {
             assert(false);
@@ -111,10 +114,11 @@ function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
     }
     return serialized;
 }
-function serializeValue(value, isHtmlJsonScript, varName) {
+function serializeValue(value, isHtmlJsonScript, varName, replacer) {
     return stringify(value, {
         forbidReactElements: true,
         valueName: varName,
+        replacer,
         htmlScriptSafe: {
             // Could be set to `isHtmlJsonScript` but we always use `htmlScriptSafe.escapeScripts` to be extra safe
             escapeScripts: true,
@@ -127,7 +131,6 @@ function getPassToClientPageContext(pageContext) {
     let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
     if (isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs)) {
         assert(hasProp(pageContext, 'is404', 'boolean'));
-        addIs404ToPageProps(pageContext);
         passToClient.push(...pageToClientBuiltInPageContextError);
     }
     passToClient = unique(passToClient);

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

@@ -16,6 +16,8 @@ export { isStreamReadableNode };
 export { getStreamName };
 export { inferStreamName };
 export { streamReadableWebToString };
+export { streamReadableWebToBytes };
+export { awaitFirstChunk };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
@@ -46,17 +48,22 @@ declare function isStreamWritableWeb(thing: unknown): thing is StreamWritableWeb
 declare function isStreamReadableNode(thing: unknown): thing is StreamReadableNode;
 declare function isStreamWritableNode(thing: unknown): thing is StreamWritableNode;
 declare function streamReadableWebToString(readableWeb: ReadableStream): Promise<string>;
+declare function streamReadableWebToBytes(readableWeb: ReadableStream): Promise<Uint8Array>;
+declare function awaitFirstChunk(stream: StreamReadableWeb, onErrorWhileStreaming: (err: unknown) => void): Promise<StreamReadableWeb>;
 declare function streamPipeNodeToString(streamPipeNode: StreamPipeNode): Promise<string>;
-declare function getStreamReadableNode(htmlRender: HtmlRender): Promise<null | StreamReadableNode>;
-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 getStreamReadableNode(htmlRender: HtmlRender | Uint8Array): Promise<null | StreamReadableNode>;
+declare function getStreamReadableWeb(htmlRender: HtmlRender | Uint8Array): null | StreamReadableWeb;
+declare function pipeToStreamWritableWeb(htmlRender: HtmlRender | Uint8Array, writable: StreamWritableWeb): boolean;
+declare function pipeToStreamWritableNode(htmlRender: HtmlRender | Uint8Array, writable: StreamWritableNode): boolean;
+declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, onCancel, }: {
     injectStringAtBegin?: () => Promise<string>;
     injectStringAfterFirstChunk?: () => string | null;
-    injectStringAtEnd?: () => Promise<string>;
+    /** `writeHtml()` writes HTML before the returned string (e.g. streamed pageContext values) */
+    injectStringAtEnd?: (writeHtml: (html: string) => void) => Promise<string>;
     onErrorWhileStreaming: (err: unknown) => void;
     enableEagerStreaming?: boolean;
+    /** The stream was cancelled (e.g. the user closed the tab) or failed */
+    onCancel: () => void;
 }): Promise<StreamProviderNormalized>;
 declare function isStream(something: unknown): something is StreamProviderAny;
 declare const __streamPipeWeb = "__streamPipeWeb";