vike 0.4.228 → 0.4.229-commit-2a06dcc

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

@@ -1,16 +1,155 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { HttpResponse } from './renderPage/createHttpResponse.js';
+export type { PageContextInit };
+export type { PageContextBegin };
+import { type GlobalContextServer, type GlobalContextServerInternal } from './globalContext.js';
+import { type HttpResponse } from './renderPage/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-declare function renderPage<PageContextUserAdded extends {}, PageContextInit extends {
-    /** @deprecated */
-    url?: string;
-    /** The URL of the HTTP request */
-    urlOriginal: string;
-}>(pageContextInit: PageContextInit): Promise<PageContextInit & {
+import type { PageContextBuiltInServerInternal } from '../../shared/types.js';
+type PageContextInit = Pick<PageContextBuiltInServerInternal, 'urlOriginal' | 'headersOriginal'> & {
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+};
+type PageContextBegin = Awaited<ReturnType<typeof getPageContextBegin>>;
+declare function renderPage<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
 declare let asyncHookWrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
     pageContextReturn: Awaited<PageContext>;
 }>;
 declare function renderPage_addAsyncHookwrapper(wrapper: typeof asyncHookWrapper): void;
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, globalContext_public: GlobalContextServer, httpRequestId: number): Promise<{
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+} & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: import("vite").ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
+    _baseServer: string;
+    _baseAssets: string;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _pageContextInit: PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
+} & {
+    _httpRequestId: number;
+}>;

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

