vike 0.4.228 → 0.4.229-commit-2a06dcc

package/dist/cjs/node/runtime/renderPage/getPageAssets/retrieveAssetsDev.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrieveAssetsDev = retrieveAssetsDev;
 const utils_js_1 = require("../../utils.js");
 async function retrieveAssetsDev(clientDependencies, viteDevServer) {
-    const visitedModules = new Set();
     const assetUrls = new Set();
     await Promise.all(clientDependencies.map(async ({ id }) => {
         if (id.startsWith('@@vike'))
@@ -22,7 +21,7 @@ async function retrieveAssetsDev(clientDependencies, viteDevServer) {
             return;
         }
         (0, utils_js_1.assert)(mod, { id });
-        collectCss(mod, assetUrls, visitedModules);
+        collectCss(mod, assetUrls, new Set());
     }));
     return Array.from(assetUrls);
 }
@@ -52,9 +51,6 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
             // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
             styleUrls.add(`/@id/${mod.url}`);
         }
-        /* Debug:
-        logModule(mod)
-        //*/
     }
     mod.importedModules.forEach((dep) => {
         collectCss(dep, styleUrls, visitedModules, mod);
@@ -69,15 +65,3 @@ function isStyle(mod) {
         // CSS of .vue files
         (mod.id && /\?vue&type=style/.test(mod.id)));
 }
-/*
-function logModule(mod: ModuleNode) {
-  const redacted = 'redacted'
-  console.log({
-    ...mod,
-    ssrModule: redacted,
-    ssrTransformResult: redacted,
-    importedModules: redacted,
-    importers: redacted
-  })
-}
-//*/

package/dist/cjs/node/runtime/renderPage/getPageAssets/retrieveAssetsProd.js

@@ -16,7 +16,7 @@ function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImp
             onlyAssets &&
             id.includes('.page.server.') &&
             // We assume that all npm packages have already built their files: bundlers (Rollup, esbuild, tsup, ...) extract the CSS out of JavaScript => we can assume JavaScript to not import any CSS/assets.
-            !(0, utils_js_1.isNpmPackageImport)(id, {
+            !(0, utils_js_1.isImportPathNpmPackage)(id, {
                 // I presume Vite already resolves path aliases when Vite sets the module's id
                 cannotBePathAlias: true
             })) {

package/dist/cjs/node/runtime/renderPage/getPageAssets.js

@@ -13,12 +13,12 @@ const globalObject = (0, utils_js_1.getGlobalObject)('renderPage/getPageAssets.t
 });
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
-    const { isProduction } = globalContext;
+    const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
     let assetUrls;
     let clientEntriesSrc;
     if (isDev) {
-        const { viteDevServer } = globalContext;
+        const { _viteDevServer: viteDevServer } = globalContext;
         clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer)));
         assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
     }

package/dist/cjs/node/runtime/renderPage/handleErrorWithoutErrorPage.js

