vike 0.4.247 → 0.4.249

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

@@ -0,0 +1,112 @@
+export { createHttpResponsePage };
+export { createHttpResponsePageContextJson };
+export { createHttpResponseErrorFallback };
+export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseRedirect };
+export { createHttpResponse404 };
+export { createHttpResponseBaseIsMissing };
+import { assert, assertWarning, escapeHtml } from '../../utils.js';
+import { getErrorPageId, isErrorPage } from '../../../shared-server-client/error-page.js';
+import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
+import { getEarlyHints } from './getEarlyHints.js';
+import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
+import { resolveHeadersResponseFinal } from './headersResponse.js';
+async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
+    let statusCode = pageContext.abortStatusCode;
+    if (!statusCode) {
+        const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs);
+        if (pageContext.errorWhileRendering) {
+            assert(isError);
+        }
+        if (!isError) {
+            assert(pageContext.is404 === null);
+            statusCode = 200;
+        }
+        else {
+            assert(pageContext.is404 === true || pageContext.is404 === false);
+            statusCode = pageContext.is404 ? 404 : 500;
+        }
+    }
+    const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
+    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
+    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+}
+function createHttpResponse404(errMsg404) {
+    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
+    return httpResponse;
+}
+function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
+    const httpResponse = createHttpResponse(
+    // We use the error code `500` to signal a failing state because this HTTP response should never be used, see https://vike.dev/base-url#setup
+    // In other words: this HTTP response is expected to be generated but isn't expected to be actually used.
+    500, 'text/html;charset=utf-8', [], `
+<h1>Error: Base URL is missing</h1>
+<p>
+  <a href="https://vike.dev/renderPage"><code>renderPage(pageContextInit)</code></a> called with <code>pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}</code> which doesn't start with the Base URL <code>${baseServer}</code>.
+</p>
+<p>
+  See <a href="https://vike.dev/base-url#setup">vike.dev/base-url#setup</a> for how to properly setup your server while using a Base URL.
+</p>
+<style>
+  code {
+    font-family: monospace;
+    background-color: #eaeaea;
+    padding: 3px 5px;
+    border-radius: 4px;
+  }
+</style>
+`);
+    return httpResponse;
+}
+function createHttpResponseErrorFallback(pageContext) {
+    const reason = (() => {
+        const errorPageId = getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs);
+        if (errorPageId) {
+            return "the error page (https://vike.dev/error-page) couldn't be rendered (for example if an error occurred while rendering the error page)";
+        }
+        else {
+            return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
+        }
+    })();
+    return createHttpResponseError_(reason);
+}
+function createHttpResponseErrorFallback_noGlobalContext() {
+    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered');
+}
+function createHttpResponseError_(reason) {
+    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTML was generated by Vike. Vike returned this HTML because ${reason}.`)})</script>`);
+    return httpResponse;
+}
+async function createHttpResponsePageContextJson(pageContextSerialized) {
+    const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    return httpResponse;
+}
+function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
+    assertNoInfiniteHttpRedirect(url, pageContextInit);
+    assert(url);
+    assert(statusCode);
+    assert(300 <= statusCode && statusCode <= 399);
+    const headers = [['Location', url]];
+    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
+    // For bots / programmatic crawlig: show what's going on.
+    // For users: showing a blank page is probably better than a flickering text.
+    `<p style="display: none">Redirecting to ${escapeHtml(url)}</p><script>console.log('This HTML was generated by Vike.')</script>`);
+}
+function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
+    headers.push(['Content-Type', contentType]);
+    assert(renderHook || typeof htmlRender === 'string');
+    return {
+        statusCode,
+        headers,
+        // TO-DO/next-major-release: remove
+        get contentType() {
+            assertWarning(false, 'pageContext.httpResponse.contentType is deprecated and will be removed in the next major release. Use pageContext.httpResponse.headers instead, see https://vike.dev/migration/0.4.134', { onlyOnce: true });
+            return contentType;
+        },
+        earlyHints,
+        get body() {
+            return getHttpResponseBody(htmlRender, renderHook);
+        },
+        ...getHttpResponseBodyStreamHandlers(htmlRender, renderHook),
+    };
+}

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

