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

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

@@ -0,0 +1,133 @@
+export { executeOnRenderHtmlHook };
+import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape } from '../html/renderHtml.js';
+import { getHook } from '../../../shared/hooks/getHook.js';
+import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, executeHook, isCallable } from '../utils.js';
+import { isStream } from '../html/stream.js';
+import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
+import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObject.js';
+import { logRuntimeError } from './loggerRuntime.js';
+import pc from '@brillout/picocolors';
+async function executeOnRenderHtmlHook(pageContext) {
+    const hookFound = getRenderHook(pageContext);
+    const { renderHook, hookFn } = hookFound;
+    objectAssign(pageContext, { _renderHook: renderHook });
+    preparePageContextForUserConsumptionServerSide(pageContext);
+    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
+    Object.assign(pageContext, pageContextProvidedByRenderHook);
+    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
+    if (documentHtml === null || documentHtml === undefined) {
+        return { htmlRender: null, renderHook };
+    }
+    const onErrorWhileStreaming = (err) => {
+        // Should the stream inject the following?
+        // ```
+        // <script>console.error("An error occurred on the server while streaming the app to HTML. Check the server logs for more information.")</script>
+        // ```
+        logRuntimeError(err, pageContext._httpRequestId);
+        if (!pageContext.errorWhileRendering) {
+            pageContext.errorWhileRendering = err;
+        }
+    };
+    const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
+    assert(typeof htmlRender === 'string' || isStream(htmlRender));
+    return { htmlRender, renderHook };
+}
+function getRenderHook(pageContext) {
+    let hookFound;
+    {
+        let hook;
+        let hookName = undefined;
+        hook = getHook(pageContext, 'onRenderHtml');
+        if (hook) {
+            hookName = 'onRenderHtml';
+        }
+        else {
+            hook = getHook(pageContext, 'render');
+            if (hook) {
+                hookName = 'render';
+            }
+        }
+        if (hook) {
+            assert(hookName);
+            const { hookFilePath, hookFn } = hook;
+            hookFound = {
+                hookFn,
+                renderHook: { hookFilePath, hookName }
+            };
+        }
+    }
+    if (!hookFound) {
+        const hookName = pageContext._pageConfigs.length > 0 ? 'onRenderHtml' : 'render';
+        assertUsage(false, [
+            `No ${hookName}() hook found, see https://vike.dev/${hookName}`
+            /*
+          'See https://vike.dev/render-modes for more information.',
+          [
+            // 'Loaded config files (none of them define the onRenderHtml() hook):',
+            'Loaded server-side page files (none of them `export { render }`):',
+            ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
+          ].join('\n')
+          */
+        ].join(' '));
+    }
+    return hookFound;
+}
+function processHookReturnValue(hookReturnValue, renderHook) {
+    let documentHtml = null;
+    let pageContextPromise = null;
+    let pageContextProvidedByRenderHook = null;
+    let injectFilter = null;
+    const ret = () => ({ documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter });
+    if (hookReturnValue === null)
+        return ret();
+    if (isDocumentHtml(hookReturnValue)) {
+        documentHtml = hookReturnValue;
+        return ret();
+    }
+    const errPrefix = `The ${renderHook.hookName}() hook defined at ${renderHook.hookFilePath}`;
+    const errSuffix = `a string generated with the ${pc.cyan('escapeInject`<html>...</html>`')} template tag or a string returned by ${pc.cyan('dangerouslySkipEscape()')}, see https://vike.dev/escapeInject`;
+    if (typeof hookReturnValue === 'string') {
+        assertWarning(false, [errPrefix, 'returned a plain JavaScript string which is dangerous: it should instead return', errSuffix].join(' '), { onlyOnce: true });
+        hookReturnValue = dangerouslySkipEscape(hookReturnValue);
+    }
+    assertUsage(isObject(hookReturnValue), [
+        errPrefix,
+        `should return ${pc.cyan('null')}, the value ${pc.cyan('documentHtml')}, or an object ${pc.cyan('{ documentHtml, pageContext }')} where ${pc.cyan('pageContext')} is ${pc.cyan('undefined')} or an object holding additional pageContext values, and where ${pc.cyan('documentHtml')} is`,
+        errSuffix
+    ].join(' '));
+    assertHookReturnedObject(hookReturnValue, ['documentHtml', 'pageContext', 'injectFilter'], errPrefix);
+    if (hookReturnValue.injectFilter) {
+        assertUsage(isCallable(hookReturnValue.injectFilter), 'injectFilter should be a function');
+        injectFilter = hookReturnValue.injectFilter;
+    }
+    if (hookReturnValue.documentHtml) {
+        let val = hookReturnValue.documentHtml;
+        const errBegin = `${errPrefix} returned ${pc.cyan('{ documentHtml }')}, but ${pc.cyan('documentHtml')}`;
+        if (typeof val === 'string') {
+            assertWarning(false, [
+                errBegin,
+                `is a plain JavaScript string which is dangerous: ${pc.cyan('documentHtml')} should be`,
+                errSuffix
+            ].join(' '), { onlyOnce: true });
+            val = dangerouslySkipEscape(val);
+        }
+        assertUsage(isDocumentHtml(val), [errBegin, 'should be', errSuffix].join(' '));
+        documentHtml = val;
+    }
+    if (hookReturnValue.pageContext) {
+        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 });
+            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`);
+            assertPageContextProvidedByUser(val, renderHook);
+            pageContextProvidedByRenderHook = val;
+        }
+    }
+    return ret();
+}

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

@@ -0,0 +1,7 @@
+export { getEarlyHints };
+export type { EarlyHint };
+import type { PageAsset } from './getPageAssets.js';
+type EarlyHint = PageAsset & {
+    earlyHintLink: string;
+};
+declare function getEarlyHints(assets: PageAsset[]): EarlyHint[];

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

@@ -0,0 +1,43 @@
+export { getEarlyHints };
+import { inferEarlyHintLink } from '../html/injectAssets/inferHtmlTags.js';
+import { assert } from '../utils.js';
+function getEarlyHints(assets) {
+    const earlyHints = [];
+    {
+        assets.forEach((asset) => {
+            // Don't early hint fallback fonts, https://github.com/vikejs/vike/issues/624
+            if (isFontFallback(asset, earlyHints))
+                return;
+            earlyHints.push({
+                ...asset,
+                earlyHintLink: inferEarlyHintLink(asset)
+            });
+        });
+    }
+    return earlyHints;
+}
+function isFontFallback(asset, earlyHints) {
+    if (asset.assetType !== 'font') {
+        return false;
+    }
+    const fontUrlBase = removeFileExtentionAndHash(asset.src);
+    return earlyHints.some((hint) => {
+        return hint.assetType === 'font' && removeFileExtentionAndHash(hint.src) === fontUrlBase;
+    });
+}
+function removeFileExtentionAndHash(assetUrl) {
+    assert(!assetUrl.includes('\\'));
+    // The logic below doesn't work for '/assets/chunk-0e184ced.js'
+    assert(!assetUrl.endsWith('.js'));
+    const paths = assetUrl.split('/');
+    {
+        const filename = paths[paths.length - 1];
+        const filenameParts = filename.split('.');
+        assert(filenameParts.length >= 2);
+        // User may set config.build.rollupOptions.output.assetFileNames => we can't assume the filename to be `*.${hash}.${ext}`
+        const filenameBase = filenameParts.slice(0, filenameParts.length === 2 ? -1 : -2);
+        assert(filenameBase.length >= 1);
+        paths[paths.length - 1] = filenameBase.join('.');
+    }
+    return paths.join('/');
+}

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

@@ -0,0 +1,31 @@
+/// <reference types="node" resolution-mode="require"/>
+export { getHttpResponseBody };
+export { getHttpResponseBodyStreamHandlers };
+export type { HttpResponseBody };
+import { StreamPipeNode, StreamPipeWeb, StreamReadableNode, StreamReadableWeb, StreamWritableNode, StreamWritableWeb } from '../html/stream.js';
+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;
+    /** @deprecated */
+    getNodeStream: () => Promise<StreamReadableNode>;
+    /** @deprecated */
+    getWebStream: () => StreamReadableWeb;
+    /** @deprecated */
+    pipeToNodeWritable: StreamPipeNode;
+    /** @deprecated */
+    pipeToWebWritable: StreamPipeWeb;
+};
+declare function getHttpResponseBody(htmlRender: HtmlRender, renderHook: null | RenderHook): string;
+declare function getHttpResponseBodyStreamHandlers(htmlRender: HtmlRender, renderHook: null | RenderHook): {
+    getBody(): Promise<string>;
+    getNodeStream(): Promise<import("stream").Readable>;
+    getWebStream(): StreamReadableWeb;
+    getReadableWebStream(): StreamReadableWeb;
+    pipeToWebWritable(writable: StreamWritableWeb): void;
+    pipeToNodeWritable(writable: StreamWritableNode): void;
+    pipe(writable: StreamWritableNode | StreamWritableWeb): void;
+};

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

@@ -0,0 +1,125 @@
+export { getHttpResponseBody };
+export { getHttpResponseBodyStreamHandlers };
+import { isStream, getStreamName, inferStreamName, isStreamWritableWeb, isStreamWritableNode, isStreamReadableWeb, isStreamReadableNode, isStreamPipeWeb, isStreamPipeNode, getStreamReadableNode, getStreamReadableWeb, pipeToStreamWritableWeb, pipeToStreamWritableNode } from '../html/stream.js';
+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.';
+function getHttpResponseBody(htmlRender, renderHook) {
+    if (typeof htmlRender !== 'string') {
+        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} or ${pc.cyan('pageContext.httpResponse.getBody()')} instead`));
+    }
+    const body = htmlRender;
+    return body;
+}
+function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
+    return {
+        async getBody() {
+            const body = await getHtmlString(htmlRender);
+            return body;
+        },
+        // TODO/v1-release: remove
+        async getNodeStream() {
+            assertWarning(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.pipe()` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const nodeStream = await getStreamReadableNode(htmlRender);
+            if (nodeStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getNodeStream()', getFixMsg('readable', 'node')));
+            }
+            return nodeStream;
+        },
+        // TODO/v1-release: remove
+        getWebStream() {
+            assertWarning(false, '`pageContext.httpResponse.getWebStream(res)` is outdated, use `pageContext.httpResponse.getReadableWebStream(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const webStream = getStreamReadableWeb(htmlRender);
+            if (webStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getWebStream()', getFixMsg('readable', 'web')));
+            }
+            return webStream;
+        },
+        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. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const success = pipeToStreamWritableWeb(htmlRender, writable);
+            if (!success) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToWebWritable()'));
+            }
+        },
+        // TODO/v1-release: remove
+        pipeToNodeWritable(writable) {
+            assertWarning(false, '`pageContext.httpResponse.pipeToNodeWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const success = pipeToStreamWritableNode(htmlRender, writable);
+            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(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
+                    assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
+                }
+            }
+            if (isStreamWritableNode(writable)) {
+                const success = pipeToStreamWritableNode(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(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) {
+        const streamName = getStreamName(type, standard);
+        assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
+        assert(renderHook);
+        const { hookFilePath, hookName } = renderHook;
+        return `Make sure the ${hookName}() defined by ${hookFilePath} hook provides ${streamName} instead`;
+    }
+}
+function getErrMsg(htmlRender, renderHook, method, msgAddendum) {
+    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) {
+    assert(renderHook);
+    const { hookFilePath, hookName } = renderHook;
+    const hookReturnType = getHookReturnType(htmlRender);
+    assert(['a ', 'an ', 'the '].some((s) => hookReturnType.startsWith(s)));
+    const errMsgBody = `${hookName}()\ hook defined by ${hookFilePath} provides ${hookReturnType}`;
+    assert(!errMsgBody.endsWith(' '));
+    return errMsgBody;
+}
+function getHookReturnType(htmlRender) {
+    if (typeof htmlRender === 'string') {
+        return 'an HTML string';
+    }
+    else if (isStream(htmlRender)) {
+        return inferStreamName(htmlRender);
+    }
+    else {
+        assert(false);
+    }
+}

package/dist/esm/node/runtime/renderPage/getPageAssets/assertClientEntryId.d.ts

@@ -0,0 +1,2 @@
+export { assertClientEntryId };
+declare function assertClientEntryId(id: string): void;

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

@@ -0,0 +1,22 @@
+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) {
+    assertPosixPath(id);
+    assert(!id.startsWith('/@fs'), id);
+    const isPkg = isNpmPackageImport(id);
+    assert(
+    // Client entry
+    id.startsWith('@@vike/') ||
+        // User files
+        id.startsWith('/') ||
+        // Page code importer
+        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

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

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

@@ -0,0 +1,125 @@
+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) {
+    assertClientEntryId(id);
+    const debugInfo = getDebugInfo(id, clientManifest);
+    // Vike client entry
+    if (id.startsWith('@@vike/')) {
+        const manifestKeyEnd = slice(id, '@@vike'.length, 0);
+        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        assert(manifestEntry && manifestKey, debugInfo);
+        return { manifestEntry, manifestKey };
+    }
+    // Page code importer
+    if (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);
+        assert(manifestEntry, debugInfo);
+        return { manifestEntry, manifestKey };
+    }
+    // User files
+    if (id.startsWith('/')) {
+        const manifestKey = id.slice(1);
+        let manifestEntry = clientManifest[manifestKey];
+        assert(manifestEntry, debugInfo);
+        return { manifestEntry, manifestKey };
+    }
+    // extensions[number].pageConfigsDistFiles
+    if (isNpmPackageImport(id)) {
+        const manifestKey = manifestKeyMap[id];
+        const debugInfo2 = { ...debugInfo, manifestKey };
+        assert(manifestKey, debugInfo2);
+        const manifestEntry = clientManifest[manifestKey];
+        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];
+        assert(manifestKeyEnd, debugInfo);
+        assert(!manifestKeyEnd.startsWith('/'), debugInfo);
+        manifestKeyEnd = '/' + manifestKeyEnd;
+        {
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            if (manifestEntry) {
+                assert(manifestKey, debugInfo);
+                return { manifestEntry, manifestKey };
+            }
+        }
+        {
+            assert(manifestKeyEnd.startsWith('/'), debugInfo);
+            const dirS = manifestKeyEnd.split('/');
+            assert(dirS[0] === '', debugInfo);
+            manifestKeyEnd = '/' + dirS.slice(2).join('/');
+            assert(manifestKeyEnd.startsWith('/'), debugInfo);
+        }
+        {
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            if (manifestEntry) {
+                assert(manifestKey, debugInfo);
+                return { manifestEntry, manifestKey };
+            }
+        }
+        assert(false, debugInfo);
+    }
+    assert(false, debugInfo);
+}
+function findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
+    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+    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('../'));
+    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);
+        }
+    }
+    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/esm/node/runtime/renderPage/getPageAssets/retrieveAssetsDev.d.ts