@@ -14,7 +14,7 @@ async function handleErrorWithoutErrorPage(pageContext) {
     (0, utils_js_1.assert)(pageContext.errorWhileRendering || pageContext.is404);
     {
         const isV1 = pageContext._pageConfigs.length > 0;
-        await warnMissingErrorPage(isV1, pageContext._globalContext.isProduction);
+        await warnMissingErrorPage(isV1, pageContext._globalContext._isProduction);
     }
     if (!pageContext.isClientSideNavigation) {
         const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);

package/dist/cjs/node/runtime/renderPage/loadUserFilesServerSide.js

@@ -14,7 +14,7 @@ async function loadUserFilesServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, globalContext.pageConfigGlobal, pageContext.pageId, !globalContext.isProduction),
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, globalContext._pageConfigGlobal, pageContext.pageId, !globalContext._isProduction),
         (0, analyzePageClientSide_js_1.analyzePageClientSideInit)(pageContext._pageFilesAll, pageContext.pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await (0, analyzePage_js_1.analyzePage)(pageContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);

package/dist/cjs/node/runtime/renderPage/log404/index.js

@@ -17,7 +17,7 @@ async function log404(pageContext) {
     */
     );
     const globalContext = pageContext._globalContext;
-    if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
+    if (!globalContext._isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
         const routesInfo = getRoutesInfo(pageRoutes);
         let msg = `URL ${picocolors_1.default.cyan(urlPathname)} ${noRouteMatch_js_1.noRouteMatch}`;
         const outro = 'See https://vike.dev/routing for more information about routing.';

package/dist/cjs/node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.js

@@ -9,7 +9,7 @@ function preparePageContextForUserConsumptionServerSide(pageContext) {
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.routeParams));
     (0, utils_js_1.assert)('Page' in pageContext);
     (0, utils_js_1.assert)(typeof pageContext.isClientSideNavigation === 'boolean');
-    (0, utils_js_1.assert)(pageContext._isPageContextObject);
+    (0, utils_js_1.assert)(pageContext.isPageContext);
     (0, utils_js_1.assert)(pageContext.isClientSide === false);
     (0, utils_js_1.assert)(typeof pageContext.isPrerendering === 'boolean');
     (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -5,13 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
-exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
-exports.createPageContext = createPageContext;
 const error_page_js_1 = require("../../../shared/error-page.js");
 const renderHtml_js_1 = require("../html/renderHtml.js");
 const utils_js_1 = require("../utils.js");
-const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
-const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
+const serializeContext_js_1 = require("../html/serializeContext.js");
 const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const loadUserFilesServerSide_js_1 = require("./loadUserFilesServerSide.js");
 const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
@@ -50,7 +47,7 @@ async function renderPageAlreadyRouted(pageContext) {
         if (isError) {
             (0, utils_js_1.objectAssign)(pageContext, { [isServerSideError_js_1.isServerSideError]: true });
         }
-        const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
@@ -80,69 +77,7 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized: null, pageContext };
     }
     else {
-        const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }
-async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
-    urlRewrite: null,
-    urlHandler: null,
-    isClientSideNavigation: false
-} } = {}) {
-    (0, utils_js_1.assert)(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, {
-        _objectCreatedByVike: true,
-        // The following is defined on `pageContext` because we can eventually make these non-global
-        _baseServer: globalContext.baseServer,
-        _baseAssets: globalContext.baseAssets,
-        // TODO/now: add meta.default
-        _includeAssetsImportedByServer: globalContext.config.includeAssetsImportedByServer ?? true,
-        // TODO/soon: use GloablContext instead
-        _pageFilesAll: globalContext.pageFilesAll,
-        _pageConfigs: globalContext.pageConfigs,
-        _pageConfigGlobal: globalContext.pageConfigGlobal,
-        _allPageIds: globalContext.allPageIds,
-        _pageRoutes: globalContext.pageRoutes,
-        _onBeforeRouteHook: globalContext.onBeforeRouteHook,
-        _globalContext: globalContext,
-        // TODO/now: add PageContext['globalContext']
-        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: globalContext.globalContext_public,
-        _pageContextInit: pageContextInit,
-        _urlRewrite: urlRewrite,
-        _urlHandler: urlHandler,
-        isClientSideNavigation
-    });
-    // pageContext.urlParsed
-    const pageContextUrlComputed = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContextInitEnhanced);
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextUrlComputed);
-    // pageContext.headers
-    {
-        let headers;
-        if (pageContextInit.headersOriginal) {
-            headers = (0, utils_js_1.normalizeHeaders)(pageContextInit.headersOriginal);
-            (0, utils_js_1.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;
-            // TODO/next-major-release: assertUsage() instead of assertWarning()
-            (0, utils_js_1.assertWarning)(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
-        }
-        else {
-            headers = null;
-        }
-        (0, utils_js_1.objectAssign)(pageContextInitEnhanced, { headers });
-    }
-    return pageContextInitEnhanced;
-}
-function createPageContext(pageContextInit, isPrerendering) {
-    const pageContext = {
-        _isPageContextObject: true,
-        isClientSide: false,
-        isPrerendering
-    };
-    (0, utils_js_1.objectAssign)(pageContext, pageContextInit);
-    return pageContext;
-}

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPage = renderPage;
 exports.renderPage_addAsyncHookwrapper = renderPage_addAsyncHookwrapper;
 const renderPageAlreadyRouted_js_1 = require("./renderPage/renderPageAlreadyRouted.js");
+const createPageContextServerSide_js_1 = require("./renderPage/createPageContextServerSide.js");
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
 const abort_js_1 = require("../../shared/route/abort.js");
@@ -18,7 +19,7 @@ const assertArguments_js_1 = require("./renderPage/assertArguments.js");
 const index_js_2 = require("./renderPage/log404/index.js");
 const isVikeConfigInvalid_js_1 = require("./renderPage/isVikeConfigInvalid.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const serializePageContextClientSide_js_1 = require("./html/serializePageContextClientSide.js");
+const serializeContext_js_1 = require("./html/serializeContext.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
 const loadUserFilesServerSide_js_1 = require("./renderPage/loadUserFilesServerSide.js");
@@ -32,13 +33,13 @@ async function renderPage(pageContextInit) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertIsUrl(pageContextInit.urlOriginal);
     (0, utils_js_1.onSetupRuntime)();
-    const pageContextInvalidRequest = renderInvalidRequest(pageContextInit);
+    const pageContextInvalidRequest = getPageContextInvalidRequest(pageContextInit);
     if (pageContextInvalidRequest)
         return pageContextInvalidRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = (0, utils_js_1.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);
     (0, utils_js_1.checkType)(pageContextReturn);
     (0, utils_js_1.assert)(pageContextReturn.httpResponse);
@@ -52,13 +53,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_js_1.isVikeConfigInvalid) {
-        if (1 < 2 // Make TS happy
-        ) {
-            return renderInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
-        }
+    if (isVikeConfigInvalid_js_1.isVikeConfigInvalid &&
+        true // Make TS happy
+    ) {
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     // Prepare context
     try {
@@ -72,49 +72,52 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+        const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
         return pageContextWithError;
     }
     if (isVikeConfigInvalid_js_1.isVikeConfigInvalid) {
-        return renderInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
+        return getPageContextInvalidVikeConfig(isVikeConfigInvalid_js_1.isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
-    const globalContext = await (0, globalContext_js_1.getGlobalContextInternal)();
+    const { globalContext, globalContext_public } = await (0, globalContext_js_1.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);
     (0, abort_js_1.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 = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
-    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
-    (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
+    // This is where pageContext._urlRewrite is set
+    (0, utils_js_1.assert)(pageContextFromAllRewrites._urlRewrite === null || typeof pageContextFromAllRewrites._urlRewrite === 'string');
+    (0, utils_js_1.objectAssign)(pageContextNominalPageBegin, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
-            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageInit);
+            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageBegin);
         }
         catch (err) {
             errNominalPage = err;
@@ -122,7 +125,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             (0, loggerRuntime_js_1.logRuntimeError)(errNominalPage, httpRequestId);
         }
         if (!errNominalPage) {
-            (0, utils_js_1.assert)(pageContextNominalPageSuccess === pageContextNominalPageInit);
+            (0, utils_js_1.assert)(pageContextNominalPageSuccess === pageContextNominalPageBegin);
         }
     }
     // Log upon 404
@@ -138,12 +141,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     else {
         (0, utils_js_1.assert)(errNominalPage);
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
-        (0, utils_js_1.assert)(pageContextNominalPageInit);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPageInit, httpRequestId);
+        (0, utils_js_1.assert)(pageContextNominalPageBegin);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if ((0, abort_js_1.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)
@@ -156,7 +159,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
             if (!errorPageId) {
                 (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
                 return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
@@ -172,12 +175,12 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if ((0, abort_js_1.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;
                     (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.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)`
@@ -186,7 +189,7 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
             if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
                 (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextInit, pageContextErrorPageInit);
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
             return pageContextWithError;
         }
         return pageContextErrorPage;
@@ -238,11 +241,26 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
 function prettyUrl(url) {
-    return picocolors_1.default.bold(decodeURI(url));
+    try {
+        url = decodeURI(url);
+    }
+    catch {
+        // https://github.com/vikejs/vike/pull/2367#issuecomment-2800967564
+    }
+    return picocolors_1.default.bold(url);
 }
-function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
+function getPageContextHttpResponseError(err, pageContextBegin) {
+    const pageContextWithError = forkPageContext(pageContextBegin);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContextBegin);
+    (0, utils_js_1.objectAssign)(pageContextWithError, {
+        httpResponse,
+        errorWhileRendering: err
+    });
+    return pageContextWithError;
+}
+function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit) {
+    const pageContextWithError = (0, createPageContextServerSide_js_1.createPageContextServerSideWithoutGlobalContext)(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseErrorWithoutGlobalContext)();
     (0, utils_js_1.objectAssign)(pageContextWithError, {
         httpResponse,
         errorWhileRendering: err
@@ -272,8 +290,8 @@ async function renderPageNominal(pageContext) {
     (0, utils_js_1.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);
     (0, utils_js_1.assert)(errNominalPage);
     (0, utils_js_1.objectAssign)(pageContext, {
         is404: false,
@@ -286,17 +304,17 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
     (0, utils_js_1.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 (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, false, {
+    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, globalContext_public, {
+        isPrerendering: false,
         ssr: {
-            urlRewrite,
             urlHandler: _urlHandler,
             isClientSideNavigation
         }
     });
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, { _httpRequestId: httpRequestId });
-    return pageContextInitEnhanced;
+    (0, utils_js_1.objectAssign)(pageContextBegin, { _httpRequestId: httpRequestId });
+    return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
@@ -319,11 +337,12 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
         return;
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.code('renderPage(pageContextInit)')} called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${picocolors_1.default.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${picocolors_1.default.cyan('createDevMiddleware()')} middleware is executed *before* the ${picocolors_1.default.cyan('renderPage()')} middleware, see ${picocolors_1.default.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 } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     if (isPageContextRequest)
         return null;
@@ -331,13 +350,13 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-    (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlNormalized, statusCode: 301 }, pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+    return pageContext;
 }
-async function getPermanentRedirect(pageContextInit, globalContext, httpRequestId) {
-    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, globalContext.baseServer);
+async function getPermanentRedirect(pageContextBegin, globalContext, httpRequestId) {
+    const pageContext = forkPageContext(pageContextBegin);
+    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContext.urlOriginal, globalContext.baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
@@ -370,48 +389,45 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
             return null;
         if (!originChanged)
             urlTarget = (0, utils_js_1.prependBase)(urlTarget, globalContext.baseServer);
-        (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
+        (0, utils_js_1.assert)(urlTarget !== pageContext.urlOriginal);
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-    (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
-    return pageContextHttpResponse;
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, pageContext);
+    (0, utils_js_1.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) {
-    (0, abort_js_1.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) {
+    (0, abort_js_1.logAbortErrorHandled)(errAbort, globalContext._isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
-    if (pageContextNominalPageInit.isClientSideNavigation) {
+    if (pageContextNominalPageBegin.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             (0, utils_js_1.assert)(abortCall);
             (0, utils_js_1.assertUsage)(errorPageId, `You called ${picocolors_1.default.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)({}, false);
+            const pageContext = forkPageContext(pageContextBegin);
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
             (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         }
         else {
-            pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextAbort)(pageContextAbort);
+            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerializedAbort)(pageContextAbort);
         }
         const httpResponse = await (0, createHttpResponse_js_1.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
         ]);
@@ -419,22 +435,22 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
+        const pageContextReturn = forkPageContext(pageContextBegin);
         (0, utils_js_1.objectAssign)(pageContextReturn, pageContextAbort);
-        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, pageContextInit);
+        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, pageContextBegin);
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     (0, utils_js_1.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 } = (0, utils_js_1.parseUrl)(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseBaseIsMissing)(urlOriginal, baseServer);
     (0, utils_js_1.objectAssign)(pageContext, {
         httpResponse,
@@ -443,20 +459,25 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     (0, utils_js_1.checkType)(pageContext);
     return pageContext;
 }
-function renderInvalidRequest(pageContextInit) {
+function getPageContextInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
-        const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
-        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
-        (0, utils_js_1.checkType)(pageContext);
-        return pageContext;
-    }
-    return null;
+    if (!urlPathnameWithBase.endsWith('/favicon.ico'))
+        return;
+    const pageContext = (0, createPageContextServerSide_js_1.createPageContextServerSideWithoutGlobalContext)(pageContextInit);
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
+    (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+    (0, utils_js_1.checkType)(pageContext);
+    return pageContext;
 }
-function renderInvalidVikeConfig(err, pageContextInit, httpRequestId) {
+function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.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 = {};
+    (0, utils_js_1.objectAssign)(pageContext, pageContextBegin, true);
+    return pageContext;
+}

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

@@ -3,7 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = universalVikeHandler;
 const index_js_1 = require("./index.js");
 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 (0, index_js_1.renderPage)(pageContextInit);
     const response = pageContext.httpResponse;
     const readable = response.getReadableWebStream();