vike 0.4.225 → 0.4.226-commit-8f5c172

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

@@ -64,6 +64,7 @@ function getGlobalContextSync() {
 }
 /** @experimental https://vike.dev/getGlobalContext */
 async function getGlobalContextAsync(isProduction) {
+    debug('getGlobalContextAsync()');
     assertUsage(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${pc.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${pc.cyan('true')} or ${pc.cyan('false')}`}`);
     setIsProduction(isProduction);
     if (!globalObject.globalContext)
@@ -89,10 +90,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();
+    }
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     await updateUserFiles();
@@ -308,10 +309,14 @@ async function loadBuildEntry(outDir) {
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         assert(globalObject.buildEntry);
-        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. ${pc.cyan('$ node dist/server/index.mjs')}) instead of running the original server entry (e.g. ${pc.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
+        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. ${pc.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${pc.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);

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

@@ -1,6 +1,7 @@
 export { getViteDevScript };
 import { assert, assertUsage, assertWarning } from '../../utils.js';
 import pc from '@brillout/picocolors';
+const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
     const globalContext = pageContext._globalContext;
     if (globalContext.isProduction) {
@@ -12,11 +13,13 @@ async function getViteDevScript(pageContext) {
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
     fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
     assertUsage(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${pc.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
-    assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), 'Vite plugins that minify the HTML are not supported by vike, see https://github.com/vikejs/vike/issues/224');
-    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.');
+    assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), `Vite plugins that minify the HTML cannot be applied, see https://github.com/vikejs/vike/issues/224`);
+    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);
     assert(viteInjection.includes('script'));
-    assertWarning(!viteInjection.includes('import('), 'Unexpected Vite HMR code. Reach out to a Vike maintainer on GitHub.', { onlyOnce: true });
+    assertWarning(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
+        onlyOnce: true
+    });
     const viteDevScript = viteInjection;
     return viteDevScript;
 }

package/dist/esm/node/runtime/html/serializePageContextClientSide.d.ts

@@ -1,6 +1,7 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
 export type { PageContextSerialization };
+export { getPropKeys };
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 type PageContextSerialization = {
@@ -20,3 +21,4 @@ declare function serializePageContextAbort(pageContext: Record<string, unknown>
 } | {
     abortStatusCode: number;
 })): string;
+declare function getPropKeys(prop: string): string[];

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

@@ -1,11 +1,13 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
+// For ./serializePageContextClientSide.spec.ts
+export { getPropKeys };
 import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../utils.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, isObject, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
