vike 0.4.228 → 0.4.229

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

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

@@ -50,7 +50,7 @@ __exportStar(require("../../utils/debug.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/freezePartial.js"), exports);
-__exportStar(require("../../utils/isNpmPackage.js"), exports);
+__exportStar(require("../../utils/parseNpmPackage.js"), exports);
 __exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/isScriptFile.js"), exports);
 __exportStar(require("../../utils/removeFileExtention.js"), exports);
@@ -74,4 +74,5 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
-__exportStar(require("../../utils/makePublicCopy.js"), exports);
+__exportStar(require("../../utils/getPublicProxy.js"), exports);
+__exportStar(require("../../utils/augmentType.js"), exports);

package/dist/cjs/shared/assertPageContextProvidedByUser.js

@@ -12,7 +12,7 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     (0, utils_js_1.assert)(!hookName.endsWith(')'));
     const errPrefix = `The ${picocolors_1.default.cyan('pageContext')} object provided by the ${hookName}() hook defined by ${hookFilePath}`;
     (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(pageContextProvidedByUser), `${errPrefix} should be an object (but it's ${picocolors_1.default.cyan(`typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`)} instead)`);
-    (0, utils_js_1.assertUsage)(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
+    (0, utils_js_1.assertUsage)(!('isPageContext' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
     (0, utils_js_1.assertWarning)(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext.pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });

package/dist/cjs/shared/createGlobalContextShared.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalContextSyncErrMsg = void 0;
+exports.createGlobalContextShared = createGlobalContextShared;
+const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
+const getPageConfigsRuntime_js_1 = require("./getPageConfigsRuntime.js");
+const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
+const utils_js_1 = require("./utils.js");
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+    const globalContext = createGlobalContextBase(virtualFileExports);
+    const globalContextAddendum = await addGlobalContext?.(globalContext);
+    (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+    if (!globalObject.globalContext) {
+        globalObject.globalContext = globalContext;
+        // - We deliberately call onCreateGlobalContext() only at the beginning and only once per process.
+        // - TO-DO/eventually: HMR
+        //    - Once Photon supports it: `server.hot.send({ type: 'full-server-reload' })`
+        //    - Either use:
+        //      - import.meta.hot
+        //        - https://vite.dev/guide/api-hmr.html
+        //        - Use a Vite transformer to inject import.meta.hot code into each user-land `+onCreateGlobalContext.js` file
+        //        - Seems more idiomatic
+        //      - globalContext._viteDevServer.hot.send()
+        //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
+        //        - Seems less idiomatic
+        await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+    }
+    else {
+        // Singleton: ensure all `globalContext` user-land references are preserved & updated.
+        // We don't use objectReplace() in order to keep user-land properties.
+        (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext);
+    }
+    return globalObject.globalContext;
+}
+function createGlobalContextBase(virtualFileExports) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
+    const globalContext = {
+        /**
+         * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+         *
+         * https://vike.dev/globalContext#typescript
+         */
+        isGlobalContext: true,
+        _virtualFileExports: virtualFileExports,
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        config: globalConfig.config,
+        pages: pageConfigsUserFriendly
+    };
+    return globalContext;
+}

package/dist/cjs/shared/createPageContextShared.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageContextShared = createPageContextShared;
+const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
+const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
+const utils_js_1 = require("./utils.js");
+async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
+    const pageConfigGlobalUserFriendly = (0, getPageConfigUserFriendly_js_1.getPageConfigGlobalUserFriendly)({
+        pageConfigGlobalValues: pageConfigGlobal.configValues
+    });
+    (0, utils_js_1.objectAssign)(pageContextCreated, {
+        isPageContext: true,
+        ...pageConfigGlobalUserFriendly
+    }, true);
+    await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+    return pageContextCreated;
+}

package/dist/cjs/shared/getPageFiles/fileTypes.js

@@ -25,7 +25,7 @@ function determineFileType(filePath) {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {
             /* This assert() is skipped to reduce client-side bundle size
-            assert(isNpmPackageImport(filePath), filePath) // `.css` page files are only supported for npm packages
+            assert(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

package/dist/cjs/shared/hooks/executeHookGeneric.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHookGeneric = executeHookGeneric;
+exports.executeHookGenericGlobalCumulative = executeHookGenericGlobalCumulative;
+const executeHook_js_1 = require("./executeHook.js");
+const getHook_js_1 = require("./getHook.js");
+async function executeHookGeneric(hookName, pageContext) {
+    const hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, hookName);
+    if (!hook)
+        return;
+    await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, pageContext);
+}
+async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
+    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
+    await Promise.all(hooks.map(async (hook) => {
+        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(arg), hook, pageContext);
+    }));
+}