vike 0.4.267 → 0.4.268-commit-ca58695

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,

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();