vike 0.4.224 → 0.4.225-commit-2b7971f

package/dist/esm/node/plugin/shared/getEnvVarObject.js

@@ -1,24 +1,25 @@
 export { getEnvVarObject };
+export { parseJson5 };
 import pc from '@brillout/picocolors';
 import { assertUsage, isObject } from '../utils.js';
 import JSON5 from 'json5';
-function getEnvVarObject(envVarName
-/* Let's eventually implement this for Vike's config as well
-| 'VIKE_CONFIG'
-*/
-) {
+function getEnvVarObject(envVarName) {
     const valueStr = process.env[envVarName];
     if (!valueStr)
         return null;
+    const value = parseJson5(valueStr, envVarName);
+    assertUsage(value, `${envVarName} should define an object but it's ${pc.bold(String(value))} instead.`);
+    assertUsage(isObject(value), `${envVarName} should define an object but it's set to the following which isn't an object: ${pc.bold(valueStr)}`);
+    return value;
+}
+function parseJson5(valueStr, what) {
     let value;
     try {
         value = JSON5.parse(valueStr);
     }
     catch (err) {
         console.error(err);
-        assertUsage(false, `Cannot parse ${envVarName} (see error above) because it's set to the following which isn't a valid JSON5 string: ${pc.bold(valueStr)}`);
+        assertUsage(false, `Cannot parse ${pc.cyan(what)} (see error above) because it's set to the following which isn't a valid JSON5 string: ${pc.bold(valueStr)}`);
     }
-    assertUsage(value, `${envVarName} should define an object but it's ${pc.bold(String(value))} instead.`);
-    assertUsage(isObject(value), `${envVarName} should define an object but it's set to the following which isn't an object: ${pc.bold(valueStr)}`);
     return value;
 }

package/dist/esm/node/plugin/shared/loggerNotProd/log.js

@@ -2,7 +2,7 @@ export { logWithViteTag };
 export { logWithVikeTag };
 export { logDirectly };
 export { applyViteSourceMapToStackTrace };
-import { assert, projectInfo, stripAnsi, hasProp, assertIsNotProductionRuntime } from '../../utils.js';
+import { assert, stripAnsi, hasProp, assertIsNotProductionRuntime, PROJECT_VERSION } from '../../utils.js';
 import pc from '@brillout/picocolors';
 import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { getViteDevServer } from '../../../runtime/globalContext.js';
@@ -15,7 +15,7 @@ function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
 function getProjectTag(showVikeVersion) {
     let projectTag;
     if (showVikeVersion) {
-        projectTag = `[vike@${projectInfo.projectVersion}]`;
+        projectTag = `[vike@${PROJECT_VERSION}]`;
     }
     else {
         projectTag = `[vike]`;

package/dist/esm/node/prerender/context.js

@@ -7,7 +7,7 @@ import { resolvePrerenderConfigGlobal } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
 function isPrerenderAutoRunEnabled(vikeConfig) {
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
-    return (prerenderConfigGlobal.isEnabled &&
+    return (prerenderConfigGlobal.isPrerenderingEnabled &&
         !(prerenderConfigGlobal || {}).disableAutoRun &&
         !globalObject.isDisabled &&
         vikeConfig.global.config.disableAutoFullBuild !== 'prerender');

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -9,7 +9,8 @@ declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
     disableAutoRun: boolean;
 } & {
     defaultLocalValue: boolean;
-    isEnabled: boolean;
+    isPrerenderingEnabledForAllPages: boolean;
+    isPrerenderingEnabled: boolean;
 };
 declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): {
     value: boolean;

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -1,29 +1,43 @@
 export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import { assert, isArray, objectAssign } from './utils.js';
+import { assert, isArray, isObject, objectAssign } from './utils.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
+// When setting +prerender to an object => it also enables pre-rendering
+const defaultValueForObject = true;
 function resolvePrerenderConfigGlobal(vikeConfig) {
-    const prerenderConfigs = vikeConfig.global.config.prerender;
-    let prerenderConfigList = prerenderConfigs || [];
-    // Needed because of backwards compatibility of `vike({prerender:true})` in `vite.config.js`; after we remove it we can remove this line.
-    prerenderConfigList = prerenderConfigList.filter(isObject2);
-    assert(prerenderConfigList.every(isObject2)); // Help TS
+    const prerenderConfigs = vikeConfig.global.config.prerender || [];
+    const prerenderSettings = prerenderConfigs.filter(isObject2);
     const prerenderConfigGlobal = {
-        partial: pickFirst(prerenderConfigList.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(prerenderConfigList.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(prerenderConfigList.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(prerenderConfigList.map((c) => c.disableAutoRun)) ?? false
+        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
     };
-    const prerenderConfigGlobalLocalValue = prerenderConfigList.map((c) => c.value).filter((v) => v !== null);
-    const defaultLocalValue = pickFirst(prerenderConfigGlobalLocalValue) ??
-        (prerenderConfigGlobalLocalValue.length > 0 ||
-            // Backwards compatibility for with vike({ prerender: true }) in vite.config.js
-            prerenderConfigs?.some((p) => p === true) ||
-            false);
+    let defaultLocalValue = false;
+    {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.enable !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.enable ?? defaultValueForObject))) {
+            defaultLocalValue = true;
+        }
+    }
+    // TODO/next-major: remove
+    // Backwards compatibility for `vike({prerender:true})` in vite.config.js
+    {
+        const valuesWithDefinedAt = vikeConfig.global._from.configsCumulative.prerender?.values ?? [];
+        if (valuesWithDefinedAt.some((v) => v.definedAt.includes('vite.config.js') && v.value)) {
+            defaultLocalValue = true;
+        }
+    }
     objectAssign(prerenderConfigGlobal, {
         defaultLocalValue,
-        isEnabled: defaultLocalValue || vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)
+        isPrerenderingEnabledForAllPages: vikeConfig.pageConfigs.length > 0 &&
+            vikeConfig.pageConfigs.every((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue),
+        isPrerenderingEnabled: vikeConfig.pageConfigs.length > 0 &&
+            vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue)
     });
+    // TODO/next-major remove
+    if (vikeConfig.pageConfigs.length === 0 && defaultLocalValue)
+        prerenderConfigGlobal.isPrerenderingEnabled = true;
     return prerenderConfigGlobal;
 }
 function resolvePrerenderConfigLocal(pageConfig) {
@@ -33,13 +47,14 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const values = configValue.value;
     assert(isArray(values));
     const value = values[0];
+    // If it's set to an object in a local config then Vike considers it a global config and it's skipped from local inheritance, thus we can assume the value to be a boolean.
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
     const prerenderConfigLocal = { value };
     return prerenderConfigLocal;
 }
-function isObject2(p) {
-    return typeof p === 'object' && p !== null;
+function isObject2(value) {
+    return typeof value === 'object' && value !== null;
 }
 function pickFirst(arr) {
     return arr.filter((v) => v !== undefined)[0];

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

@@ -4,7 +4,7 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy, PROJECT_VERSION } from './utils.js';
 import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -38,7 +38,7 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareViteApiCall(undefined, 'prerender');
+        const { viteConfigEnhanced } = await prepareViteApiCall({}, 'prerender');
         await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
@@ -75,7 +75,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
-        console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
+        console.log(`${pc.cyan(`vike v${PROJECT_VERSION}`)} ${pc.green('pre-rendering HTML...')}`);
     }
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
@@ -84,13 +84,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
     validatePrerenderConfig(prerenderConfigGlobal);
-    const { partial, noExtraDir, parallel, defaultLocalValue, isEnabled } = prerenderConfigGlobal;
-    if (!isEnabled) {
+    const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
+    if (!isPrerenderingEnabled) {
         assert(standaloneTrigger);
-        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs whenever possible
-        assertWarning(prerenderConfigGlobal, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the config ${pc.cyan('prerender')} (${pc.underline('https://vike.dev/prerender')}) to enable it.`, {
-            onlyOnce: true
-        });
+        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs if pre-rendering is completely disabled
+        assertWarning(false, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${pc.cyan('prerender')} setting (${pc.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`, { onlyOnce: true });
     }
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
@@ -306,20 +304,16 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
     })));
 }
 async function createPageContext(urlOriginal, prerenderContext, globalContext) {
-    const pageContext = {
+    const pageContextInit = { urlOriginal };
+    objectAssign(pageContextInit, prerenderContext.pageContextInit);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true, {});
+    assert(pageContext.isPrerendering === true);
+    objectAssign(pageContext, {
         _urlHandler: null,
         _urlRewrite: null,
         _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
-    };
-    const pageContextInit = {
-        urlOriginal
-    };
-    objectAssign(pageContextInit, prerenderContext.pageContextInit);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     return pageContext;
 }
 async function callOnPrerenderStartHook(prerenderContext, globalContext) {

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

@@ -1,6 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/hasProp.js';
-export * from '../../utils/projectInfo.js';
+export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';

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

@@ -2,7 +2,7 @@ import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/hasProp.js';
-export * from '../../utils/projectInfo.js';
+export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';

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

@@ -75,7 +75,7 @@ declare function getUserFiles(): Promise<{
     pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     pages: PageConfigsUserFriendly;
-    config: import("../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+    config: import("../../types/index.js").ConfigResolved;
 }>;
 declare function setGlobalContext_buildEntry(buildEntry: unknown): Promise<void>;
 type BuildInfo = {

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

@@ -25,7 +25,7 @@ export { updateUserFiles };
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
 //   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, projectInfo, checkType } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, checkType, PROJECT_VERSION } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
 import pc from '@brillout/picocolors';
@@ -89,9 +89,10 @@ function makePublic(globalContext) {
 async function setGlobalContext_viteDevServer(viteDevServer) {
     debug('setGlobalContext_viteDevServer()');
     setIsProduction(false);
-    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();
@@ -351,7 +352,7 @@ function assertBuildInfo(buildInfo) {
     checkType({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
 function assertVersionAtBuildTime(versionAtBuildTime) {
-    const versionAtRuntime = projectInfo.projectVersion;
+    const versionAtRuntime = PROJECT_VERSION;
     const pretty = (version) => pc.bold(`vike@${version}`);
     assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
@@ -369,7 +370,7 @@ async function updateUserFiles() {
     const { promise, resolve } = genPromise();
     assert(!globalObject.isProduction);
     globalObject.waitForUserFilesUpdate = promise;
-    const viteDevServer = getViteDevServer();
+    const { viteDevServer } = globalObject;
     assert(viteDevServer);
     let virtualFileExports;
     try {
@@ -381,6 +382,9 @@ async function updateUserFiles() {
     }
     virtualFileExports = virtualFileExports.default || virtualFileExports;
     debugGlob('Glob result: ', virtualFileExports);
+    // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
+    if (viteDevServer !== globalObject.viteDevServer)
+        return;
     await setUserFiles(virtualFileExports);
     resolve();
 }

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/html/stream.js

@@ -159,6 +159,13 @@ function getStreamReadableWeb(htmlRender) {
     if (isStreamReadableWeb(htmlRender)) {
         return htmlRender;
     }
+    if (isStreamPipeWeb(htmlRender)) {
+        const streamPipeWeb = getStreamPipeWeb(htmlRender);
+        assert(streamPipeWeb);
+        const { readable, writable } = new TransformStream();
+        streamPipeWeb(writable);
+        return readable;
+    }
     return null;
 }
 function pipeToStreamWritableWeb(htmlRender, writable) {

package/dist/esm/node/runtime/index-deprecated.d.ts

@@ -13,6 +13,4 @@ import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js
  *
  * See https://vike.dev/render
  */
-export declare const RenderErrorPage: (args_0?: {
-    pageContext?: Record<string, unknown>;
-} | undefined) => Error;
+export declare const RenderErrorPage: (...args: Parameters<typeof RenderErrorPage_>) => Error;

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

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

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

@@ -1,23 +1,32 @@
 export { assertNoInfiniteHttpRedirect };
-import { assert, assertUsage, getGlobalObject } from '../../utils.js';
+import { assert, assertUsage, getGlobalObject, removeUrlOrigin } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+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 (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
+        // 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.
         //    ```js
         //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    assert(urlLogical.startsWith('/'));
+    const urlOriginalNormalized = removeUrlOrigin(pageContextInit.urlOriginal).urlModified;
+    assert(urlOriginalNormalized.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
     graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
-    graph[urlRedirectTarget].add(urlLogical);
+    graph[urlRedirectTarget].add(urlOriginalNormalized);
     validate(graph);
     globalObject.redirectGraph = graph;
 }

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

@@ -35,4 +35,6 @@ declare function createHttpResponseError(pageContext: null | {
     _pageConfigs: PageConfigRuntime[];
 }): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: {
+    urlOriginal: string;
+}): HttpResponse;

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

@@ -82,10 +82,8 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
     const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
-function createHttpResponseRedirect({ url, statusCode }, 
-// The URL we assume the redirect to be logically based on
-urlLogical) {
-    assertNoInfiniteHttpRedirect(url, urlLogical);
+function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
+    assertNoInfiniteHttpRedirect(url, pageContextInit);
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);

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

@@ -23,6 +23,10 @@ const errorsMisc = [
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext',
         mustMentionNodeModules: false
+    },
+    {
+        errMsg: 'ERR_UNKNOWN_FILE_EXTENSION',
+        link: 'https://vike.dev/broken-npm-package#err-unknown-file-extension'
     }
 ];
 const reactInvalidEelement = 'https://vike.dev/broken-npm-package#react-invalid-component';
@@ -73,7 +77,8 @@ const errorsCjsEsm = [
     { errMsg: 'exports is not defined' },
     { errMsg: 'module is not defined' },
     { errMsg: 'not defined in ES' },
-    { errMsg: "Unexpected token 'export'" }
+    { errMsg: "Unexpected token 'export'" },
+    { errMsg: 'Failed to resolve entry for package' }
 ];
 function logErrorHint(error) {
     /* Collect errors for ./logErrorHint.spec.ts

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