vike 0.4.171 → 0.4.172-commit-ea2b76c

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

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertPathFilesystemAbsolute, isArray } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertPathFilesystemAbsolute, isArray, changeEnumerable } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -16,10 +16,10 @@ import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
 import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
-import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
+import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
@@ -27,6 +27,7 @@ import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
+import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -114,7 +115,7 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
-        const configValue = getConfigValue(pageConfig, configName, 'boolean');
+        const configValue = getConfigValueBuildTime(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
             const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
             assert(configValueFilePathToShowToUser);
@@ -217,7 +218,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout });
+        const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -240,9 +241,9 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
                 objectAssign(pageContextNew, {
-                    _pageContextAlreadyProvidedByOnPrerenderHook: true,
-                    ...pageContext
+                    _pageContextAlreadyProvidedByOnPrerenderHook: true
                 });
+                objectAssign(pageContextNew, pageContext);
             }
         });
     })));
@@ -300,14 +301,11 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
-        urlOriginal,
-        ...prerenderContext.pageContextInit
+        urlOriginal
     };
+    objectAssign(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext, {
-            // We set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in a onPrerenderStart() hook, e.g. /examples/i18n/
-            urlComputedPropsNonEnumerable: true
-        });
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
@@ -382,6 +380,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
     const docLink = 'https://vike.dev/i18n#pre-rendering';
+    // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
+    const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
     let result = await executeHook(() => hookFn({
         pageContexts: prerenderContext.pageContexts,
         // TODO/v1-release: remove warning
@@ -392,7 +392,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), onPrerenderStartHook);
+    }), onPrerenderStartHook, null);
+    restoreEnumerable();
     if (result === null || result === undefined) {
         return;
     }
@@ -430,9 +431,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
                 hookName
             };
         }
-        // Restore as URL computed props are lost when user makes a pageContext copy
-        addUrlComputedProps(pageContext);
     });
+    addPageContextComputedUrl(prerenderContext.pageContexts);
 }
 async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = getGlobalContext();
@@ -474,7 +474,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             if (pageContext._pageConfigs.length > 0) {
                 const pageConfig = pageContext._pageConfigs.find((p) => p.pageId === pageId);
                 assert(pageConfig);
-                usesClientRouter = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+                usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
                 usesClientRouter = globalContext.pluginManifest.usesClientRouter;
@@ -714,3 +714,23 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCall);
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
+function makePageContextComputedUrlNonEnumerable(pageContexts) {
+    change(false);
+    return { restoreEnumerable, addPageContextComputedUrl };
+    function restoreEnumerable() {
+        change(true);
+    }
+    function addPageContextComputedUrl(pageContexts) {
+        // Add URL computed props to the user-generated pageContext copies
+        pageContexts.forEach((pageContext) => {
+            const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
+            objectAssign(pageContext, pageContextUrlComputed);
+        });
+    }
+    function change(enumerable) {
+        pageContexts.forEach((pageContext) => {
+            changeEnumerable(pageContext, 'urlPathname', enumerable);
+            changeEnumerable(pageContext, 'urlParsed', enumerable);
+        });
+    }
+}

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

@@ -13,3 +13,4 @@ export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertPathFilesystemAbsolute.js';
 export * from '../../utils/isArray.js';
+export * from '../../utils/changeEnumerable.js';

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

@@ -15,3 +15,4 @@ export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertPathFilesystemAbsolute.js';
 export * from '../../utils/isArray.js';
+export * from '../../utils/changeEnumerable.js';

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

@@ -107,7 +107,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
         });
     }
     // The JavaScript entry <script> tag
-    const scriptEntry = await mergeScriptEntries(pageAssets, isProduction);
+    const scriptEntry = await mergeScriptEntries(pageAssets);
     if (scriptEntry) {
         htmlTags.push({
             htmlTag: scriptEntry,
@@ -128,11 +128,11 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     });
     return htmlTags;
 }