@@ -1,19 +1,20 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { getPageContextInitEnhanced, renderPageAlreadyRouted, createPageContext } from './renderPage/renderPageAlreadyRouted.js';
+import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
-import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
+import { getGlobalContextServerInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
+import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseErrorWithoutGlobalContext, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
 import { log404 } from './renderPage/log404/index.js';
 import { isVikeConfigInvalid } from './renderPage/isVikeConfigInvalid.js';
 import pc from '@brillout/picocolors';
-import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
+import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
@@ -27,13 +28,13 @@ async function renderPage(pageContextInit) {
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertIsUrl(pageContextInit.urlOriginal);
     onSetupRuntime();
-    const pageContextInvalidRequest = renderInvalidRequest(pageContextInit);
+    const pageContextInvalidRequest = getPageContextInvalidRequest(pageContextInit);
     if (pageContextInvalidRequest)
         return pageContextInvalidRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = getUrlPretty(pageContextInit.urlOriginal);
     logHttpRequest(urlOriginalPretty, httpRequestId);
-    const { pageContextReturn } = await asyncHookWrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    const { pageContextReturn } = await asyncHookWrapper(httpRequestId, () => renderPagePrepare(pageContextInit, httpRequestId));
     logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn);
     checkType(pageContextReturn);
     assert(pageContextReturn.httpResponse);
@@ -47,13 +48,12 @@ let asyncHookWrapper = async (_httpRequestId, ret) => ({
 function renderPage_addAsyncHookwrapper(wrapper) {
     asyncHookWrapper = wrapper;
 }
-async function renderPageAndPrepare(pageContextInit, httpRequestId) {
+async function renderPagePrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    if (isVikeConfigInvalid) {
-        if (1 < 2 // Make TS happy
-        ) {
-            return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
-        }
+    if (isVikeConfigInvalid &&
+        true // Make TS happy
+    ) {
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     // Prepare context
     try {
@@ -67,49 +67,52 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+        const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
         return pageContextWithError;
     }
     if (isVikeConfigInvalid) {
-        return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
-    const globalContext = await getGlobalContextInternal();
+    const { globalContext, globalContext_public } = await getGlobalContextServerInternal();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId);
     // Check Base URL
     {
-        const pageContextHttpResponse = await checkBaseUrl(pageContextInit, globalContext);
+        const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
     // Normalize URL
     {
-        const pageContextHttpResponse = await normalizeUrl(pageContextInit, globalContext, httpRequestId);
+        const pageContextHttpResponse = await normalizeUrl(pageContextBegin, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
     // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpResponse = await getPermanentRedirect(pageContextInit, globalContext, httpRequestId);
+        const pageContextHttpResponse = await getPermanentRedirect(pageContextBegin, globalContext, httpRequestId);
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
-    return await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, []);
+    return await renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, []);
 }
-async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, pageContextsFromRewrite) {
+async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
+    const pageContextNominalPageBegin = forkPageContext(pageContextBegin);
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, 
     // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
     0);
     let pageContextNominalPageSuccess;
     const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
-    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
-    objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
+    // This is where pageContext._urlRewrite is set
+    assert(pageContextFromAllRewrites._urlRewrite === null || typeof pageContextFromAllRewrites._urlRewrite === 'string');
+    objectAssign(pageContextNominalPageBegin, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
-            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageInit);
+            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageBegin);
         }
         catch (err) {
             errNominalPage = err;
@@ -117,7 +120,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             logRuntimeError(errNominalPage, httpRequestId);
         }
         if (!errNominalPage) {
-            assert(pageContextNominalPageSuccess === pageContextNominalPageInit);
+            assert(pageContextNominalPageSuccess === pageContextNominalPageBegin);
         }
     }
     // Log upon 404
@@ -133,12 +136,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        assert(pageContextNominalPageInit);
-        assert(hasProp(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPageInit, httpRequestId);
+        assert(pageContextNominalPageBegin);
+        assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if (isAbortError(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -151,7 +154,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
             if (!errorPageId) {
                 objectAssign(pageContextErrorPageInit, { pageId: null });
                 return handleErrorWithoutErrorPage(pageContextErrorPageInit);
@@ -167,12 +170,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if (isAbortError(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext);
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
                 // throw render(abortStatusCode)
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
                     return pageContextHttpWithError;
                 }
                 // `throw redirect()` / `throw render(url)`
@@ -181,7 +184,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             if (isNewError(errErrorPage, errNominalPage)) {
                 logRuntimeError(errErrorPage, httpRequestId);
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
             return pageContextWithError;
         }
         return pageContextErrorPage;
@@ -233,11 +236,26 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
 function prettyUrl(url) {
-    return pc.bold(decodeURI(url));
+    try {
+        url = decodeURI(url);
+    }
+    catch {
+        // https://github.com/vikejs/vike/pull/2367#issuecomment-2800967564
+    }
+    return pc.bold(url);
 }
-function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = createPageContext(pageContextInit, false);
-    const httpResponse = createHttpResponseError(pageContext);
+function getPageContextHttpResponseError(err, pageContextBegin) {
+    const pageContextWithError = forkPageContext(pageContextBegin);
+    const httpResponse = createHttpResponseError(pageContextBegin);
+    objectAssign(pageContextWithError, {
+        httpResponse,
+        errorWhileRendering: err
+    });
+    return pageContextWithError;
+}
+function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit) {
+    const pageContextWithError = createPageContextServerSideWithoutGlobalContext(pageContextInit);
+    const httpResponse = createHttpResponseErrorWithoutGlobalContext();
     objectAssign(pageContextWithError, {
         httpResponse,
         errorWhileRendering: err
@@ -267,8 +285,8 @@ async function renderPageNominal(pageContext) {
     assert(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContext = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
+async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPagePartial) {
+    const pageContext = forkPageContext(pageContextBegin);
     assert(errNominalPage);
     objectAssign(pageContext, {
         is404: false,
@@ -281,17 +299,17 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
     assert(pageContext.errorWhileRendering);
     return pageContext;
 }
-async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
+async function getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, false, {
+    const pageContextBegin = await createPageContextServerSide(pageContextInit, globalContext, globalContext_public, {
+        isPrerendering: false,
         ssr: {
-            urlRewrite,
             urlHandler: _urlHandler,
             isClientSideNavigation
         }
     });
-    objectAssign(pageContextInitEnhanced, { _httpRequestId: httpRequestId });
-    return pageContextInitEnhanced;
+    objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
+    return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
@@ -314,11 +332,12 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
         return;
     assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
-async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
+async function normalizeUrl(pageContextBegin, globalContext, httpRequestId) {
+    const pageContext = forkPageContext(pageContextBegin);
     const { trailingSlash, disableUrlNormalization } = globalContext.config;
     if (disableUrlNormalization)
         return null;
-    const { urlOriginal } = pageContextInit;
+    const { urlOriginal } = pageContext;
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     if (isPageContextRequest)
         return null;
@@ -326,13 +345,13 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit, false);
-    objectAssign(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
-async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
-    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, globalContext.baseServer);
+async function getPermanentRedirect(pageContextBegin, globalContext, httpRequestId) {
+    const pageContext = forkPageContext(pageContextBegin);
+    const urlWithoutBase = removeBaseServer(pageContext.urlOriginal, globalContext.baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
@@ -365,48 +384,45 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
             return null;
         if (!originChanged)
             urlTarget = prependBase(urlTarget, globalContext.baseServer);
-        assert(urlTarget !== pageContextInit.urlOriginal);
+        assert(urlTarget !== pageContext.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit, false);
-    objectAssign(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
 }
 function normalize(url) {
     return url || '/';
 }
-async function handleAbortError(errAbort, pageContextsFromRewrite, 
-// The original `pageContextInit` object passed to `renderPage(pageContextInit)`
-pageContextInit, 
-// handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
-pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
-    logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
+async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextBegin, 
+// handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageBegin to it: we only use some pageContextNominalPageBegin information.
+pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext) {
+    logAbortErrorHandled(errAbort, globalContext._isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
-    if (pageContextNominalPageInit.isClientSideNavigation) {
+    if (pageContextNominalPageBegin.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = createPageContext({}, false);
+            const pageContext = forkPageContext(pageContextBegin);
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
             objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = serializePageContextClientSide(pageContext);
+            pageContextSerialized = getPageContextClientSerialized(pageContext);
         }
         else {
-            pageContextSerialized = serializePageContextAbort(pageContextAbort);
+            pageContextSerialized = getPageContextClientSerializedAbort(pageContextAbort);
         }
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
         const pageContextReturn = { httpResponse };
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRewrite) {
-        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, globalContext, httpRequestId, [
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, [
             ...pageContextsFromRewrite,
             pageContextAbort
         ]);
@@ -414,22 +430,22 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = createPageContext(pageContextInit, false);
+        const pageContextReturn = forkPageContext(pageContextBegin);
         objectAssign(pageContextReturn, pageContextAbort);
-        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextInit);
+        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextBegin);
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-async function checkBaseUrl(pageContextInit, globalContext) {
+async function checkBaseUrl(pageContextBegin, globalContext) {
+    const pageContext = forkPageContext(pageContextBegin);
     const { baseServer } = globalContext;
-    const { urlOriginal } = pageContextInit;
+    const { urlOriginal } = pageContext;
     const { isBaseMissing } = parseUrl(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = createPageContext(pageContextInit, false);
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
@@ -438,20 +454,25 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     checkType(pageContext);
     return pageContext;
 }
-function renderInvalidRequest(pageContextInit) {
+function getPageContextInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = createPageContext(pageContextInit, false);
-        const httpResponse = createHttpResponseFavicon404();
-        objectAssign(pageContext, { httpResponse });
-        checkType(pageContext);
-        return pageContext;
-    }
-    return null;
+    if (!urlPathnameWithBase.endsWith('/favicon.ico'))
+        return;
+    const pageContext = createPageContextServerSideWithoutGlobalContext(pageContextInit);
+    const httpResponse = createHttpResponseFavicon404();
+    objectAssign(pageContext, { httpResponse });
+    checkType(pageContext);
+    return pageContext;
 }
-function renderInvalidVikeConfig(err, pageContextInit, httpRequestId) {
+function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
     logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-    const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+    const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
     return pageContextWithError;
 }
+// Create pageContext forks to avoid leaks: upon an error (bug or abort) a brand new pageContext object is created, in order to avoid previous pageContext modifications that are now obsolete to leak to the new pageContext object.
+function forkPageContext(pageContextBegin) {
+    const pageContext = {};
+    objectAssign(pageContext, pageContextBegin, true);
+    return pageContext;
+}

package/dist/esm/node/runtime/universal-middleware.js

@@ -1,6 +1,12 @@
 import { renderPage } from './index.js';
 export default async function universalVikeHandler(request, context, runtime) {
-    const pageContextInit = { ...context, ...runtime, urlOriginal: request.url, headersOriginal: request.headers };
+    const pageContextInit = {
+        ...context,
+        ...runtime,
+        runtime,
+        urlOriginal: request.url,
+        headersOriginal: request.headers
+    };
     const pageContext = await renderPage(pageContextInit);
     const response = pageContext.httpResponse;
     const readable = response.getReadableWebStream();

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

@@ -30,7 +30,7 @@ export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/freezePartial.js';
-export * from '../../utils/isNpmPackage.js';
+export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
@@ -54,4 +54,5 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/getPublicProxy.js';
+export * from '../../utils/augmentType.js';

package/dist/esm/node/runtime/utils.js

@@ -34,7 +34,7 @@ export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/freezePartial.js';
-export * from '../../utils/isNpmPackage.js';
+export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
@@ -58,4 +58,5 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
-export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/getPublicProxy.js';
+export * from '../../utils/augmentType.js';