-import { notSerializable } from '../../../shared/notSerializable.js';
+import { NOT_SERIALIZABLE } from '../../../shared/NOT_SERIALIZABLE.js';
 import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 const PASS_TO_CLIENT = [
@@ -25,12 +27,8 @@ const PASS_TO_CLIENT = [
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', 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] = true;
     }
     let pageContextSerialized;
@@ -42,14 +40,15 @@ function serializePageContextClientSide(pageContext) {
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const propName1 = 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(getPropAccessNotation).join('')}`;
             try {
-                serialize(pageContext[prop], varName);
+                serialize(value, varName);
             }
             catch (err) {
-                hasWarned = true;
                 propsNonSerializable.push(prop);
                 // useConfig() wrong usage
                 if (prop === '_configFromHook') {
@@ -62,7 +61,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 (isJsonSerializerError(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -75,11 +74,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
                 assertWarning(false, msg, { onlyOnce: false });
+                hasWarned = true;
             }
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[prop] = notSerializable;
+            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
             pageContextSerialized = serialize(pageContextClient);
@@ -138,3 +138,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 (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 (!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/esm/node/runtime/renderPage/createHttpResponse/assertNoInfiniteHttpRedirect.d.ts

@@ -1,4 +1,4 @@
 export { assertNoInfiniteHttpRedirect };
 declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, pageContextInit: {
     urlOriginal: string;
-}): void;
+}): "DISABLED" | undefined;

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

@@ -4,14 +4,15 @@ import pc from '@brillout/picocolors';
 const globalObject = 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/esm/node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.js

@@ -7,5 +7,8 @@ function preparePageContextForUserConsumptionServerSide(pageContext) {
     assert(isPlainObject(pageContext.routeParams));
     assert('Page' in pageContext);
     assert(typeof pageContext.isClientSideNavigation === 'boolean');
+    assert(pageContext._isPageContextObject);
+    assert(pageContext.isClientSide === false);
+    assert(typeof pageContext.isPrerendering === 'boolean');
     preparePageContextForUserConsumption(pageContext);
 }

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

@@ -2,6 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 export { prerender404Page };
 export { getPageContextInitEnhanced };
+export { createPageContext };
 export type { PageContextAfterRender };
 export type { PageContextInitEnhanced };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
@@ -32,6 +33,10 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -118,6 +123,10 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     documentHtml: string;
     pageContextSerialized: string;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -205,6 +214,10 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -291,6 +304,10 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     documentHtml: string;
     pageContextSerialized: string;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -379,13 +396,17 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
-}, globalContext: GlobalContextInternal, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
+}, globalContext: GlobalContextInternal, isPrerendering: boolean, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
     ssr?: {
         urlRewrite: null | string;
         urlHandler: null | ((url: string) => string);
         isClientSideNavigation: boolean;
     };
 }): Promise<{
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Record<string, unknown> & {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
@@ -450,3 +471,8 @@ declare function getPageContextInitEnhanced(pageContextInit: {
 } & {
     headers: Record<string, string> | null;
 }>;
+declare function createPageContext(pageContextInit: Record<string, unknown>, isPrerendering: boolean): {
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Record<string, unknown>;

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

@@ -2,6 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 export { prerender404Page };
 export { getPageContextInitEnhanced };
+export { createPageContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAssign } from '../utils.js';
@@ -84,7 +85,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' };
+    objectAssign(pageContextInit, pageContextInit_);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    objectAssign(pageContext, {
         pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
@@ -93,25 +98,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`
-    };
-    objectAssign(pageContextInit, pageContextInit_);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     objectAssign(pageContext, await 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
 } } = {}) {
     assert(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = {};
+    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
@@ -158,3 +155,12 @@ async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr:
     }
     return pageContextInitEnhanced;
 }
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        _isPageContextObject: true,
+        isClientSide: false,
+        isPrerendering
+    };
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}

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

@@ -1,6 +1,6 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { getPageContextInitEnhanced, renderPageAlreadyRouted, createPageContext } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
@@ -103,15 +103,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 = getPageContextFromAllRewrites(pageContextsFromRewrite);
-        objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
-    }
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
-        objectAssign(pageContextNominalPageInit, pageContextInitEnhanced);
-    }
+    const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
+    objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
@@ -242,7 +236,7 @@ function prettyUrl(url) {
     return pc.bold(decodeURI(url));
 }
 function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = createPageContext(pageContextInit);
+    const pageContextWithError = createPageContext(pageContextInit, false);
     const httpResponse = createHttpResponseError(pageContext);
     objectAssign(pageContextWithError, {
         httpResponse,
@@ -250,13 +244,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) {
     objectAssign(pageContext, { errorWhileRendering: null });
     // Route
@@ -281,10 +268,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);
     assert(errNominalPage);
-    const pageContext = {};
-    objectAssign(pageContext, pageContextInitEnhanced);
     objectAssign(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
@@ -298,7 +283,7 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
 }
 async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, {
+    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, false, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -342,7 +327,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
     const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit);
+    const pageContextHttpResponse = createPageContext(pageContextInit, false);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -384,7 +369,7 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit);
+    const pageContextHttpResponse = createPageContext(pageContextInit, false);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -405,10 +390,10 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = createPageContext({});
+            const pageContext = createPageContext({}, false);
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
-            objectAssign(pageContext, pageContextErrorPageInit);
+            objectAssign(pageContext, pageContextErrorPageInit, true);
             objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = serializePageContextClientSide(pageContext);