@@ -0,0 +1,4 @@
+export { retrieveAssetsDev };
+import type { ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+declare function retrieveAssetsDev(clientDependencies: ClientDependency[], viteDevServer: ViteDevServer): Promise<string[]>;

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

@@ -0,0 +1,72 @@
+export { retrieveAssetsDev };
+import { assert, styleFileRE } from '../../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
+        assert(id);
+        const { moduleGraph } = viteDevServer;
+        const [_, graphId] = await moduleGraph.resolveUrl(id);
+        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;
+        }
+        assert(mod, { id });
+        collectCss(mod, assetUrls, visitedModules);
+    }));
+    return Array.from(assetUrls);
+}
+// 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) {
+    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 (styleFileRE.test(mod.url) || (mod.id && /\?vue&type=style/.test(mod.id))) {
+        // `mod.type` seems broken
+        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/esm/node/runtime/renderPage/getPageAssets/retrieveAssetsProd.d.ts

@@ -0,0 +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[];

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

@@ -0,0 +1,58 @@
+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) {
+    let assetUrls = new Set();
+    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 (isNpmPackageImport(id))
+                return;
+            if (id.includes('.page.server.')) {
+                id = extractAssetsAddQuery(id);
+            }
+        }
+        const { manifestKey } = getManifestEntry(id, clientManifest, manifestKeyMap);
+        collectAssets(manifestKey, assetUrls, visistedAssets, clientManifest, onlyAssets);
+    });
+    collectSingleStyle(assetUrls, clientManifest);
+    return Array.from(assetUrls);
+}
+function collectAssets(manifestKey, assetUrls, visistedAssets, manifest, onlyCollectStaticAssets) {
+    if (visistedAssets.has(manifestKey))
+        return;
+    visistedAssets.add(manifestKey);
+    const manifestEntry = manifest[manifestKey];
+    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];
+        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/esm/node/runtime/renderPage/getPageAssets/sortPageAssetsForEarlyHintsHeader.d.ts

@@ -0,0 +1,3 @@
+export { sortPageAssetsForEarlyHintsHeader };
+import type { PageAsset } from '../getPageAssets.js';
+declare function sortPageAssetsForEarlyHintsHeader(pageAssets: PageAsset[]): void;