vike 0.4.225 → 0.4.226-commit-8f5c172

package/dist/cjs/node/prerender/runPrerender.js

@@ -76,8 +76,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
@@ -88,11 +88,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
     (0, utils_js_1.assert)(false);
 }
-async function runPrerenderFromAutoRun(viteConfig, config) {
-    let prerenderContextPublic;
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
-        const ret = await runPrerender({ viteConfig });
-        prerenderContextPublic = ret.prerenderContextPublic;
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -100,8 +98,6 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
-    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(config);
-    vike.prerenderContext = prerenderContextPublic;
     const forceExit = (0, context_js_2.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
     return { forceExit };
 }
@@ -118,6 +114,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
+    const vike = (0, commonConfig_js_1.getVikeConfigPublic)(viteConfig);
+    (0, utils_js_1.assert)(vike.prerenderContext.isPrerenderingEnabled);
     const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
@@ -161,7 +159,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
-    return { viteConfig, prerenderContextPublic };
+    (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic);
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
@@ -342,20 +341,16 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
     })));
 }
 async function createPageContext(urlOriginal, prerenderContext, globalContext) {
-    const pageContext = {
+    const pageContextInit = { urlOriginal };
+    (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
+    const pageContext = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, true, {});
+    (0, utils_js_1.assert)(pageContext.isPrerendering === true);
+    (0, utils_js_1.objectAssign)(pageContext, {
         _urlHandler: null,
         _urlRewrite: null,
         _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
-    };
-    const pageContextInit = {
-        urlOriginal
-    };
-    (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
-    {
-        const pageContextInitEnhanced = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext);
-        (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
-    }
+    });
     return pageContext;
 }
 async function callOnPrerenderStartHook(prerenderContext, globalContext) {
@@ -634,6 +629,12 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    (0, utils_js_1.objectAssign)(pageContext, {
+        _prerenderResult: {
+            filePath,
+            fileContent
+        }
+    });
     output.push({
         filePath,
         fileType,
@@ -641,15 +642,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
         pageContext
     });
     if (onPagePrerender) {
-        const prerenderPageContext = {};
-        (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
-        (0, utils_js_1.objectAssign)(prerenderPageContext, {
-            _prerenderResult: {
-                filePath,
-                fileContent
-            }
-        });
-        await onPagePrerender(prerenderPageContext);
+        await onPagePrerender(pageContext);
     }
     else {
         const { promises } = await Promise.resolve().then(() => __importStar(require('fs')));

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

@@ -33,4 +33,4 @@ __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
 __exportStar(require("../../utils/makePublicCopy.js"), exports);
-__exportStar(require("../../utils/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isNullish.js"), exports);

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

@@ -67,6 +67,7 @@ function getGlobalContextSync() {
 }
 /** @experimental https://vike.dev/getGlobalContext */
 async function getGlobalContextAsync(isProduction) {
+    debug('getGlobalContextAsync()');
     (0, utils_js_1.assertUsage)(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${picocolors_1.default.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${picocolors_1.default.cyan('true')} or ${picocolors_1.default.cyan('false')}`}`);
     setIsProduction(isProduction);
     if (!globalObject.globalContext)
@@ -92,10 +93,10 @@ function makePublic(globalContext) {
 async function setGlobalContext_viteDevServer(viteDevServer) {
     debug('setGlobalContext_viteDevServer()');
     setIsProduction(false);
-    /* We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
-    if (globalObject.viteDevServer) return
-    assertIsNotInitilizedYet()
-    */
+    // We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
+    if (!globalObject.viteDevServer) {
+        assertIsNotInitilizedYet();
+    }
     (0, utils_js_1.assert)(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     await updateUserFiles();
@@ -311,10 +312,14 @@ async function loadBuildEntry(outDir) {
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         (0, utils_js_1.assert)(globalObject.buildEntry);
-        (0, utils_js_1.assertWarning)(!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject, 
-        // TODO/soon: show precise path
-        // TODO/soon: make this warning work on test/vike-node/
-        `Run the server production build (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of running the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
+        (0, utils_js_1.assertWarning)(
+        // vike-server => `vitePluginServerEntry.inject === true`
+        // vike-node => `vitePluginServerEntry.inject === [ 'index' ]`
+        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true, 
+        /* TO-DO/eventually:
+        !!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject,
+        */
+        `Run the built server entry (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScript.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getViteDevScript = getViteDevScript;
 const utils_js_1 = require("../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
     const globalContext = pageContext._globalContext;
     if (globalContext.isProduction) {
@@ -17,11 +18,13 @@ async function getViteDevScript(pageContext) {
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
     fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
     (0, utils_js_1.assertUsage)(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${picocolors_1.default.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
-    (0, utils_js_1.assertUsage)(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), 'Vite plugins that minify the HTML are not supported by vike, see https://github.com/vikejs/vike/issues/224');
-    (0, utils_js_1.assertUsage)(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), 'You are using a Vite Plugin that transforms the HTML in a way that conflicts with vike. Create a new GitHub ticket to discuss a solution.');
+    (0, utils_js_1.assertUsage)(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), `Vite plugins that minify the HTML cannot be applied, see https://github.com/vikejs/vike/issues/224`);
+    (0, utils_js_1.assertUsage)(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), `You are using a Vite Plugin that transforms the HTML in a way that conflicts with Vike. ${reachOutCTA}`);
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
     (0, utils_js_1.assert)(viteInjection.includes('script'));
-    (0, utils_js_1.assertWarning)(!viteInjection.includes('import('), 'Unexpected Vite HMR code. Reach out to a Vike maintainer on GitHub.', { onlyOnce: true });
+    (0, utils_js_1.assertWarning)(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
+        onlyOnce: true
+    });
     const viteDevScript = viteInjection;
     return viteDevScript;
 }

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -5,12 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializePageContextClientSide = serializePageContextClientSide;
 exports.serializePageContextAbort = serializePageContextAbort;
+exports.getPropKeys = getPropKeys;
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const utils_js_1 = require("../utils.js");
 const error_page_js_1 = require("../../../shared/error-page.js");
 const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const notSerializable_js_1 = require("../../../shared/notSerializable.js");
+const NOT_SERIALIZABLE_js_1 = require("../../../shared/NOT_SERIALIZABLE.js");
 const pageContextInitIsPassedToClient_js_1 = require("../../../shared/misc/pageContextInitIsPassedToClient.js");
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 const PASS_TO_CLIENT = [
@@ -30,12 +31,8 @@ const PASS_TO_CLIENT = [
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
-    const pageContextClient = {};
-    passToClient.forEach((prop) => {
-        // We set non-existing props to `undefined`, in order to pass the list of passToClient values to the client-side
-        pageContextClient[prop] = pageContext[prop];
-    });
-    if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
+    const pageContextClient = applyPassToClient(passToClient, pageContext);
+    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient] = true;
     }
     let pageContextSerialized;
@@ -47,14 +44,15 @@ function serializePageContextClientSide(pageContext) {
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const propName1 = (0, utils_js_1.getPropAccessNotation)(prop);
-            const propName2 = JSON.stringify(prop);
-            const varName = `pageContext${propName1}`;
+            const res = getPropVal(pageContext, prop);
+            if (!res)
+                return;
+            const { value } = res;
+            const varName = `pageContext${getPropKeys(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
             try {
-                serialize(pageContext[prop], varName);
+                serialize(value, varName);
             }
             catch (err) {
-                hasWarned = true;
                 propsNonSerializable.push(prop);
                 // useConfig() wrong usage
                 if (prop === '_configFromHook') {
@@ -67,7 +65,7 @@ function serializePageContextClientSide(pageContext) {
                 // Non-serializable pageContext set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
-                    `Make sure ${h(varName)} is serializable, or remove ${h(propName2)} from ${h('passToClient')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
                 ].join(' ');
                 if ((0, stringify_1.isJsonSerializerError)(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -80,11 +78,12 @@ function serializePageContextClientSide(pageContext) {
                 }
                 // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
                 (0, utils_js_1.assertWarning)(false, msg, { onlyOnce: false });
+                hasWarned = true;
             }
         });
         (0, utils_js_1.assert)(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[prop] = notSerializable_js_1.notSerializable;
+            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
         });
         try {
             pageContextSerialized = serialize(pageContextClient);
@@ -143,3 +142,57 @@ function serializePageContextAbort(pageContext) {
     }
     return serialize(pageContext);
 }
+function applyPassToClient(passToClient, pageContext) {
+    const pageContextClient = {};
+    passToClient.forEach((prop) => {
+        // Get value from pageContext
+        const res = getPropVal(pageContext, prop);
+        if (!res)
+            return;
+        const { value } = res;
+        // Set value to pageContextClient
+        setPropVal(pageContextClient, prop, value);
+    });
+    return pageContextClient;
+}
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if ((0, utils_js_1.isObject)(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!(0, utils_js_1.isObject)(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see serializePageContextClientSide.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

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

@@ -9,14 +9,15 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalObject = (0, utils_js_1.getGlobalObject)('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-// It's too strict, see https://github.com/vikejs/vike/issues/1270#issuecomment-1820608999
-// - Let's create a new setting `+doNotCatchInfiniteRedirect` if someone complains.
 function assertNoInfiniteHttpRedirect(
 // The exact URL that the user will be redirected to.
 // - It includes the Base URL as well as the locale (i18n) base.
 urlRedirectTarget, 
 // Rationale for checking against `pageContextInit.urlOriginal`: https://github.com/vikejs/vike/pull/2264#issuecomment-2713890263
 pageContextInit) {
+    // TO-DO/eventually: use cookie as described at https://github.com/vikejs/vike/pull/2273
+    if (true)
+        return 'DISABLED'; // Disabled until we make it reliable.
     if (!urlRedirectTarget.startsWith('/')) {
         // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (at least not in itself).
         //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin; we hope/assume the user sets the URL without origin.

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

@@ -9,5 +9,8 @@ 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.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

@@ -7,6 +7,7 @@ exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
 exports.prerender404Page = prerender404Page;
 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");
@@ -89,7 +90,11 @@ async function prerender404Page(pageContextInit_, globalContext) {
     if (!errorPageId) {
         return null;
     }
-    const pageContext = {
+    // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
+    const pageContextInit = { urlOriginal: '/fake-404-url' };
+    (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    (0, utils_js_1.objectAssign)(pageContext, {
         pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
@@ -98,25 +103,17 @@ async function prerender404Page(pageContextInit_, globalContext) {
         // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
         _usesClientRouter: false,
         _debugRouteMatches: []
-    };
-    const pageContextInit = {
-        urlOriginal: '/fake-404-url' // A URL is needed for `applyViteHtmlTransform`
-    };
-    (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
-    }
+    });
     (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
     return prerenderPage(pageContext);
 }
-async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+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 = {};
+    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
@@ -163,3 +160,12 @@ async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr:
     }
     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

@@ -108,15 +108,9 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
     0);
     let pageContextNominalPageSuccess;
-    let pageContextNominalPageInit = {};
-    {
-        const pageContextFromAllRewrites = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
-        (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
-    }
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
-        (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextInitEnhanced);
-    }
+    const pageContextFromAllRewrites = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
+    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
+    (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
@@ -247,7 +241,7 @@ function prettyUrl(url) {
     return picocolors_1.default.bold(decodeURI(url));
 }
 function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = createPageContext(pageContextInit);
+    const pageContextWithError = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
     (0, utils_js_1.objectAssign)(pageContextWithError, {
         httpResponse,
@@ -255,13 +249,6 @@ function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     });
     return pageContextWithError;
 }
-function createPageContext(pageContextInit) {
-    const pageContext = {
-        _isPageContextObject: true
-    };
-    Object.assign(pageContext, pageContextInit);
-    return pageContext;
-}
 async function renderPageNominal(pageContext) {
     (0, utils_js_1.objectAssign)(pageContext, { errorWhileRendering: null });
     // Route
@@ -286,10 +273,8 @@ async function renderPageNominal(pageContext) {
     return pageContextAfterRender;
 }
 async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
+    const pageContext = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
     (0, utils_js_1.assert)(errNominalPage);
-    const pageContext = {};
-    (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     (0, utils_js_1.objectAssign)(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
@@ -303,7 +288,7 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
 }
 async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, {
+    const pageContextInitEnhanced = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, false, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -347,7 +332,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
         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 = createPageContext(pageContextInit);
+    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -389,7 +374,7 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
     }
     (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 = createPageContext(pageContextInit);
+    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -410,10 +395,10 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
             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 = createPageContext({});
+            const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)({}, false);
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
-            (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit);
+            (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);
@@ -434,7 +419,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = createPageContext(pageContextInit);
+        const pageContextReturn = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
         (0, utils_js_1.objectAssign)(pageContextReturn, pageContextAbort);
         const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, pageContextInit);
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
@@ -449,7 +434,7 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     const { isBaseMissing } = (0, utils_js_1.parseUrl)(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = createPageContext(pageContextInit);
+    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,
@@ -462,7 +447,7 @@ function renderInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
     if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = createPageContext(pageContextInit);
+        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);

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

@@ -51,7 +51,7 @@ __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/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/isScriptFile.js"), exports);
 __exportStar(require("../../utils/removeFileExtention.js"), exports);
 __exportStar(require("../../utils/objectKeys.js"), exports);

package/dist/cjs/node/runtime-dev/createDevMiddleware.js

@@ -22,8 +22,8 @@ async function createDevMiddleware(options = {}) {
             }
         }
     };
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(optionsMod, 'dev');
-    const server = await (0, vite_1.createServer)(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(optionsMod, 'dev');
+    const server = await (0, vite_1.createServer)(viteConfigFromUserEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

package/dist/cjs/node/shared/assertV1Design.js

@@ -12,7 +12,7 @@ function assertV1Design(pageConfigs, pageFilesAll) {
             (0, utils_js_1.assert)(pageConfigs.length > 0);
             const filesV1 = (0, utils_js_1.unique)(pageConfigs
                 .map((p) => Object.values(p.configValueSources).map((sources) => sources
-                .map((c) => c.definedAtFilePath)
+                .map((c) => c.definedAt)
                 .map((definedAt) => (definedAt.definedBy ? null : definedAt.filePathAbsoluteUserRootDir))
                 .filter(utils_js_1.isNotNullish)
                 .map((filePathToShowToUser) => indent + filePathToShowToUser)))

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

@@ -28,6 +28,6 @@ __exportStar(require("../../utils/parseUrl.js"), exports);
 __exportStar(require("../../utils/parseUrl-extras.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/assertIsNotBrowser.js"), exports);
-__exportStar(require("../../utils/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/unique.js"), exports);
 __exportStar(require("../../utils/debug.js"), exports);

package/dist/cjs/node/shared/virtual-files.js

@@ -6,32 +6,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isVirtualFileId = isVirtualFileId;
 exports.getVirtualFileId = getVirtualFileId;
 exports.resolveVirtualFileId = resolveVirtualFileId;
+exports.removeVirtualIdTag = removeVirtualIdTag;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("./utils.js");
 const idBase = 'virtual:vike:';
 // https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
-const tag = '\0';
+const virtualIdTag = '\0';
 function isVirtualFileId(id) {
     if (id.startsWith(idBase))
         return true;
-    if (id.startsWith(tag + idBase))
+    if (id.startsWith(virtualIdTag + idBase))
         return true;
     // https://github.com/vikejs/vike/issues/1985
     (0, utils_js_1.assertUsage)(!id.includes(idBase), `Encountered a module ID ${picocolors_1.default.cyan(id)} that is unexpected. Are you using a tool that modifies the ID of modules? For example, the baseUrl setting in tsconfig.json cannot be used.`);
     return false;
 }
 function getVirtualFileId(id) {
-    if (id.startsWith(tag)) {
-        id = id.slice(tag.length);
-    }
-    (0, utils_js_1.assert)(!id.startsWith(tag));
-    return id;
+    return removeVirtualIdTag(id);
 }
 function resolveVirtualFileId(id) {
     (0, utils_js_1.assert)(isVirtualFileId(id));
-    if (!id.startsWith(tag)) {
-        id = tag + id;
+    if (!id.startsWith(virtualIdTag)) {
+        id = virtualIdTag + id;
+    }
+    (0, utils_js_1.assert)(id.startsWith(virtualIdTag));
+    return id;
+}
+function removeVirtualIdTag(id) {
+    if (id.startsWith(virtualIdTag)) {
+        id = id.slice(virtualIdTag.length);
     }
-    (0, utils_js_1.assert)(id.startsWith(tag));
+    (0, utils_js_1.assert)(!id.startsWith(virtualIdTag));
     return id;
 }

package/dist/cjs/shared/NOT_SERIALIZABLE.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOT_SERIALIZABLE = void 0;
+// TODO: move to ../node/runtime/html/NOT_SERIALIZABLE.ts once code is distributed as ESM
+exports.NOT_SERIALIZABLE = '__VIKE__NOT_SERIALIZABLE__';