vike 0.4.160 → 0.4.161-commit-ba539a4

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

@@ -4,11 +4,11 @@ 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 { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
+import { getClientEntry } from '../../shared/getClientEntry.js';
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
         const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
-        const clientFilePath = getClientEntryFilePath(pageConfig);
+        const clientFilePath = getClientEntry(pageConfig);
         const clientEntry = !isClientSideRenderable ? clientFilePath : getVikeClientEntry(isClientRouting);
         const clientDependencies = [];
         clientDependencies.push({

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

@@ -119,11 +119,11 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         const val = hookReturnValue.pageContext;
         const errBegin = `${errPrefix} returned ${pc.cyan('{ pageContext }')}, but ${pc.cyan('pageContext')}`;
         if (isPromise(val) || isCallable(val)) {
-            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/stream#initial-data-after-stream-end`, { onlyOnce: true });
+            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/streaming#initial-data-after-stream-end`, { onlyOnce: true });
             pageContextPromise = val;
         }
         else {
-            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/stream#initial-data-after-stream-end`);
+            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/streaming#initial-data-after-stream-end`);
             assertPageContextProvidedByUser(val, renderHook);
             pageContextProvidedByRenderHook = val;
         }

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

@@ -7,9 +7,10 @@ import { type HtmlRender } from '../html/renderHtml.js';
 import type { RenderHook } from './executeOnRenderHtmlHook.js';
 type HttpResponseBody = {
     body: string;
-    getBody: () => Promise<string>;
-    getReadableWebStream: () => StreamReadableWeb;
     pipe: (writable: StreamWritableWeb | StreamWritableNode) => void;
+    getReadableWebStream: () => StreamReadableWeb;
+    getReadableNodeStream: () => Promise<StreamReadableNode>;
+    getBody: () => Promise<string>;
     /** @deprecated */
     getNodeStream: () => Promise<StreamReadableNode>;
     /** @deprecated */
@@ -21,12 +22,12 @@ type HttpResponseBody = {
 };
 declare function getHttpResponseBody(htmlRender: HtmlRender, renderHook: null | RenderHook): string;
 declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender, renderHook: null | RenderHook): {
+    pipe(writable: StreamWritableNode | StreamWritableWeb): void;
+    getReadableWebStream(): StreamReadableWeb;
+    getReadableNodeStream(): Promise<import("stream").Readable>;
     getBody(): Promise<string>;
     getNodeStream(): Promise<import("stream").Readable>;
     getWebStream(): StreamReadableWeb;
-    getReadableNodeStream(): Promise<import("stream").Readable>;
-    getReadableWebStream(): StreamReadableWeb;
     pipeToWebWritable(writable: StreamWritableWeb): void;
     pipeToNodeWritable(writable: StreamWritableNode): void;
-    pipe(writable: StreamWritableNode | StreamWritableWeb): void;
 };

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

@@ -4,7 +4,7 @@ import { isStream, getStreamName, inferStreamName, isStreamWritableWeb, isStream
 import { assert, assertUsage, assertWarning } from '../utils.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import pc from '@brillout/picocolors';
-const streamDocs = 'See https://vike.dev/stream for more information.';
+const streamDocs = 'See https://vike.dev/streaming for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
         assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
@@ -14,6 +14,44 @@ function getHttpResponseBody(htmlRender, renderHook) {
 }
 function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
     return {
+        pipe(writable) {
+            const getErrMsgMixingStreamTypes = (writableType) => `The ${getErrMsgBody(htmlRender, renderHook)} while a ${writableType} was passed to pageContext.httpResponse.pipe() which is contradictory. You cannot mix a Web Stream with a Node.js Stream.`;
+            if (isStreamWritableWeb(writable)) {
+                const success = pipeToStreamWritableWeb(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
+                    assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
+                }
+            }
+            if (isStreamWritableNode(writable)) {
+                const success = pipeToStreamWritableNode(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
+                    assertUsage(false, getErrMsgMixingStreamTypes('Node.js Writable'));
+                }
+            }
+            assertUsage(false, `The argument ${pc.cyan('writable')} passed to ${pc.cyan('pageContext.httpResponse.pipe(writable)')} doesn't seem to be ${getStreamName('writable', 'web')} nor ${getStreamName('writable', 'node')}.`);
+        },
+        getReadableWebStream() {
+            const webStream = getStreamReadableWeb(htmlRender);
+            if (webStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableWebStream()', getFixMsg('readable', 'web')));
+            }
+            return webStream;
+        },
+        async getReadableNodeStream() {
+            const nodeStream = await getStreamReadableNode(htmlRender);
+            if (nodeStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableNodeStream()', getFixMsg('readable', 'node')));
+            }
+            return nodeStream;
+        },
         async getBody() {
             const body = await getHtmlString(htmlRender);
             return body;
@@ -38,20 +76,6 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
             return webStream;
         },
-        async getReadableNodeStream() {
-            const nodeStream = await getStreamReadableNode(htmlRender);
-            if (nodeStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableNodeStream()', getFixMsg('readable', 'node')));
-            }
-            return nodeStream;
-        },
-        getReadableWebStream() {
-            const webStream = getStreamReadableWeb(htmlRender);
-            if (webStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableWebStream()', getFixMsg('readable', 'web')));
-            }
-            return webStream;
-        },
         // TODO/v1-release: remove
         pipeToWebWritable(writable) {
             assertWarning(false, '`pageContext.httpResponse.pipeToWebWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
@@ -69,30 +93,6 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             if (!success) {
                 assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToNodeWritable()'));
             }
-        },
-        pipe(writable) {
-            const getErrMsgMixingStreamTypes = (writableType) => `The ${getErrMsgBody(htmlRender, renderHook)} while a ${writableType} was passed to pageContext.httpResponse.pipe() which is contradictory. You cannot mix a Web Stream with a Node.js Stream.`;
-            if (isStreamWritableWeb(writable)) {
-                const success = pipeToStreamWritableWeb(htmlRender, writable);
-                if (success) {
-                    return;
-                }
-                else {
-                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
-                    assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
-                }
-            }
-            if (isStreamWritableNode(writable)) {
-                const success = pipeToStreamWritableNode(htmlRender, writable);
-                if (success) {
-                    return;
-                }
-                else {
-                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
-                    assertUsage(false, getErrMsgMixingStreamTypes('Node.js Writable'));
-                }
-            }
-            assertUsage(false, `The argument ${pc.cyan('writable')} passed to ${pc.cyan('pageContext.httpResponse.pipe(writable)')} doesn't seem to be ${getStreamName('writable', 'web')} nor ${getStreamName('writable', 'node')}.`);
         }
     };
     function getFixMsg(type, standard) {

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

@@ -1,5 +1,4 @@
 export { assertClientEntryId };
-import { getGlobalContext } from '../../globalContext.js';
 import { assert, assertPosixPath, isNpmPackageImport } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 function assertClientEntryId(id) {
@@ -15,8 +14,4 @@ function assertClientEntryId(id) {
         isVirtualFileIdPageConfigValuesAll(id) ||
         // Stem packages
         isPkg, id);
-    if (isPkg) {
-        const { configVike } = getGlobalContext();
-        assert(configVike === null || configVike.extensions.some(({ npmPackageName }) => id.startsWith(npmPackageName)), id);
-    }
 }

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

@@ -2,7 +2,10 @@ export { getManifestEntry };
 import { assert, slice, isNpmPackageImport } from '../../utils.js';
 import { assertClientEntryId } from './assertClientEntryId.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-function getManifestEntry(id, clientManifest, manifestKeyMap) {
+import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
+function getManifestEntry(id, clientManifest, 
+// TODO: remove
+manifestKeyMap) {
     assertClientEntryId(id);
     const debugInfo = getDebugInfo(id, clientManifest);
     // Vike client entry
@@ -40,13 +43,11 @@ function getManifestEntry(id, clientManifest, manifestKeyMap) {
         assert(manifestEntry, debugInfo);
         return { manifestEntry, manifestKey };
     }
-    // extensions[number].pageConfigsDistFiles
+    // npm package import
     if (isNpmPackageImport(id)) {
-        const manifestKey = manifestKeyMap[id];
-        const debugInfo2 = { ...debugInfo, manifestKey };
-        assert(manifestKey, debugInfo2);
-        const manifestEntry = clientManifest[manifestKey];
-        assert(manifestEntry, debugInfo2);
+        const found = Object.entries(clientManifest).find(([, e]) => e.name === prependEntriesDir(id));
+        assert(found);
+        const [manifestKey, manifestEntry] = found;
         return { manifestEntry, manifestKey };
     }
     // extensions[number].pageConfigsSrcDir

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

@@ -1,5 +1,5 @@
 export { getPageAssets };
-import { assert, prependBase, assertPosixPath, toPosixPath, isNpmPackageImport, unique, isNotNullish, pathJoin } from '../utils.js';
+import { assert, prependBase, assertPosixPath, toPosixPath, isNpmPackageImport, unique, pathJoin } from '../utils.js';
 import { retrieveAssetsDev } from './getPageAssets/retrieveAssetsDev.js';
 import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
 import { inferMediaType } from './inferMediaType.js';
@@ -77,7 +77,7 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
         // User files
         filePath = pathJoin(root, clientEntry);
     }
-    else if (clientEntry.startsWith('@@vike/')) {
+    else if (clientEntry.startsWith('@@vike/') || isNpmPackageImport(clientEntry)) {
         // Vike client entry
         const { createRequire } = (await import_('module')).default;
         const { dirname } = (await import_('path')).default;
@@ -89,27 +89,23 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
         // @ts-expect-error
         // Bun workaround https://github.com/vikejs/vike/pull/1048
         const res = typeof Bun !== 'undefined' ? (toPath) => Bun.resolveSync(toPath, __dirname_) : require_.resolve;
-        assert(clientEntry.endsWith('.js'));
-        try {
-            // For Vitest (which doesn't resolve vike to its dist but to its source files)
-            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/runtime/renderPage/getPageAssets.js
-            filePath = toPosixPath(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts')));
+        if (isNpmPackageImport(clientEntry)) {
+            filePath = res(clientEntry);
         }
-        catch {
-            // For users
-            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/runtime/renderPage/getPageAssets.js
-            filePath = toPosixPath(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/')));
+        else {
+            assert(clientEntry.endsWith('.js'));
+            try {
+                // For Vitest (which doesn't resolve vike to its dist but to its source files)
+                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/runtime/renderPage/getPageAssets.js
+                filePath = toPosixPath(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts')));
+            }
+            catch {
+                // For users
+                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/runtime/renderPage/getPageAssets.js
+                filePath = toPosixPath(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/')));
+            }
         }
     }
-    else if (isNpmPackageImport(clientEntry)) {
-        const extensionPageFile = configVike.extensions
-            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-            .flat()
-            .filter(isNotNullish)
-            .find((e) => e.importPath === clientEntry);
-        assert(extensionPageFile, clientEntry);
-        filePath = extensionPageFile.filePath;
-    }
     else {
         assert(false);
     }

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

@@ -42,7 +42,7 @@ async function loadUserFilesServerSide(pageContext) {
     // TODO/v1-release: remove
     Object.assign(pageContextAddendum, {
         _getPageAssets: async () => {
-            assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preload', {
+            assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
                 onlyOnce: true,
                 showStackTrace: true
             });

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

@@ -0,0 +1,8 @@
+export { logErrorHint };
+export { isCjsEsmError };
+export { isKnownError };
+export { getHint };
+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[];

package/dist/esm/node/runtime/renderPage/{logHintForCjsEsmError.js → logErrorHint.js}

@@ -1,12 +1,22 @@
-export { logHintForCjsEsmError };
-// For ./logHintForCjsEsmError/*.spec.ts
+export { logErrorHint };
+// For ./logErrorHint/*.spec.ts
 export { isCjsEsmError };
-export { isReactInvalidComponentError };
+export { isKnownError };
 export { getHint };
 import pc from '@brillout/picocolors';
 import { assert, formatHintLog, isNotNullish, isObject, unique, joinEnglish } from '../utils.js';
-function logHintForCjsEsmError(error) {
-    /* Collect errors for ./logHintForCjsEsmError.spec.ts
+const knownErrors = [
+    {
+        errMsg: 'jsxDEV is not a function',
+        link: 'https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096'
+    },
+    {
+        errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
+        link: 'https://vike.dev/broken-npm-package#react-invalid-component'
+    }
+];
+function logErrorHint(error) {
+    /* Collect errors for ./logErrorHint.spec.ts
     collectError(error)
     //*/
     const hint = getHint(error);
@@ -14,9 +24,10 @@ function logHintForCjsEsmError(error) {
         logHint(hint);
 }
 function getHint(error) {
-    if (isReactInvalidComponentError(error)) {
-        const hint = 'To fix this error, see https://vike.dev/broken-npm-package#react-invalid-component';
-        return hint;
+    {
+        const link = isKnownError(error);
+        if (link)
+            return `To fix this error, see ${link}`;
     }
     const res = isCjsEsmError(error);
     if (res) {
@@ -37,43 +48,71 @@ function logHint(hint) {
     hint = formatHintLog(hint);
     console.error(hint);
 }
-function isReactInvalidComponentError(error) {
+function isKnownError(error) {
     const anywhere = getAnywhere(error);
-    return includes(anywhere, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)');
+    const knownErr = knownErrors.find((knownErorr) => {
+        return includes(anywhere, knownErorr.errMsg);
+    });
+    if (!knownErr)
+        return false;
+    return knownErr.link;
 }
-/**
- * `false` -> noop
- * `true` -> generic message
- * `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
- */
+// `false` -> noop
+// `true` -> generic message
+// `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
 function isCjsEsmError(error) {
+    const res = check(error);
+    if (res === true || res === false)
+        return res;
+    const packageNames = normalizeRes(res);
+    if (packageNames === false)
+        return packageNames;
+    packageNames.forEach((packageName) => {
+        assert(!['vite', 'vike'].includes(packageName));
+    });
+    return packageNames;
+}
+function normalizeRes(res) {
+    let packageNames = Array.isArray(res) ? res : [res];
+    packageNames = unique(packageNames.filter(isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
+    if (packageNames.length === 0)
+        return false;
+    return packageNames;
+}
+function check(error) {
     const message = getErrMessage(error);
     const anywhere = getAnywhere(error);
     const packageName_stack1 = getPackageName_stack1(error);
     const packageName_stack2 = getPackageName_stack2(error);
     const isRelatedToNodeModules = !!packageName_stack1 || !!packageName_stack2 || includesNodeModules(message);
-    // const relatedNpmPackages = normalize([packageName_stack1, packageName_stack2, extractFromNodeModulesPath(message)])
+    /*
+    const relatedNpmPackages = normalizeArray([
+      packageName_stack1 || null,
+      packageName_stack2 || null,
+      (message && extractFromNodeModulesPath(message)) || null
+    ])
+    */
     // ERR_UNSUPPORTED_DIR_IMPORT
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
+        if (packageName)
+            return packageName;
     }
     // ERR_UNKNOWN_FILE_EXTENSION
     {
-        const packageNames = parseUnkownFileExtensionMessage(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseUnkownFileExtensionMessage(anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('is not exported', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('is not exported', anywhere);
+        if (packageName)
+            return packageName;
     }
     // Using CJS inside ESM modules.
     if (includes(anywhere, 'require is not a function') ||
@@ -94,7 +133,7 @@ function isCjsEsmError(error) {
     if (includes(anywhere, 'ERR_REQUIRE_ESM')) {
         /* The issue is the importer, not the importee.
         if (relatedNpmPackages) return relatedNpmPackages
-        */
+         */
         {
             if (packageName_stack1)
                 return packageName_stack1;
@@ -114,9 +153,9 @@ function isCjsEsmError(error) {
     */
     // `SyntaxError: Named export '${exportName}' not found. The requested module '${packageName}' is a CommonJS module, which may not support all module.exports as named exports.`
     {
-        const packageNames = parseImportFrom(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseImportFrom(anywhere);
+        if (packageName)
+            return packageName;
     }
     if (includes(anywhere, 'Cannot read properties of undefined')) {
         if (isRelatedToNodeModules) {
@@ -152,7 +191,7 @@ function parseCannotFindMessage(str) {
         return false;
     // const packageNameCannotFind = extractFromPath(match[1]!)
     const packageNameFrom = extractFromPath(match[2]);
-    return normalize([
+    return normalizeArray([
         // packageNameCannotFind,
         packageNameFrom
     ]);
@@ -163,7 +202,7 @@ function parseUnkownFileExtensionMessage(str) {
         return false;
     const filePath = match[1];
     const packageName = extractFromPath(filePath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseImportFrom(str) {
     const match = /\bimport\b.*?\bfrom\b\s*?"(.+?)"/.exec(str);
@@ -171,7 +210,7 @@ function parseImportFrom(str) {
         return false;
     const importPath = match[1];
     const packageName = extractFromPath(importPath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseNodeModulesPathMessage(begin, str) {
     str = str.replaceAll('\\', '/');
@@ -225,7 +264,6 @@ function extractFromPath(filePath) {
         packageName = packageName.split('/')[0];
     }
     packageName = clean(packageName);
-    assert(!['vite', 'vike'].includes(packageName));
     return packageName;
 }
 function clean(packageName) {
@@ -243,7 +281,7 @@ function extractFromNodeModulesPath(str) {
         return false;
     const packageName = extractFromPath(str);
     assert(packageName);
-    return normalize([packageName]);
+    return packageName;
 }
 function includes(str1, str2) {
     return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
@@ -258,11 +296,11 @@ function includesNodeModules(str) {
         return false;
     return true;
 }
-function normalize(packageNames) {
-    const result = unique(packageNames.filter(isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
-    if (result.length === 0)
-        return false;
-    return result;
+function normalizeArray(arr) {
+    const arrNormalized = arr.filter(isNotNullish);
+    if (arrNormalized.length === 0)
+        return null;
+    return arrNormalized;
 }
 function getErrMessage(err) {
     if (!isObject(err))

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

@@ -6,7 +6,7 @@ import { isAbortError } from '../../../shared/route/abort.js';
 import { setAlreadyLogged } from './isNewError.js';
 import { isObject, warnIfErrorIsNotObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-import { logHintForCjsEsmError } from './logHintForCjsEsmError.js';
+import { logErrorHint } from './logErrorHint.js';
 function logErrorProd(err, _httpRquestId) {
     warnIfErrorIsNotObject(err);
     setAlreadyLogged(err);
@@ -20,6 +20,6 @@ function logErrorProd(err, _httpRquestId) {
 }
 // Every server-side runtime error is expected to go through onRuntimeError(). (In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.)
 function onRuntimeError(err) {
-    // The more runtime errors we pass to logHintForCjsEsmError() the better.
-    logHintForCjsEsmError(err);
+    // The more runtime errors we pass to logErrorHint() the better.
+    logErrorHint(err);
 }

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

@@ -36,7 +36,7 @@ export * from '../../utils/isNpmPackage.js';
 export * from '../../utils/isNotNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
-export * from '../../utils/objectEntries.js';
+export * from '../../utils/objectKeys.js';
 export * from '../../utils/isStringRecord.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertIsNotProductionRuntime.js';

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

@@ -39,7 +39,7 @@ export * from '../../utils/isNpmPackage.js';
 export * from '../../utils/isNotNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
-export * from '../../utils/objectEntries.js';
+export * from '../../utils/objectKeys.js';
 export * from '../../utils/isStringRecord.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertIsNotProductionRuntime.js';

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

@@ -6,6 +6,7 @@ type ViteManifestEntry = {
     css?: string[];
     assets?: string[];
     isEntry?: boolean;
+    name?: string;
     isDynamicEntry?: boolean;
     imports?: string[];
     dynamicImports?: string[];

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

@@ -0,0 +1,3 @@
+export { getClientEntry };
+import type { PageConfigRuntime, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function getClientEntry(pageConfig: PageConfigRuntime | PageConfigBuildTime): null | string;

package/dist/esm/node/shared/{getClientEntryFilePath.js → getClientEntry.js}

@@ -1,6 +1,6 @@
-export { getClientEntryFilePath };
+export { getClientEntry };
 import { getConfigValue } from '../../shared/page-configs/helpers.js';
-function getClientEntryFilePath(pageConfig) {
+function getClientEntry(pageConfig) {
     const configName = 'client';
     const configValue = getConfigValue(pageConfig, configName, 'string');
     if (!configValue)

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

@@ -0,0 +1,2 @@
+export { prependEntriesDir };
+declare function prependEntriesDir(entryName: string): string;

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

@@ -0,0 +1,10 @@
+export { prependEntriesDir };
+import { assert } from './utils.js';
+function prependEntriesDir(entryName) {
+    if (entryName.startsWith('/')) {
+        entryName = entryName.slice(1);
+    }
+    assert(!entryName.startsWith('/'));
+    entryName = `entries/${entryName}`;
+    return entryName;
+}

package/dist/esm/shared/page-configs/Config.d.ts

@@ -201,7 +201,7 @@ type OnRenderHtmlSync = (pageContext: PageContextServer) => DocumentHtml | {
     pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
 };
 type OnRenderHtmlPageContextReturn = Partial<Vike.PageContext & {
-    /** See https://vike.dev/stream */
+    /** See https://vike.dev/streaming */
     enableEagerStreaming: boolean;
 }>;
 /** @deprecated Use a sync route() with an async guard() instead */

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -17,6 +17,7 @@ export type { DefinedAtFileFullInfo };
 export type { FilePathResolved };
 export type { FilePath };
 import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
+import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -71,6 +72,7 @@ type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAt: DefinedAtFileFullInfo;
+    locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */