vike 0.4.160 → 0.4.161-commit-0e9c635

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

@@ -3,11 +3,10 @@ export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
 export { setGlobalContext_viteDevServer };
-export { setGlobalContext_vitePreviewServer };
-export { setGlobalContext_viteConfig };
+export { setGlobalContext_prerender };
 export { getRuntimeManifest };
 import type { ViteManifest } from '../shared/ViteManifest.js';
-import type { ResolvedConfig, ViteDevServer, PreviewServer as VitePreviewServer } from 'vite';
+import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
@@ -22,9 +21,7 @@ type GlobalContext = {
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
-    configVike: ConfigVikeResolved;
     viteDevServer: ViteDevServer;
-    vitePreviewServer: null;
     clientManifest: null;
     pluginManifest: null;
 } | ({
@@ -32,21 +29,17 @@ type GlobalContext = {
     clientManifest: ViteManifest;
     pluginManifest: PluginManifest;
     viteDevServer: null;
-    vitePreviewServer: null | VitePreviewServer;
 } & ({
     isPrerendering: false;
     viteConfig: null;
-    configVike: null;
 } | {
     isPrerendering: true;
     viteConfig: ResolvedConfig;
-    configVike: ConfigVikeResolved;
 })));
 declare function getGlobalContext(): GlobalContext;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
-declare function setGlobalContext_vitePreviewServer(vitePreviewServer: VitePreviewServer): void;
 declare function getViteDevServer(): ViteDevServer | null;
-declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig): void;
+declare function setGlobalContext_prerender(viteConfig: ResolvedConfig): void;
 declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext(isPrerendering?: boolean, outDir?: string): Promise<void>;
 declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;

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

@@ -3,10 +3,9 @@ export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
 export { setGlobalContext_viteDevServer };
-export { setGlobalContext_vitePreviewServer };
-export { setGlobalContext_viteConfig };
+export { setGlobalContext_prerender };
 export { getRuntimeManifest };
-import { assert, assertUsage, getGlobalObject, getNodeEnv, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -22,18 +21,14 @@ function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
     assert(!globalObject.globalContext);
-    globalObject.viteDevServer = viteDevServer;
-}
-function setGlobalContext_vitePreviewServer(vitePreviewServer) {
-    if (globalObject.vitePreviewServer)
-        return;
     assert(!globalObject.globalContext);
-    globalObject.vitePreviewServer = vitePreviewServer;
+    globalObject.viteConfig = viteDevServer.config;
+    globalObject.viteDevServer = viteDevServer;
 }
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
 }
