vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

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

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpResponseBodyStreamHandlers = exports.getHttpResponseBody = void 0;
+const stream_js_1 = require("../html/stream.js");
+const utils_js_1 = require("../utils.js");
+const renderHtml_js_1 = require("../html/renderHtml.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const streamDocs = 'See https://vike.dev/stream for more information.';
+function getHttpResponseBody(htmlRender, renderHook) {
+    if (typeof htmlRender !== 'string') {
+        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} or ${picocolors_1.default.cyan('pageContext.httpResponse.getBody()')} instead`));
+    }
+    const body = htmlRender;
+    return body;
+}
+exports.getHttpResponseBody = getHttpResponseBody;
+function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
+    return {
+        async getBody() {
+            const body = await (0, renderHtml_js_1.getHtmlString)(htmlRender);
+            return body;
+        },
+        // TODO/v1-release: remove
+        async getNodeStream() {
+            (0, utils_js_1.assertWarning)(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.pipe()` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const nodeStream = await (0, stream_js_1.getStreamReadableNode)(htmlRender);
+            if (nodeStream === null) {
+                (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'getNodeStream()', getFixMsg('readable', 'node')));
+            }
+            return nodeStream;
+        },
+        // TODO/v1-release: remove
+        getWebStream() {
+            (0, utils_js_1.assertWarning)(false, '`pageContext.httpResponse.getWebStream(res)` is outdated, use `pageContext.httpResponse.getReadableWebStream(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const webStream = (0, stream_js_1.getStreamReadableWeb)(htmlRender);
+            if (webStream === null) {
+                (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'getWebStream()', getFixMsg('readable', 'web')));
+            }
+            return webStream;
+        },
+        getReadableWebStream() {
+            const webStream = (0, stream_js_1.getStreamReadableWeb)(htmlRender);
+            if (webStream === null) {
+                (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'getReadableWebStream()', getFixMsg('readable', 'web')));
+            }
+            return webStream;
+        },
+        // TODO/v1-release: remove
+        pipeToWebWritable(writable) {
+            (0, utils_js_1.assertWarning)(false, '`pageContext.httpResponse.pipeToWebWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const success = (0, stream_js_1.pipeToStreamWritableWeb)(htmlRender, writable);
+            if (!success) {
+                (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'pipeToWebWritable()'));
+            }
+        },
+        // TODO/v1-release: remove
+        pipeToNodeWritable(writable) {
+            (0, utils_js_1.assertWarning)(false, '`pageContext.httpResponse.pipeToNodeWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const success = (0, stream_js_1.pipeToStreamWritableNode)(htmlRender, writable);
+            if (!success) {
+                (0, utils_js_1.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 ((0, stream_js_1.isStreamWritableWeb)(writable)) {
+                const success = (0, stream_js_1.pipeToStreamWritableWeb)(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    (0, utils_js_1.assert)((0, stream_js_1.isStreamReadableWeb)(htmlRender) || (0, stream_js_1.isStreamPipeWeb)(htmlRender));
+                    (0, utils_js_1.assertUsage)(false, getErrMsgMixingStreamTypes('Web Writable'));
+                }
+            }
+            if ((0, stream_js_1.isStreamWritableNode)(writable)) {
+                const success = (0, stream_js_1.pipeToStreamWritableNode)(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    (0, utils_js_1.assert)((0, stream_js_1.isStreamReadableNode)(htmlRender) || (0, stream_js_1.isStreamPipeNode)(htmlRender));
+                    (0, utils_js_1.assertUsage)(false, getErrMsgMixingStreamTypes('Node.js Writable'));
+                }
+            }
+            (0, utils_js_1.assertUsage)(false, `The argument ${picocolors_1.default.cyan('writable')} passed to ${picocolors_1.default.cyan('pageContext.httpResponse.pipe(writable)')} doesn't seem to be ${(0, stream_js_1.getStreamName)('writable', 'web')} nor ${(0, stream_js_1.getStreamName)('writable', 'node')}.`);
+        }
+    };
+    function getFixMsg(type, standard) {
+        const streamName = (0, stream_js_1.getStreamName)(type, standard);
+        (0, utils_js_1.assert)(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
+        (0, utils_js_1.assert)(renderHook);
+        const { hookFilePath, hookName } = renderHook;
+        return `Make sure the ${hookName}() defined by ${hookFilePath} hook provides ${streamName} instead`;
+    }
+}
+exports.getHttpResponseBodyStreamHandlers = getHttpResponseBodyStreamHandlers;
+function getErrMsg(htmlRender, renderHook, method, msgAddendum) {
+    (0, utils_js_1.assert)(!msgAddendum || !msgAddendum.endsWith('.'));
+    const errMsgBody = getErrMsgBody(htmlRender, renderHook);
+    return [`pageContext.httpResponse.${method} can't be used because the ${errMsgBody}`, msgAddendum, streamDocs]
+        .filter(Boolean)
+        .join('. ');
+}
+function getErrMsgBody(htmlRender, renderHook) {
+    (0, utils_js_1.assert)(renderHook);
+    const { hookFilePath, hookName } = renderHook;
+    const hookReturnType = getHookReturnType(htmlRender);
+    (0, utils_js_1.assert)(['a ', 'an ', 'the '].some((s) => hookReturnType.startsWith(s)));
+    const errMsgBody = `${hookName}()\ hook defined by ${hookFilePath} provides ${hookReturnType}`;
+    (0, utils_js_1.assert)(!errMsgBody.endsWith(' '));
+    return errMsgBody;
+}
+function getHookReturnType(htmlRender) {
+    if (typeof htmlRender === 'string') {
+        return 'an HTML string';
+    }
+    else if ((0, stream_js_1.isStream)(htmlRender)) {
+        return (0, stream_js_1.inferStreamName)(htmlRender);
+    }
+    else {
+        (0, utils_js_1.assert)(false);
+    }
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertClientEntryId = void 0;
+const globalContext_js_1 = require("../../globalContext.js");
+const utils_js_1 = require("../../utils.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+function assertClientEntryId(id) {
+    (0, utils_js_1.assertPosixPath)(id);
+    (0, utils_js_1.assert)(!id.startsWith('/@fs'), id);
+    const isPkg = (0, utils_js_1.isNpmPackageImport)(id);
+    (0, utils_js_1.assert)(
+    // Client entry
+    id.startsWith('@@vike/') ||
+        // User files
+        id.startsWith('/') ||
+        // Page code importer
+        (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id) ||
+        // Stem packages
+        isPkg, id);
+    if (isPkg) {
+        const { configVike } = (0, globalContext_js_1.getGlobalContext)();
+        (0, utils_js_1.assert)(configVike === null || configVike.extensions.some(({ npmPackageName }) => id.startsWith(npmPackageName)), id);
+    }
+}
+exports.assertClientEntryId = assertClientEntryId;

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManifestEntry = void 0;
+const utils_js_1 = require("../../utils.js");
+const assertClientEntryId_js_1 = require("./assertClientEntryId.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+function getManifestEntry(id, clientManifest, manifestKeyMap) {
+    (0, assertClientEntryId_js_1.assertClientEntryId)(id);
+    const debugInfo = getDebugInfo(id, clientManifest);
+    // Vike client entry
+    if (id.startsWith('@@vike/')) {
+        const manifestKeyEnd = (0, utils_js_1.slice)(id, '@@vike'.length, 0);
+        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        (0, utils_js_1.assert)(manifestEntry && manifestKey, debugInfo);
+        return { manifestEntry, manifestKey };
+    }
+    // Page code importer
+    if ((0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id)) {
+        {
+            const manifestKey = id;
+            const manifestEntry = clientManifest[manifestKey];
+            if (manifestEntry) {
+                return { manifestEntry, manifestKey };
+            }
+        }
+        // Workaround for what seems to be a Vite bug when process.cwd() !== config.root
+        //  - Manifest key is:
+        //       ../../virtual:vike:pageConfigValuesAll:client:/pages/index
+        //    But it should be this instead:
+        //      virtual:vike:pageConfigValuesAll:client:/pages/index
+        //  - This workaround was implemented to support Vitest runnung /tests/*
+        //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
+        const manifestKeyEnd = id;
+        const { manifestKey, manifestEntry } = getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        (0, utils_js_1.assert)(manifestEntry, debugInfo);
+        return { manifestEntry, manifestKey };
+    }
+    // User files
+    if (id.startsWith('/')) {
+        const manifestKey = id.slice(1);
+        let manifestEntry = clientManifest[manifestKey];
+        (0, utils_js_1.assert)(manifestEntry, debugInfo);
+        return { manifestEntry, manifestKey };
+    }
+    // extensions[number].pageConfigsDistFiles
+    if ((0, utils_js_1.isNpmPackageImport)(id)) {
+        const manifestKey = manifestKeyMap[id];
+        const debugInfo2 = { ...debugInfo, manifestKey };
+        (0, utils_js_1.assert)(manifestKey, debugInfo2);
+        const manifestEntry = clientManifest[manifestKey];
+        (0, utils_js_1.assert)(manifestEntry, debugInfo2);
+        return { manifestEntry, manifestKey };
+    }
+    // extensions[number].pageConfigsSrcDir
+    if (id.startsWith('/node_modules/') || id.startsWith('/../')) {
+        let manifestKeyEnd = id.split('/node_modules/').slice(-1)[0];
+        (0, utils_js_1.assert)(manifestKeyEnd, debugInfo);
+        (0, utils_js_1.assert)(!manifestKeyEnd.startsWith('/'), debugInfo);
+        manifestKeyEnd = '/' + manifestKeyEnd;
+        {
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            if (manifestEntry) {
+                (0, utils_js_1.assert)(manifestKey, debugInfo);
+                return { manifestEntry, manifestKey };
+            }
+        }
+        {
+            (0, utils_js_1.assert)(manifestKeyEnd.startsWith('/'), debugInfo);
+            const dirS = manifestKeyEnd.split('/');
+            (0, utils_js_1.assert)(dirS[0] === '', debugInfo);
+            manifestKeyEnd = '/' + dirS.slice(2).join('/');
+            (0, utils_js_1.assert)(manifestKeyEnd.startsWith('/'), debugInfo);
+        }
+        {
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            if (manifestEntry) {
+                (0, utils_js_1.assert)(manifestKey, debugInfo);
+                return { manifestEntry, manifestKey };
+            }
+        }
+        (0, utils_js_1.assert)(false, debugInfo);
+    }
+    (0, utils_js_1.assert)(false, debugInfo);
+}
+exports.getManifestEntry = getManifestEntry;
+function findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
+    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+    (0, utils_js_1.assert)(manifestKeyEnd.startsWith('/'), debugInfo);
+    const manifestKeys = [];
+    for (const manifestKey in clientManifest) {
+        if (manifestKey.endsWith(manifestKeyEnd)) {
+            manifestKeys.push(manifestKey);
+        }
+    }
+    const manifestKeysRelative = manifestKeys.filter((k) => k.startsWith('../'));
+    (0, utils_js_1.assert)(manifestKeysRelative.length <= 1, debugInfo);
+    const manifestKey = manifestKeysRelative[0] ?? manifestKeys[0] ?? null;
+    if (!manifestKey) {
+        return { manifestEntry: null, manifestKey: null };
+    }
+    const manifestEntry = clientManifest[manifestKey];
+    return { manifestEntry, manifestKey };
+}
+function getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
+    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+    const manifestKeys = [];
+    for (const manifestKey in clientManifest) {
+        if (manifestKey.endsWith(manifestKeyEnd)) {
+            manifestKeys.push(manifestKey);
+        }
+    }
+    (0, utils_js_1.assert)(manifestKeys.length <= 1, debugInfo);
+    const manifestKey = manifestKeys[0];
+    if (!manifestKey) {
+        return { manifestEntry: null, manifestKey: null };
+    }
+    const manifestEntry = clientManifest[manifestKey];
+    return { manifestEntry, manifestKey };
+}
+function getDebugInfo(id, clientManifest, manifestKeyEnd) {
+    const manifestKeys = Object.keys(clientManifest);
+    if (manifestKeyEnd === undefined) {
+        return { manifestKeys, id };
+    }
+    else {
+        return { manifestKeys, manifestKeyEnd, id };
+    }
+}

package/dist/cjs/node/runtime/renderPage/getPageAssets/retrieveAssetsDev.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveAssetsDev = void 0;
+const utils_js_1 = require("../../utils.js");
+async function retrieveAssetsDev(clientDependencies, viteDevServer) {
+    const visitedModules = new Set();
+    const assetUrls = new Set();
+    await Promise.all(clientDependencies.map(async ({ id }) => {
+        if (id.startsWith('@@vike'))
+            return; // vike doesn't have any CSS
+        (0, utils_js_1.assert)(id);
+        const { moduleGraph } = viteDevServer;
+        const [_, graphId] = await moduleGraph.resolveUrl(id);
+        (0, utils_js_1.assert)(graphId, { id });
+        const mod = moduleGraph.getModuleById(graphId);
+        if (!mod) {
+            /* Not sure when the assertion fails. So let's just remove it for now.
+             *  - https://github.com/vikejs/vike/issues/391
+            // `moduleGraph` is missing `.page.client.js` files on the very first render
+            assert(id.includes('.page.client.'), { id })
+            */
+            return;
+        }
+        (0, utils_js_1.assert)(mod, { id });
+        collectCss(mod, assetUrls, visitedModules);
+    }));
+    return Array.from(assetUrls);
+}
+exports.retrieveAssetsDev = retrieveAssetsDev;
+// Collect the CSS to be injected to the HTML to avoid FLOUC
+//  - We only collect the root import: https://github.com/vikejs/vike/issues/400
+function collectCss(mod, styleUrls, visitedModules, importer) {
+    (0, utils_js_1.assert)(mod);
+    if (!mod.url)
+        return;
+    if (visitedModules.has(mod.url))
+        return;
+    visitedModules.add(mod.url);
+    if (isStyle(mod) && (!importer || !isStyle(importer))) {
+        if (mod.url.startsWith('/')) {
+            styleUrls.add(mod.url);
+        }
+        else {
+            // Vuetify uses virtual SCSS modules which we skip
+            //  - We skip because `<link rel="stylesheet" type="text/css" href="virtual-module.css">` doesn't work
+            //  - Reproduction: https://github.com/vikejs/vike/issues/479
+            //  - Possible workaround: `<script>import 'virtual-module.css'</script>`
+            // logModule(mod)
+        }
+    }
+    mod.importedModules.forEach((dep) => {
+        collectCss(dep, styleUrls, visitedModules, mod);
+    });
+}
+function isStyle(mod) {
+    if (utils_js_1.styleFileRE.test(mod.url) || (mod.id && /\?vue&type=style/.test(mod.id))) {
+        // `mod.type` seems broken
+        (0, utils_js_1.assert)(mod.type === 'js');
+        // logModule(mod)
+        return true;
+    }
+    return false;
+}
+/*
+function logModule(mod: ModuleNode) {
+  const redacted = 'redacted'
+  console.log({
+    ...mod,
+    ssrModule: redacted,
+    ssrTransformResult: redacted,
+    importedModules: redacted,
+    importers: redacted
+  })
+}
+//*/

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveAssetsProd = void 0;
+const utils_js_1 = require("../../utils.js");
+const getManifestEntry_js_1 = require("./getManifestEntry.js");
+const extractAssetsQuery_js_1 = require("../../../shared/extractAssetsQuery.js");
+function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImportedByServer, manifestKeyMap) {
+    let assetUrls = new Set();
+    (0, utils_js_1.assert)(clientManifest);
+    const visistedAssets = new Set();
+    clientDependencies.forEach(({ id, onlyAssets, eagerlyImported }) => {
+        if (eagerlyImported)
+            return; // Eagerly imported assets aren't imported with import() and therefore don't create a new Rollup entry and aren't listed in the manifest file
+        if (onlyAssets) {
+            if (!includeAssetsImportedByServer)
+                return;
+            // We assume that all npm packages have already built their Vike page files.
+            //  - Bundlers (Rollup, esbuild, tsup, ...) extract the CSS out of JavaScript => we can assume JavaScript to not import any CSS/assets
+            if ((0, utils_js_1.isNpmPackageImport)(id))
+                return;
+            if (id.includes('.page.server.')) {
+                id = (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(id);
+            }
+        }
+        const { manifestKey } = (0, getManifestEntry_js_1.getManifestEntry)(id, clientManifest, manifestKeyMap);
+        collectAssets(manifestKey, assetUrls, visistedAssets, clientManifest, onlyAssets);
+    });
+    collectSingleStyle(assetUrls, clientManifest);
+    return Array.from(assetUrls);
+}
+exports.retrieveAssetsProd = retrieveAssetsProd;
+function collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCollectStaticAssets) {
+    if (visistedAssets.has(manifestKey))
+        return;
+    visistedAssets.add(manifestKey);
+    const manifestEntry = manifest[manifestKey];
+    (0, utils_js_1.assert)(manifestEntry, { manifestKey });
+    const { file } = manifestEntry;
+    if (!onlyCollectStaticAssets) {
+        assetUrls.add(`/${file}`);
+    }
+    const { imports = [], assets = [], css = [] } = manifestEntry;
+    for (const manifestKey of imports) {
+        const importManifestEntry = manifest[manifestKey];
+        (0, utils_js_1.assert)(importManifestEntry);
+        collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCollectStaticAssets);
+    }
+    for (const cssAsset of css) {
+        assetUrls.add(`/${cssAsset}`);
+    }
+    for (const asset of assets) {
+        assetUrls.add(`/${asset}`);
+    }
+}
+// Support `config.build.cssCodeSplit: false`, https://github.com/vikejs/vike/issues/644
+function collectSingleStyle(assetUrls, manifest) {
+    const style = manifest['style.css'];
+    if (style && Object.values(manifest).filter((asset) => asset.file.endsWith('.css')).length === 1) {
+        assetUrls.add(`/${style.file}`);
+    }
+}