@@ -429,7 +414,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = createPageContext(pageContextInit);
+        const pageContextReturn = createPageContext(pageContextInit, false);
         objectAssign(pageContextReturn, pageContextAbort);
         const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextInit);
         objectAssign(pageContextReturn, { httpResponse });
@@ -444,7 +429,7 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     const { isBaseMissing } = parseUrl(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = createPageContext(pageContextInit);
+    const pageContext = createPageContext(pageContextInit, false);
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
@@ -457,7 +442,7 @@ function renderInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
     if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = createPageContext(pageContextInit);
+        const pageContext = createPageContext(pageContextInit, false);
         const httpResponse = createHttpResponseFavicon404();
         objectAssign(pageContext, { httpResponse });
         checkType(pageContext);

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

@@ -31,7 +31,7 @@ export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/freezePartial.js';
 export * from '../../utils/isNpmPackage.js';
-export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
 export * from '../../utils/objectKeys.js';

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

@@ -35,7 +35,7 @@ export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/freezePartial.js';
 export * from '../../utils/isNpmPackage.js';
-export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
 export * from '../../utils/objectKeys.js';

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

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

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

@@ -10,7 +10,7 @@ function assertV1Design(pageConfigs, pageFilesAll) {
             assert(pageConfigs.length > 0);
             const filesV1 = 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(isNotNullish)
                 .map((filePathToShowToUser) => indent + filePathToShowToUser)))

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

@@ -10,6 +10,6 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertIsNotBrowser.js';
-export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isNullish.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/debug.js';

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

@@ -12,6 +12,6 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertIsNotBrowser.js';
-export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isNullish.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/debug.js';

package/dist/esm/node/shared/virtual-files.d.ts

@@ -1,6 +1,8 @@
 export { isVirtualFileId };
 export { getVirtualFileId };
 export { resolveVirtualFileId };
+export { removeVirtualIdTag };
 declare function isVirtualFileId(id: string): boolean;
 declare function getVirtualFileId(id: string): string;
 declare function resolveVirtualFileId(id: string): string;
+declare function removeVirtualIdTag(id: string): string;

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

@@ -1,32 +1,36 @@
 export { isVirtualFileId };
 export { getVirtualFileId };
 export { resolveVirtualFileId };
+export { removeVirtualIdTag };
 import pc from '@brillout/picocolors';
 import { assert, assertUsage } from './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
     assertUsage(!id.includes(idBase), `Encountered a module ID ${pc.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);
-    }
-    assert(!id.startsWith(tag));
-    return id;
+    return removeVirtualIdTag(id);
 }
 function resolveVirtualFileId(id) {
     assert(isVirtualFileId(id));
-    if (!id.startsWith(tag)) {
-        id = tag + id;
+    if (!id.startsWith(virtualIdTag)) {
+        id = virtualIdTag + id;
+    }
+    assert(id.startsWith(virtualIdTag));
+    return id;
+}
+function removeVirtualIdTag(id) {
+    if (id.startsWith(virtualIdTag)) {
+        id = id.slice(virtualIdTag.length);
     }
-    assert(id.startsWith(tag));
+    assert(!id.startsWith(virtualIdTag));
     return id;
 }

package/dist/esm/shared/NOT_SERIALIZABLE.d.ts

@@ -0,0 +1 @@
+export declare const NOT_SERIALIZABLE = "__VIKE__NOT_SERIALIZABLE__";

package/dist/esm/shared/NOT_SERIALIZABLE.js

@@ -0,0 +1,2 @@
+// TODO: move to ../node/runtime/html/NOT_SERIALIZABLE.ts once code is distributed as ESM
+export const NOT_SERIALIZABLE = '__VIKE__NOT_SERIALIZABLE__';