-function setGlobalContext_viteConfig(viteConfig) {
+function setGlobalContext_prerender(viteConfig) {
     if (globalObject.viteConfig)
         return;
     assert(!globalObject.globalContext);
@@ -45,13 +40,12 @@ function getViteConfig() {
 async function initGlobalContext(isPrerendering = false, outDir) {
     if (globalObject.globalContext)
         return;
-    const { viteDevServer, vitePreviewServer, viteConfig } = globalObject;
+    const { viteDevServer, viteConfig } = globalObject;
     assertNodeEnv(!!viteDevServer);
     const isProduction = !viteDevServer;
     if (!isProduction) {
         assert(viteConfig);
         assert(!isPrerendering);
-        assert(!vitePreviewServer);
         const configVike = await getConfigVike(viteConfig);
         const pluginManifest = getRuntimeManifest(configVike);
         globalObject.globalContext = {
@@ -60,9 +54,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             clientManifest: null,
             pluginManifest: null,
             viteDevServer,
-            vitePreviewServer: null,
             viteConfig,
-            configVike,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -83,7 +75,6 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             clientManifest,
             pluginManifest,
             viteDevServer: null,
-            vitePreviewServer: vitePreviewServer ?? null,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -97,16 +88,14 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             assert(configVike);
             objectAssign(globalContext, {
                 isPrerendering: true,
-                viteConfig,
-                configVike
+                viteConfig
             });
             globalObject.globalContext = globalContext;
         }
         else {
             objectAssign(globalContext, {
                 isPrerendering: false,
-                viteConfig: null,
-                configVike: null
+                viteConfig: null
             });
             globalObject.globalContext = globalContext;
         }
@@ -151,8 +140,11 @@ function assertNodeEnv(hasViteDevServer) {
     const nodeEnv = getNodeEnv();
     if (nodeEnv === null || nodeEnv === 'test')
         return;
-    const isDevNodeEnv = isNodeEnvDev();
-    // - Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    // - We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value).
-    assertUsage(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`);
+    const isDev = isNodeEnvDev();
+    // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    if (hasViteDevServer === isDev)
+        return;
+    const nodeEnvDesc = getNodeEnvDesc();
+    // We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value)
+    assertUsage(false, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`);
 }

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

@@ -85,8 +85,8 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     // See https://github.com/vikejs/vike/pull/1271
     const positionJavaScriptEntry = (() => {
         if (pageContext._pageContextPromise) {
-            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time as progressive hydration won't work", { onlyOnce: true });
-            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/stream#initial-data-after-stream-end
+            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time, because progressive hydration won't work.", { onlyOnce: true });
+            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/streaming#initial-data-after-stream-end
             return 'HTML_END';
         }
         if (injectToStream) {

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

@@ -181,7 +181,7 @@ async function renderTemplate(templateContent, pageContext) {
             const varType = typeof templateVar;
             const streamNote = ['boolean', 'number', 'bigint', 'symbol'].includes(varType)
                 ? null
-                : '(See https://vike.dev/stream for HTML streaming.)';
+                : '(See https://vike.dev/streaming for HTML streaming.)';
             assertUsage(varType === 'string', getErrMsg(pc.cyan(`typeof htmlVar === "${varType}"`), streamNote));
         }
         {

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

@@ -634,7 +634,7 @@ function isStream(something) {
 const __streamPipeWeb = '__streamPipeWeb';
 /** @deprecated */
 function pipeWebStream(pipe) {
-    assertWarning(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+    assertWarning(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
         showStackTrace: true
     });
@@ -669,7 +669,7 @@ function isStreamPipeWeb(thing) {
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
         showStackTrace: true
     });

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.d.ts

@@ -1,6 +1,6 @@
 export { getManifestEntry };
 import type { ViteManifest, ViteManifestEntry } from '../../../shared/ViteManifest.js';
-declare function getManifestEntry(id: string, clientManifest: ViteManifest, manifestKeyMap: Record<string, string>): {
+declare function getManifestEntry(id: string, clientManifest: ViteManifest): {
     manifestKey: string;
     manifestEntry: ViteManifestEntry;
 };

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

@@ -2,7 +2,8 @@ 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) {
     assertClientEntryId(id);
     const debugInfo = getDebugInfo(id, clientManifest);
     // Vike client entry
@@ -40,13 +41,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/retrieveAssetsProd.d.ts

@@ -1,4 +1,4 @@
 export { retrieveAssetsProd };
 import type { ViteManifest } from '../../../shared/ViteManifest.js';
 import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-declare function retrieveAssetsProd(clientDependencies: ClientDependency[], clientManifest: ViteManifest, includeAssetsImportedByServer: boolean, manifestKeyMap: Record<string, string>): string[];
+declare function retrieveAssetsProd(clientDependencies: ClientDependency[], clientManifest: ViteManifest, includeAssetsImportedByServer: boolean): string[];

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

@@ -2,7 +2,7 @@ export { retrieveAssetsProd };
 import { assert, isNpmPackageImport } from '../../utils.js';
 import { getManifestEntry } from './getManifestEntry.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
-function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImportedByServer, manifestKeyMap) {
+function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImportedByServer) {
     let assetUrls = new Set();
     assert(clientManifest);
     const visistedAssets = new Set();
@@ -19,7 +19,7 @@ function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImp
                 id = extractAssetsAddQuery(id);
             }
         }
-        const { manifestKey } = getManifestEntry(id, clientManifest, manifestKeyMap);
+        const { manifestKey } = getManifestEntry(id, clientManifest);
         collectAssets(manifestKey, assetUrls, visistedAssets, clientManifest, onlyAssets);
     });
     collectSingleStyle(assetUrls, clientManifest);

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';
@@ -14,15 +14,14 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     let assetUrls;
     let clientEntriesSrc;
     if (isDev) {
-        const { viteDevServer, configVike } = globalContext;
-        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer, configVike)));
+        const { viteDevServer } = globalContext;
+        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer)));
         assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
     }
     else {
-        const { pluginManifest, clientManifest } = globalContext;
-        const manifestKeyMap = pluginManifest.manifestKeyMap;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap));
-        assetUrls = retrieveAssetsProd(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer, manifestKeyMap);
+        const { clientManifest } = globalContext;
+        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest));
+        assetUrls = retrieveAssetsProd(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer);
     }
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
@@ -56,7 +55,7 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     sortPageAssetsForEarlyHintsHeader(pageAssets);
     return pageAssets;
 }
-async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
+async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     assertClientEntryId(clientEntry);
     let root = viteDevServer.config.root;
     assert(root);
@@ -77,7 +76,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 +88,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);
     }
@@ -121,8 +116,8 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
     assertPosixPath(filePath);
     return filePath;
 }
-function resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap) {
-    const { manifestEntry } = getManifestEntry(clientEntry, clientManifest, manifestKeyMap);
+function resolveClientEntriesProd(clientEntry, clientManifest) {
+    const { manifestEntry } = getManifestEntry(clientEntry, clientManifest);
     assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
     let { file } = manifestEntry;
     assert(!file.startsWith('/'));

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[];