package/dist/cjs/node/runtime/renderPage/getPageAssets/sortPageAssetsForEarlyHintsHeader.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortPageAssetsForEarlyHintsHeader = void 0;
+const globalContext_js_1 = require("../../globalContext.js");
+const utils_js_1 = require("../../utils.js");
+function sortPageAssetsForEarlyHintsHeader(pageAssets) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    pageAssets.sort((0, utils_js_1.higherFirst)(({ assetType }) => {
+        // In dev, we load scripts first in order to parallelize I/O and CPU
+        if (!globalContext.isProduction && assetType === 'script') {
+            return 1;
+        }
+        let priority = 0;
+        // CSS has highest priority
+        if (assetType === 'style')
+            return priority;
+        priority--;
+        // Visual assets have high priority
+        if (assetType === 'font')
+            return priority;
+        priority--;
+        if (assetType === 'image')
+            return priority;
+        priority--;
+        // Others
+        if (assetType !== 'script')
+            return priority;
+        priority--;
+        // JavaScript has lowest priority
+        return priority;
+    }));
+}
+exports.sortPageAssetsForEarlyHintsHeader = sortPageAssetsForEarlyHintsHeader;

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageAssets = void 0;
+const utils_js_1 = require("../utils.js");
+const retrieveAssetsDev_js_1 = require("./getPageAssets/retrieveAssetsDev.js");
+const retrieveAssetsProd_js_1 = require("./getPageAssets/retrieveAssetsProd.js");
+const inferMediaType_js_1 = require("./inferMediaType.js");
+const getManifestEntry_js_1 = require("./getPageAssets/getManifestEntry.js");
+const sortPageAssetsForEarlyHintsHeader_js_1 = require("./getPageAssets/sortPageAssetsForEarlyHintsHeader.js");
+const globalContext_js_1 = require("../globalContext.js");
+const assertClientEntryId_js_1 = require("./getPageAssets/assertClientEntryId.js");
+const import_1 = require("@brillout/import");
+async function getPageAssets(pageContext, clientDependencies, clientEntries) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const isDev = !globalContext.isProduction;
+    let assetUrls;
+    let clientEntriesSrc;
+    if (isDev) {
+        const { viteDevServer, configVike } = globalContext;
+        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer, configVike)));
+        assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
+    }
+    else {
+        const { pluginManifest, clientManifest } = globalContext;
+        const manifestKeyMap = pluginManifest.manifestKeyMap;
+        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap));
+        assetUrls = (0, retrieveAssetsProd_js_1.retrieveAssetsProd)(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer, manifestKeyMap);
+    }
+    let pageAssets = [];
+    (0, utils_js_1.unique)([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
+        const { mediaType = null, assetType = null } = (0, inferMediaType_js_1.inferMediaType)(src) || {};
+        if (isDev && assetType === 'style') {
+            // https://github.com/vikejs/vike/issues/449
+            if (src.endsWith('?inline')) {
+                return;
+            }
+            // https://github.com/vikejs/vike/issues/401
+            src = src + '?direct';
+        }
+        const isEntry = clientEntriesSrc.includes(src) ||
+            // Vite automatically injects CSS, not only in development, but also in production (albeit with a FOUC). Therefore, strictly speaking, CSS aren't entries. We still, however, set `isEntry: true` for CSS, in order to denote page assets that should absolutely be injected in the HTML, regardless of preload strategy (not injecting CSS leads to FOUC).
+            assetType === 'style';
+        pageAssets.push({
+            src,
+            assetType,
+            mediaType,
+            isEntry
+        });
+    });
+    pageAssets.forEach(({ src }) => {
+        (0, utils_js_1.assert)(1 === pageAssets.filter((p) => p.src === src).length);
+    });
+    pageAssets = pageAssets.map((pageAsset) => {
+        const baseServerAssets = pageContext._baseAssets || pageContext._baseServer;
+        pageAsset.src = (0, utils_js_1.prependBase)((0, utils_js_1.toPosixPath)(pageAsset.src), baseServerAssets);
+        return pageAsset;
+    });
+    (0, sortPageAssetsForEarlyHintsHeader_js_1.sortPageAssetsForEarlyHintsHeader)(pageAssets);
+    return pageAssets;
+}
+exports.getPageAssets = getPageAssets;
+async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
+    (0, assertClientEntryId_js_1.assertClientEntryId)(clientEntry);
+    let root = viteDevServer.config.root;
+    (0, utils_js_1.assert)(root);
+    root = (0, utils_js_1.toPosixPath)(root);
+    // The `?import` suffix is needed for MDX to be transpiled:
+    //   - Not transpiled: `/pages/markdown.page.mdx`
+    //   - Transpiled: `/pages/markdown.page.mdx?import`
+    // But `?import` doesn't work with `/@fs/`:
+    //   - Not transpiled: /@fs/home/runner/work/vike/vike/examples/react-full/pages/markdown.page.mdx
+    //   - Not transpiled: /@fs/home/runner/work/vike/vike/examples/react-full/pages/markdown.page.mdx?import
+    if (clientEntry.endsWith('?import')) {
+        (0, utils_js_1.assert)(clientEntry.startsWith('/'));
+        return clientEntry;
+    }
+    (0, utils_js_1.assertPosixPath)(clientEntry);
+    let filePath;
+    if (clientEntry.startsWith('/')) {
+        // User files
+        filePath = (0, utils_js_1.pathJoin)(root, clientEntry);
+    }
+    else if (clientEntry.startsWith('@@vike/')) {
+        // Vike client entry
+        const { createRequire } = (await (0, import_1.import_)('module')).default;
+        const { dirname } = (await (0, import_1.import_)('path')).default;
+        const { fileURLToPath } = (await (0, import_1.import_)('url')).default;
+        // @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+        const importMetaUrl = `file://${__filename}`;
+        const require_ = createRequire(importMetaUrl);
+        const __dirname_ = dirname(fileURLToPath(importMetaUrl));
+        // @ts-expect-error
+        // Bun workaround https://github.com/vikejs/vike/pull/1048
+        const res = typeof Bun !== 'undefined' ? (toPath) => Bun.resolveSync(toPath, __dirname_) : require_.resolve;
+        (0, utils_js_1.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 = (0, utils_js_1.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 = (0, utils_js_1.toPosixPath)(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/')));
+        }
+    }
+    else if ((0, utils_js_1.isNpmPackageImport)(clientEntry)) {
+        const extensionPageFile = configVike.extensions
+            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+            .flat()
+            .filter(utils_js_1.isNotNullish)
+            .find((e) => e.importPath === clientEntry);
+        (0, utils_js_1.assert)(extensionPageFile, clientEntry);
+        filePath = extensionPageFile.filePath;
+    }
+    else {
+        (0, utils_js_1.assert)(false);
+    }
+    if (!filePath.startsWith('/')) {
+        (0, utils_js_1.assert)(process.platform === 'win32');
+        filePath = '/' + filePath;
+    }
+    filePath = '/@fs' + filePath;
+    (0, utils_js_1.assertPosixPath)(filePath);
+    return filePath;
+}
+function resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap) {
+    const { manifestEntry } = (0, getManifestEntry_js_1.getManifestEntry)(clientEntry, clientManifest, manifestKeyMap);
+    (0, utils_js_1.assert)(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
+    let { file } = manifestEntry;
+    (0, utils_js_1.assert)(!file.startsWith('/'));
+    return '/' + file;
+}

package/dist/cjs/node/runtime/renderPage/handleErrorWithoutErrorPage.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrorWithoutErrorPage = void 0;
+const stringify_1 = require("@brillout/json-serializer/stringify");
+const globalContext_js_1 = require("../globalContext.js");
+const utils_js_1 = require("../utils.js");
+const createHttpResponseObject_js_1 = require("./createHttpResponseObject.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// When the user hasn't defined _error.page.js
+async function handleErrorWithoutErrorPage(pageContext) {
+    (0, utils_js_1.assert)(pageContext._pageId === null);
+    (0, utils_js_1.assert)(pageContext.errorWhileRendering || pageContext.is404);
+    {
+        const isV1 = pageContext._pageConfigs.length > 0;
+        warnMissingErrorPage(isV1);
+    }
+    if (!pageContext.isClientSideNavigation) {
+        (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
+        return pageContext;
+    }
+    else {
+        const __getPageAssets = async () => [];
+        (0, utils_js_1.objectAssign)(pageContext, { __getPageAssets });
+        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponseObject)((0, stringify_1.stringify)({ serverSideError: true }), null, pageContext);
+        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+        return pageContext;
+    }
+}
+exports.handleErrorWithoutErrorPage = handleErrorWithoutErrorPage;
+function warnMissingErrorPage(isV1) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    if (!globalContext.isProduction) {
+        const msg = [
+            `No ${isV1 ? 'error page' : picocolors_1.default.cyan('_error.page.js')} found,`,
+            'we recommend defining an error page,',
+            'see https://vike.dev/error-page'
+        ].join(' ');
+        (0, utils_js_1.assertWarning)(false, msg, { onlyOnce: true });
+    }
+}