-async function mergeScriptEntries(pageAssets, isProduction) {
+async function mergeScriptEntries(pageAssets) {
     const scriptEntries = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
     const viteScripts = await getViteDevScripts();
     const scriptTagsHtml = `${viteScripts}${scriptEntries.map((asset) => inferAssetTag(asset)).join('')}`;
-    const scriptTag = mergeScriptTags(scriptTagsHtml, isProduction);
+    const scriptTag = mergeScriptTags(scriptTagsHtml);
     return scriptTag;
 }
 function getPageContextJsonScriptTag(pageContext) {

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

@@ -1,6 +1,6 @@
 export { getViteDevScripts };
 import { getGlobalContext } from '../../globalContext.js';
-import { assert, assertUsage } from '../../utils.js';
+import { assert, assertUsage, assertWarning } from '../../utils.js';
 import pc from '@brillout/picocolors';
 async function getViteDevScripts() {
     const globalContext = getGlobalContext();
@@ -16,7 +16,8 @@ async function getViteDevScripts() {
     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.');
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
-    assert(viteInjection.includes('script'), { viteInjection });
+    assert(viteInjection.includes('script'));
+    assertWarning(!viteInjection.includes('import('), 'Unexpected Vite HMR code. Reach out to a Vike maintainer on GitHub.', { onlyOnce: true });
     const scriptTags = viteInjection;
     return scriptTags;
 }

package/dist/esm/node/runtime/html/injectAssets/mergeScriptTags.d.ts

@@ -1,2 +1,2 @@
 export { mergeScriptTags };
-declare function mergeScriptTags(scriptTagsHtml: string, isProduction: boolean): string;
+declare function mergeScriptTags(scriptTagsHtml: string): string;

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

@@ -4,7 +4,7 @@ import { scriptAttrs } from './inferHtmlTags.js';
 const scriptRE = /(<script\b(?:\s[^>]*>|>))(.*?)<\/script>/gims;
 const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
-function mergeScriptTags(scriptTagsHtml, isProduction) {
+function mergeScriptTags(scriptTagsHtml) {
     let scriptTag = '';
     const scripts = parseScripts(scriptTagsHtml);
     // We need to merge module scripts to ensure execution order
@@ -19,13 +19,7 @@ function mergeScriptTags(scriptTagsHtml, isProduction) {
                 const hasInnerHtml = !!innerHtml.trim();
                 if (src) {
                     assert(!hasInnerHtml);
-                    if (isProduction) {
-                        contents.push(`import ${JSON.stringify(src)};`);
-                    }
-                    else {
-                        // Ensure HMR preamble code is executed before client entries
-                        contents.push(`import(${JSON.stringify(src)});`);
-                    }
+                    contents.push(`import ${JSON.stringify(src)};`);
                 }
                 else if (hasInnerHtml) {
                     innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');

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

@@ -3,7 +3,7 @@ export { dangerouslySkipEscape };
 export { renderDocumentHtml };
 export { isDocumentHtml };
 export { getHtmlString };
-import { assert, assertUsage, assertWarning, checkType, hasProp, isHtml, isPromise, objectAssign } from '../utils.js';
+import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign } from '../utils.js';
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
 import { processStream, isStream, streamToString } from './stream.js';
 import { isStreamReactStreaming } from './stream/react-streaming.js';
@@ -165,31 +165,40 @@ async function renderTemplate(templateContent, pageContext) {
             setStream(templateVar);
             continue;
         }
-        const getErrMsg = (typeText, end) => {
+        const getErrMsg = (msg) => {
             const { hookName, hookFilePath } = pageContext._renderHook;
             const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
-            return [`The ${nth} HTML variable is ${typeText}, see ${hookName}() hook defined by ${hookFilePath}.`, end]
+            return [
+                `The ${nth} HTML variable is ${msg}`,
+                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`
+            ]
                 .filter(Boolean)
                 .join(' ');
         };
-        assertUsage(!isPromise(templateVar), getErrMsg('a promise', `Did you forget to ${pc.cyan('await')} the promise?`));
+        assertUsage(!isPromise(templateVar), getErrMsg(`a promise, did you forget to ${pc.cyan('await')} the promise?`));
         if (templateVar === undefined || templateVar === null) {
-            assertWarning(false, getErrMsg(`${pc.cyan(String(templateVar))} which will be converted to an empty string`, `Pass the empty string ${pc.cyan("''")} instead of ${pc.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
+            const msgVal = pc.cyan(String(templateVar));
+            const msgEmptyString = pc.cyan("''");
+            const msg = `${msgVal} which will be converted to an empty string. Pass the empty string ${msgEmptyString} instead of ${msgVal} to remove this warning.`;
+            assertWarning(false, getErrMsg(msg), { onlyOnce: false });
             templateVar = '';
         }
         {
             const varType = typeof templateVar;
-            const streamNote = ['boolean', 'number', 'bigint', 'symbol'].includes(varType)
-                ? null
-                : '(See https://vike.dev/streaming for HTML streaming.)';
-            assertUsage(varType === 'string', getErrMsg(pc.cyan(`typeof htmlVar === "${varType}"`), streamNote));
+            if (varType !== 'string') {
+                const msgType = pc.cyan(`typeof htmlVariable === "${varType}"`);
+                const msg = `${msgType} but a string or stream (https://vike.dev/streaming) is expected instead.`;
+                assertUsage(false, getErrMsg(msg));
+            }
         }
         {
             const { isProduction } = getGlobalContext();
             if (isHtml(templateVar) &&
                 // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
                 !isProduction) {
-                assertWarning(false, getErrMsg(`${pc.cyan(templateVar)} which seems to be HTML code`, 'Did you forget to wrap the value with dangerouslySkipEscape()?'), { onlyOnce: false });
+                const msgVal = pc.cyan(String(templateVar));
+                const msg = `${msgVal} which seems to be HTML code. Did you forget to wrap the value with dangerouslySkipEscape()?`;
+                assertWarning(false, getErrMsg(msg), { onlyOnce: false });
             }
         }
         // Escape untrusted template variable
@@ -209,16 +218,6 @@ async function renderTemplate(templateContent, pageContext) {
         htmlPartsEnd
     };
 }
-function escapeHtml(unsafeString) {
-    // Source: https://stackoverflow.com/questions/6234773/can-i-escape-html-special-chars-in-javascript/6234804#6234804
-    const safe = unsafeString
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#039;');
-    return safe;
-}
 async function getHtmlString(htmlRender) {
     if (typeof htmlRender === 'string') {
         return htmlRender;

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

@@ -80,5 +80,5 @@ type StreamPipeWrapped = {
 };
 declare function pipeStream(pipe: StreamPipe): StreamPipeWrapped;
 declare function streamToString(stream: StreamProviderAny): Promise<string>;
-declare function getStreamName(type: 'pipe' | 'readable' | 'writable', standard: 'web' | 'node'): `a ${string} Stream` | `a ${string} Stream Pipe`;
+declare function getStreamName(kind: 'pipe' | 'readable' | 'writable', type: 'web' | 'node'): `a ${string} Stream` | `a ${string} Stream Pipe`;
 declare function inferStreamName(stream: StreamProviderNormalized): `a ${string} Stream` | `a ${string} Stream Pipe`;

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

@@ -758,17 +758,17 @@ async function loadStreamNodeModule() {
     const { Readable, Writable } = streamModule;
     return { Readable, Writable };
 }
-function getStreamName(type, standard) {
-    let standardName = capitalizeFirstLetter(standard);
-    if (standardName === 'Node') {
-        standardName = 'Node.js';
+function getStreamName(kind, type) {
+    let typeName = capitalizeFirstLetter(type);
+    if (typeName === 'Node') {
+        typeName = 'Node.js';
     }
-    const typeName = capitalizeFirstLetter(type);
-    if (type !== 'pipe') {
-        return `a ${typeName} ${standardName} Stream`;
+    const kindName = capitalizeFirstLetter(kind);
+    if (kind !== 'pipe') {
+        return `a ${kindName} ${typeName} Stream`;
     }
-    if (type === 'pipe') {
-        return `a ${standardName} Stream Pipe`;
+    if (kind === 'pipe') {
+        return `a ${typeName} Stream Pipe`;
     }
     assert(false);
 }

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

@@ -4,12 +4,16 @@ import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageC
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getGlobalContext } from '../globalContext.js';
-import { getClientEntry } from '../../shared/getClientEntry.js';
+import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValue.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
         const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
-        const clientFilePath = getClientEntry(pageConfig);
-        const clientEntry = !isClientSideRenderable ? clientFilePath : getVikeClientEntry(isClientRouting);
+        const clientEntries = [];
+        const clientFilePath = getConfigValueRuntime(pageConfig, 'client', 'string')?.value ?? null;
+        if (clientFilePath)
+            clientEntries.push(clientFilePath);
+        if (isClientSideRenderable)
+            clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
@@ -41,15 +45,13 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           }
         })
         */
-        const clientEntries = [];
-        if (clientEntry) {
+        clientEntries.forEach((clientEntry) => {
             clientDependencies.push({
                 id: clientEntry,
                 onlyAssets: false,
                 eagerlyImported: false
             });
-            clientEntries.push(clientEntry);
-        }
+        });
         return {
             isHtmlOnly: !isClientSideRenderable,
             isClientRouting,

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

@@ -1,13 +1,13 @@
 export { getCacheControl };
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValue.js';
 const defaultValue = 'no-store, max-age=0';
 function getCacheControl(pageId, pageConfigs) {
     // TODO/v1-release: remove
     if (pageConfigs.length === 0)
         return defaultValue;
     const pageConfig = getPageConfig(pageId, pageConfigs);
-    const configValue = getConfigValue(pageConfig, 'cacheControl', 'string');
+    const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
     const value = configValue?.value;
     if (value)
         return value;

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

@@ -14,7 +14,7 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
     }
     preparePageContextForUserConsumptionServerSide(pageContext);
     if (dataHook) {
-        const hookResult = await executeHook(() => dataHook.hookFn(pageContext), dataHook);
+        const hookResult = await executeHook(() => dataHook.hookFn(pageContext), dataHook, pageContext);
         // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
         const pageContextFromHook = {
             data: hookResult
@@ -22,7 +22,7 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
         Object.assign(pageContext, pageContextFromHook);
     }
     if (onBeforeRenderHook) {
-        const hookResult = await executeHook(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook);
+        const hookResult = await executeHook(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook, pageContext);
         assertOnBeforeRenderHookReturn(hookResult, onBeforeRenderHook.hookFilePath);
         const pageContextFromHook = hookResult?.pageContext;
         Object.assign(pageContext, pageContextFromHook);

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

@@ -13,7 +13,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { renderHook, hookFn } = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: renderHook });
     preparePageContextForUserConsumptionServerSide(pageContext);
-    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook);
+    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook, pageContext);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
@@ -63,13 +63,13 @@ function getRenderHook(pageContext) {
         assertUsage(false, [
             `No ${hookName}() hook found, see https://vike.dev/${hookName}`
             /*
-          'See https://vike.dev/render-modes for more information.',
-          [
-            // 'Loaded config files (none of them define the onRenderHtml() hook):',
-            'Loaded server-side page files (none of them `export { render }`):',
-            ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
-          ].join('\n')
-          */
+            'See https://vike.dev/render-modes for more information.',
+            [
+              // 'Loaded config files (none of them define the onRenderHtml() hook):',
+              'Loaded server-side page files (none of them `export { render }`):',
+              ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
+            ].join('\n')
+            */
         ].join(' '));
     }
     return hookFound;

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

@@ -95,8 +95,8 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
         }
     };
-    function getFixMsg(type, standard) {
-        const streamName = getStreamName(type, standard);
+    function getFixMsg(kind, type) {
+        const streamName = getStreamName(kind, type);
         assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
         assert(renderHook);
         const { hookFilePath, hookName } = renderHook;

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

@@ -14,16 +14,11 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
     _pageId: string;
-} & PageContext_loadUserFilesServerSide): Promise<{
+} & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageContextExports & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];
     _pageFilePathsLoaded: string[];
-    config: Record<string, unknown>;
-    configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
-    exports: Record<string, unknown>;
-    exportsAll: import("../../../shared/getPageFiles/getExports.js").ExportsAll;
-    pageExports: Record<string, unknown>;
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;
 }>;

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

@@ -10,7 +10,7 @@ import { getGlobalContext } from '../globalContext.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 async function loadUserFilesServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
-    const [{ pageFilesLoaded, pageConfigLoaded, ...pageContextExports }] = await Promise.all([
+    const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
         loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
         analyzePageClientSideInit(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
@@ -35,8 +35,8 @@ async function loadUserFilesServerSide(pageContext) {
         });
     }
     const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, {
-        ...pageContextExports,
         Page: pageContextExports.exports.Page,
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
@@ -101,8 +101,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
     const pageContextExports = getPageContextExports(pageFilesServerSide, pageConfigLoaded);
     return {
-        ...pageContextExports,
-        pageFilesLoaded: pageFilesServerSide,
-        pageConfigLoaded
+        pageContextExports,
+        pageFilesLoaded: pageFilesServerSide
     };
 }

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

@@ -1,8 +1,4 @@
 export { logErrorHint };
-export { isCjsEsmError };
-export { isKnownError };
-export { getHint };
+export { getErrorHint };
 declare function logErrorHint(error: unknown): void;
-declare function getHint(error: unknown): null | string;
-declare function isKnownError(error: unknown): false | string;
-declare function isCjsEsmError(error: unknown): boolean | string[];
+declare function getErrorHint(error: unknown): null | string;