@@ -0,0 +1,159 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+export type { PageContextCreated };
+import type { GlobalContextServerInternal } from '../globalContext.js';
+import type { PageContextInit } from '../renderPageServer.js';
+type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
+    requestId: number;
+} & ({
+    isPrerendering: true;
+} | {
+    isPrerendering: false;
+    urlHandler: null | ((url: string) => string);
+    isClientSideNavigation: boolean;
+})): {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _globalContext: ({
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../../types/index.js").ConfigResolved;
+                    _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../../types/index.js").ConfigResolved;
+                _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../../types/index.js").ConfigResolved;
+        _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../__internal/index.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & (({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
+        isClientSide: false;
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+    })) & {
+        prerenderContext: import("../../../types/index.js").PrerenderContext | undefined;
+    };
+    _pageFilesAll: import("../../__internal/index.js").PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: PageContextInit;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    pages: {
+        [k: string]: {
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../../types/index.js").ConfigResolved;
+    _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("../../utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+};
+declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit, requestId: number): {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+};

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

@@ -0,0 +1,57 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+import { assert, assertUsage, assertWarning, updateType, normalizeHeaders, objectAssign } from '../../utils.js';
+import { getPageContextUrlComputed } from '../../../shared-server-client/getPageContextUrlComputed.js';
+import { createPageContextObject, createPageContextShared, } from '../../../shared-server-client/createPageContextShared.js';
+function createPageContextServerSide(pageContextInit, globalContext, args) {
+    assert(pageContextInit.urlOriginal);
+    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering, args.requestId);
+    objectAssign(pageContextCreated, {
+        _globalContext: globalContext,
+        _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
+        // We use pageContext._baseServer and pageContext._baseAssets instead of pageContext._globalContext.baseServer and pageContext._globalContext.baseAssets because the Base URLs can (eventually one day if needed) be made non-global
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
+        _pageContextInit: pageContextInit,
+        _urlHandler: args.isPrerendering ? null : args.urlHandler,
+        isClientSideNavigation: args.isPrerendering ? false : args.isClientSideNavigation,
+    });
+    objectAssign(pageContextCreated, globalContext._globalConfigPublic);
+    // pageContext.urlParsed
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
+    objectAssign(pageContextCreated, pageContextUrlComputed);
+    // pageContext.headers
+    {
+        let headers;
+        if (pageContextInit.headersOriginal) {
+            headers = normalizeHeaders(pageContextInit.headersOriginal);
+            assertUsage(!('headers' in pageContextInit), "You're defining pageContextInit.headersOriginal as well as pageContextInit.headers but you should only define pageContextInit.headersOriginal instead, see https://vike.dev/headers");
+        }
+        else if (pageContextInit.headers) {
+            headers = pageContextInit.headers;
+            // TO-DO/next-major-release: remove
+            assertWarning(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        objectAssign(pageContextCreated, { headers });
+    }
+    const pageContextAugmented = createPageContextShared(pageContextCreated, globalContext._globalConfigPublic);
+    updateType(pageContextCreated, pageContextAugmented);
+    return pageContextCreated;
+}
+function createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId) {
+    const pageContext = createPageContext(pageContextInit, false, requestId);
+    return pageContext;
+}
+function createPageContext(pageContextInit, isPrerendering, requestId) {
+    const pageContext = createPageContextObject();
+    objectAssign(pageContext, {
+        isClientSide: false,
+        isPrerendering,
+        _requestId: requestId,
+    });
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}

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

@@ -0,0 +1,12 @@
+export { resolvePageContextCspNone };
+export { inferNonceAttr };
+export { addCspResponseHeader };
+export type { PageContextCspNonce };
+import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { PageContextServer } from '../../../types/PageContext.js';
+declare function resolvePageContextCspNone(pageContext: PageContextConfig & Partial<PageContextCspNonce>): Promise<null | {
+    cspNonce: string | null;
+}>;
+type PageContextCspNonce = Pick<PageContextServer, 'cspNonce'>;
+declare function inferNonceAttr(pageContext: PageContextCspNonce): string;
+declare function addCspResponseHeader(pageContext: PageContextCspNonce, headersResponse: Headers): void;

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

@@ -0,0 +1,45 @@
+export { resolvePageContextCspNone };
+export { inferNonceAttr };
+export { addCspResponseHeader };
+import { import_ } from '@brillout/import';
+import { assert } from '../../utils.js';
+async function resolvePageContextCspNone(pageContext) {
+    if (pageContext.cspNonce)
+        return null; // already set by user e.g. `renderPage({ cspNonce: '123456789' })`
+    const { csp } = pageContext.config;
+    const pageContextAddendum = { cspNonce: null };
+    if (csp?.nonce) {
+        if (csp.nonce === true) {
+            pageContextAddendum.cspNonce = await generateNonce();
+        }
+        else {
+            pageContextAddendum.cspNonce = await csp.nonce(pageContext);
+        }
+    }
+    return pageContextAddendum;
+}
+// Generate a cryptographically secure nonce for Content Security Policy (CSP).
+// Returns a base64url-encoded nonce string (URL-safe, no padding).
+// https://github.com/vikejs/vike/issues/1554#issuecomment-3181128304
+async function generateNonce() {
+    let cryptoModule;
+    try {
+        cryptoModule = (await import_('crypto')).default;
+    }
+    catch {
+        return Math.random().toString(36).substring(2, 18);
+    }
+    return cryptoModule.randomBytes(16).toString('base64url');
+}
+function inferNonceAttr(pageContext) {
+    const nonceAttr = pageContext.cspNonce ? ` nonce="${pageContext.cspNonce}"` : '';
+    return nonceAttr;
+}
+function addCspResponseHeader(pageContext, headersResponse) {
+    assert(pageContext.cspNonce === null || typeof pageContext.cspNonce === 'string'); // ensure resolvePageContextCspNone() is called before addCspResponseHeader()
+    if (!pageContext.cspNonce)
+        return;
+    if (headersResponse.get('Content-Security-Policy'))
+        return;
+    headersResponse.set('Content-Security-Policy', `script-src 'self' 'nonce-${pageContext.cspNonce}'`);
+}

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

@@ -0,0 +1,29 @@
+export { execHookDataAndOnBeforeRender };
+import { assertOnBeforeRenderHookReturn } from '../../../shared-server-client/assertOnBeforeRenderHookReturn.js';
+import { execHookServer } from './execHookServer.js';
+async function execHookDataAndOnBeforeRender(pageContext) {
+    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
+        return;
+    }
+    const hooks = await execHookServer('data', pageContext);
+    const dataHook = hooks[0]; // TO-DO/soon/cumulative-hooks: support cumulative
+    if (dataHook) {
+        // Note: hookReturn can be anything (e.g. an object) and is to be assigned to pageContext.data
+        const pageContextFromHook = {
+            data: dataHook.hookReturn,
+        };
+        Object.assign(pageContext, pageContextFromHook);
+        // Execute +onData
+        if (!pageContext.isClientSideNavigation) {
+            await execHookServer('onData', pageContext);
+        }
+    }
+    const res = await execHookServer('onBeforeRender', pageContext);
+    const onBeforeRenderHook = res[0]; // TO-DO/soon/cumulative-hooks: support cumulative
+    if (onBeforeRenderHook) {
+        const { hookReturn } = onBeforeRenderHook;
+        assertOnBeforeRenderHookReturn(hookReturn, onBeforeRenderHook.hookFilePath);
+        const pageContextFromHook = hookReturn?.pageContext;
+        Object.assign(pageContext, pageContextFromHook);
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+export { execHookOnError };
+import { isObject, getGlobalObject } from '../../utils.js';
+import { getGlobalContextServerInternalOptional } from '../globalContext.js';
+import { getHookFromPageConfigGlobalCumulative } from '../../../shared-server-client/hooks/getHook.js';
+const globalObject = getGlobalObject('renderPageServer/execHookOnError.ts', {
+    seen: new WeakSet(),
+});
+function execHookOnError(err, pageContext) {
+    if (isObject(err)) {
+        if (globalObject.seen.has(err))
+            return;
+        globalObject.seen.add(err);
+    }
+    const globalContext = getGlobalContextServerInternalOptional();
+    if (!globalContext)
+        return;
+    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
+    for (const hook of hooks) {
+        try {
+            hook.hookFn(err, pageContext);
+        }
+        catch (hookErr) {
+            console.error(hookErr);
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+export { execHookOnRenderHtml };
+export type { RenderHook };
+import { type HtmlRender } from './html/renderHtml.js';
+import { type Hook } from '../../../shared-server-client/hooks/getHook.js';
+import type { PageAsset } from './getPageAssets.js';
+import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+import type { PageContextSerialization } from './html/serializeContext.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
+type GetPageAssets = () => Promise<PageAsset[]>;
+type RenderHook = Hook & {
+    hookName: HookName;
+};
+type HookName = 'onRenderHtml' | 'render';
+declare function execHookOnRenderHtml(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
+    pageId: string;
+    _globalContext: GlobalContextServerInternal;
+    __getPageAssets: GetPageAssets;
+    _isHtmlOnly: boolean;
+    _baseServer: string;
+    _requestId: number;
+}): Promise<{
+    renderHook: RenderHook;
+    htmlRender: HtmlRender;
+}>;

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

@@ -0,0 +1,115 @@
+export { execHookOnRenderHtml };
+import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape, } from './html/renderHtml.js';
+import { getHookFromPageContext } from '../../../shared-server-client/hooks/getHook.js';
+import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../../utils.js';
+import { isStream } from './html/stream.js';
+import { assertPageContextProvidedByUser } from '../../../shared-server-client/assertPageContextProvidedByUser.js';
+import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
+import { assertHookReturnedObject } from '../../../shared-server-client/assertHookReturnedObject.js';
+import { logRuntimeError } from '../loggerRuntime.js';
+import pc from '@brillout/picocolors';
+import { execHookDirectSingleWithReturn } from '../../../shared-server-client/hooks/execHook.js';
+async function execHookOnRenderHtml(pageContext) {
+    const hook = getRenderHook(pageContext);
+    objectAssign(pageContext, { _renderHook: hook });
+    const { hookReturn } = await execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
+    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?
+        // ```
+        // <script>console.error("An error occurred on the server side while streaming the page to HTML, see server logs.")</script>
+        // ```
+        logRuntimeError(err, pageContext);
+        if (!pageContext.errorWhileRendering) {
+            pageContext.errorWhileRendering = err;
+        }
+    };
+    const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
+    assert(typeof htmlRender === 'string' || isStream(htmlRender));
+    return { htmlRender, renderHook: hook };
+}
+function getRenderHook(pageContext) {
+    let hookFound;
+    {
+        let hook;
+        let hookName = undefined;
+        hook = getHookFromPageContext(pageContext, 'onRenderHtml');
+        if (hook) {
+            hookName = 'onRenderHtml';
+        }
+        else {
+            hook = getHookFromPageContext(pageContext, 'render');
+            if (hook) {
+                hookName = 'render';
+            }
+        }
+        if (hook) {
+            assert(hookName);
+            const { hookFilePath, hookFn, hookTimeout } = hook;
+            hookFound = { hookFn, hookFilePath, hookName, hookTimeout };
+        }
+    }
+    if (!hookFound) {
+        const hookName = pageContext._globalContext._pageConfigs.length > 0 ? 'onRenderHtml' : 'render';
+        assertUsage(false, `No ${hookName}() hook found, see https://vike.dev/${hookName}`);
+    }
+    return hookFound;
+}
+function processHookReturnValue(hookReturnValue, renderHook) {
+    let documentHtml;
+    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') {
+        assertWarning(false, [
+            errPrefix,
+            `returned a plain JavaScript string which is ${pc.red(pc.bold('dangerous'))}: it should instead return`,
+            errSuffix,
+        ].join(' '), { onlyOnce: true });
+        hookReturnValue = dangerouslySkipEscape(hookReturnValue);
+    }
+    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);
+    assertUsage(hookReturnValue.documentHtml, `${errPrefix} returned an object that is missing the ${pc.code('documentHtml')} property: it ${wrongReturnValue}`);
+    if (hookReturnValue.injectFilter) {
+        assertUsage(isCallable(hookReturnValue.injectFilter), 'injectFilter should be a function');
+        injectFilter = hookReturnValue.injectFilter;
+    }
+    {
+        let val = hookReturnValue.documentHtml;
+        const errBegin = `${errPrefix} returned ${pc.cyan('{ documentHtml }')}, but ${pc.cyan('documentHtml')}`;
+        if (typeof val === 'string') {
+            assertWarning(false, [
+                errBegin,
+                `is a plain JavaScript string which is ${pc.bold(pc.red('dangerous'))}: ${pc.cyan('documentHtml')} should be`,
+                errSuffix,
+            ].join(' '), { onlyOnce: true });
+            val = dangerouslySkipEscape(val);
+        }
+        assertUsage(isDocumentHtml(val), [errBegin, 'should be', errSuffix].join(' '));
+        documentHtml = val;
+    }
+    if (hookReturnValue.pageContext) {
+        const val = hookReturnValue.pageContext;
+        const errBegin = `${errPrefix} returned ${pc.cyan('{ pageContext }')}, but ${pc.cyan('pageContext')}`;
+        if (isPromise(val) || isCallable(val)) {
+            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/streaming#initial-data-after-stream-end`, { onlyOnce: true });
+            pageContextPromise = val;
+        }
+        else {
+            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/streaming#initial-data-after-stream-end`);
+            assertPageContextProvidedByUser(val, renderHook);
+            pageContextProvidedByRenderHook = val;
+        }
+    }
+    return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
+}

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

@@ -0,0 +1,12 @@
+export { execHookServer };
+export type { PageContextExecHookServer };
+import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { HookName } from '../../../types/Config.js';
+type PageContextExecHookServer = PageContextConfig & PageContextForPublicUsageServer;
+declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared-server-client/hooks/getHook.js").HookLoc & {
+    hookFn: (arg: import("../../../shared-server-client/preparePageContextForPublicUsage.js").PageContextPrepareMinimum, ...rest: unknown[]) => unknown;
+    hookTimeout: import("../../../shared-server-client/hooks/getHook.js").HookTimeout;
+} & {
+    hookReturn: unknown;
+})[]>;

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

@@ -0,0 +1,13 @@
+export { execHookServer };
+import { execHookDirect } from '../../../shared-server-client/hooks/execHook.js';
+import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
+import { getHookFromPageContextNew } from '../../../shared-server-client/hooks/getHook.js';
+import { getFileSuffixes } from '../../../shared-server-node/getFileSuffixes.js';
+async function execHookServer(hookName, pageContext) {
+    const allHooks = getHookFromPageContextNew(hookName, pageContext);
+    const hooks = !pageContext.isClientSideNavigation
+        ? allHooks
+        : // Don't execute `.ssr.js` hooks upon client-side navigation
+            allHooks.filter((hook) => !getFileSuffixes(hook.hookFilePath).includes('ssr'));
+    return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsageServer);
+}

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

@@ -0,0 +1,21 @@
+export { getCacheControl };
+export { cacheControlDisable };
+import { getPageConfig } from '../../../shared-server-client/page-configs/helpers.js';
+import { getConfigValueRuntime } from '../../../shared-server-client/page-configs/getConfigValueRuntime.js';
+const cacheControlDisable = 'no-store, max-age=0';
+function getCacheControl(pageId, pageConfigs) {
+    // TO-DO/next-major-release: remove this line
+    if (pageConfigs.length === 0)
+        return cacheControlDisable;
+    if (pageId) {
+        const pageConfig = getPageConfig(pageId, pageConfigs);
+        const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
+        const value = configValue?.value;
+        if (value)
+            return value;
+    }
+    // - Disabling caching by default is the safest strategy, because caching is problematic with authentication as described in https://github.com/vikejs/vike/issues/1275#issuecomment-1824366875
+    // - Are there use cases when we don't need to disable caching?
+    //   - When there isn't any <script id="vike_pageContext" type="application/json"> then we can safely have caching. (We don't implement this exception because we're lazy and it's quite a rare situation.)
+    return cacheControlDisable;
+}