vike 0.4.267 → 0.4.268-commit-45c1759

package/dist/client/shared/streamedValues.js

@@ -0,0 +1,82 @@
+// Streamed pageContext values, client-side (see shared-server-client/streamedValues.ts): the lines that follow the
+// serialized pageContext feed the values of a receiver (see ./streamedValues/registry.ts).
+//
+// Loaded only if the pageContext has streamed values (see getJsonSerializedInHtml.ts and
+// ../runtime-client-routing/streamedValues.ts).
+export { parsePageContextHtml };
+export { readPageContextJsonStreamed };
+export { cancelStreamedValues };
+import { parse } from '@brillout/json-serializer/parse';
+import { assert } from '../../utils/assert.js';
+import { isObject } from '../../utils/isObject.js';
+import { createReceiver } from './streamedValues/registry.js';
+import '../assertEnvClient.js';
+// First render: the `<script>` tags that follow `<script id="vike_pageContext">` push the lines to `self.__vike_streamed`,
+// before and after Vike's client runtime is loaded.
+function parsePageContextHtml(pageContextJson) {
+    const receiver = createReceiver();
+    const [pageContext] = parse(pageContextJson, { reviver: receiver.reviver });
+    const g = self;
+    const linesQueued = Array.isArray(g.__vike_streamed) ? g.__vike_streamed : [];
+    g.__vike_streamed = { push: receiver.onLine };
+    linesQueued.forEach(receiver.onLine);
+    return pageContext;
+}
+// Client-side navigation: the `.pageContext.json` response (see server/runtime/renderPageServer/getPageContextJson.ts),
+// `[pageContext` then one `,line` per line then `]`. The pageContext is returned as soon as its line arrives.
+async function readPageContextJsonStreamed(response) {
+    const reader = response.body.getReader();
+    const lines = readLines(reader);
+    const { done, value: lineFirst } = await lines.next();
+    assert(!done && lineFirst[0] === '[');
+    const receiver = createReceiver();
+    const pageContextFromServer = parse(lineFirst.slice(1), { reviver: receiver.reviver });
+    assert(isObject(pageContextFromServer));
+    responsesStreaming.push(reader);
+    (async () => {
+        try {
+            for await (const line of lines) {
+                if (line !== ']')
+                    receiver.onLine(line.slice(1));
+            }
+            receiver.fail(new Error('The pageContext.json response ended before the streamed pageContext values ended'));
+        }
+        catch (err) {
+            // E.g. the server aborted the response
+            receiver.fail(err);
+        }
+    })();
+    return { ...pageContextFromServer, _streamedValuesReader: reader };
+}
+async function* readLines(reader) {
+    const decoder = new TextDecoder();
+    // Joined once per line: joining upon each chunk would be quadratic
+    let parts = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            return;
+        const chunk = decoder.decode(value, { stream: true });
+        let lineStart = 0;
+        let lineEnd;
+        while ((lineEnd = chunk.indexOf('\n', lineStart)) !== -1) {
+            yield parts.join('') + chunk.slice(lineStart, lineEnd);
+            parts = [];
+            lineStart = lineEnd + 1;
+        }
+        parts.push(chunk.slice(lineStart));
+    }
+}
+// Once a page is rendered, the streamed values fetched before it are cancelled (the previous page's, and superseded
+// navigations'): the previous page keeps its values while it's shown.
+let responsesStreaming = [];
+// Cancels the streamed values of `pageContext` (a superseded navigation), or, once `pageContext` is rendered, all the others
+function cancelStreamedValues(pageContext, isRendered) {
+    const { _streamedValuesReader } = pageContext;
+    responsesStreaming = responsesStreaming.filter((reader) => {
+        if ((reader === _streamedValuesReader) === isRendered)
+            return true;
+        reader.cancel().catch(() => { });
+        return false;
+    });
+}

package/dist/node/api/dev.js

@@ -5,6 +5,7 @@ import { assert } from '../../utils/assert.js';
 import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 import './assertEnvApiDev.js';
 import { startupLog } from './startupLog.js';
+import { startServerEntry_parent, startServerEntry_child, getServerEntryFilePath_ifDevCli, isServerChildProcess, } from './serverEntryDev.js';
 assertIsNotProductionRuntime();
 /**
  * Programmatically trigger `$ vike dev`
@@ -13,7 +14,15 @@ assertIsNotProductionRuntime();
  */
 async function dev(options = {}) {
     const { viteConfigUser } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigUser);
+    // `$ vike dev` runs +serverEntry.js if there isn't +server.js — https://vike.dev/serverEntry
+    const serverEntryFilePath = await getServerEntryFilePath_ifDevCli();
+    const serverEntryIsChildProcess = isServerChildProcess();
+    if (serverEntryFilePath && !serverEntryIsChildProcess)
+        return await startServerEntry_parent();
+    const server = await createServer(serverEntryFilePath
+        ? // +serverEntry.js creates the server: it uses Vite's development server as middleware
+            setMiddlewareMode(viteConfigUser)
+        : viteConfigUser);
     const viteServer = server;
     const viteConfig = server.config;
     const viteVersion = viteConfig._viteVersionResolved;
@@ -22,9 +31,14 @@ async function dev(options = {}) {
         await viteServer.listen();
     if (options.startupLog)
         startupLog(viteConfig, viteServer);
+    if (serverEntryFilePath && serverEntryIsChildProcess)
+        await startServerEntry_child(viteServer, serverEntryFilePath);
     return {
         viteServer,
         viteConfig,
         viteVersion,
     };
 }
+function setMiddlewareMode(viteConfig) {
+    return { ...viteConfig, server: { ...viteConfig.server, middlewareMode: true } };
+}

package/dist/node/api/resolveViteConfigUser.js

@@ -15,7 +15,7 @@ import { toPosixPath } from '../../utils/path.js';
 import pc from '@brillout/picocolors';
 import { getEnvVarObject } from '../../utils/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
-import { getViteCliCommand, getViteCliArgs } from '../vite/shared/isViteCli.js';
+import { getViteCliCommand, getViteCliArgsMinimal } from '../vite/shared/isViteCli.js';
 import './assertEnvApiDevAndProd.js';
 const globalObject = getGlobalObject('resolveViteConfigUser.ts', {});
 const debug = createDebug('vike:vite-config-user');
@@ -83,7 +83,7 @@ async function resolve(viteContext) {
     // Vite CLI args (when invoked via Vite's CLI rather than Vike's API).
     // - Without this, Vike loads vite.config.js blind to `vite [root]` / `-c <file>` and ends up with the wrong root when those Vite CLI args are used.
     {
-        const viteConfigFromViteCli = getViteCliArgs();
+        const viteConfigFromViteCli = getViteCliArgsMinimal();
         addConfig(viteConfigFromViteCli);
         if (debug.isActivated)
             debug('viteConfigFromViteCli', viteConfigFromViteCli);

package/dist/node/api/serverEntryDev.d.ts

@@ -0,0 +1,10 @@
+export { startServerEntry_parent };
+export { startServerEntry_child };
+export { getServerEntryFilePath_ifDevCli };
+export { isServerChildProcess };
+import { type ViteDevServer } from 'vite';
+import './assertEnvApiDev.js';
+declare function startServerEntry_parent(): Promise<never>;
+declare function startServerEntry_child(viteServer: ViteDevServer, serverEntryFilePath: string): Promise<void>;
+declare function getServerEntryFilePath_ifDevCli(): Promise<string | null>;
+declare function isServerChildProcess(): boolean;

package/dist/node/api/serverEntryDev.js

@@ -0,0 +1,125 @@
+export { startServerEntry_parent };
+export { startServerEntry_child };
+export { getServerEntryFilePath_ifDevCli };
+export { isServerChildProcess };
+// `$ vike dev` runs +serverEntry.js (if there isn't +server.js) — https://vike.dev/serverEntry
+// - The parent process (`$ vike dev`) runs +serverEntry.js in a child process, and restarts the child process whenever a file imported by +serverEntry.js changes
+// - The child process creates Vite's development server (in middleware mode) and runs +serverEntry.js using Vite's module runner
+import { fork } from 'node:child_process';
+import path from 'node:path';
+import { normalizePath } from 'vite';
+import pc from '@brillout/picocolors';
+import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
+import { getServerEntryFilePath_ifDev } from '../vite/plugins/pluginUniversalDeploy/getServerConfig.js';
+import { isVikeCli } from '../cli/context.js';
+import { assert, assertInfo, assertUsage } from '../../utils/assert.js';
+import { isRunnableDevEnvironment } from '../../utils/isRunnableDevEnvironment.js';
+import './assertEnvApiDev.js';
+const IS_SERVER_CHILD_PROCESS = '__VIKE_IS_SERVER_CHILD_PROCESS';
+// The child process exits with this code to tell the parent process to restart it
+const EXIT_CODE_RESTART = 33;
+// Parent process — child_process.fork()
+function startServerEntry_parent() {
+    const [scriptPath, ...args] = process.argv.slice(1);
+    assert(scriptPath);
+    let child;
+    let signalReceived;
+    const forkChild = () => {
+        child = fork(scriptPath, args, { stdio: 'inherit', env: { ...process.env, [IS_SERVER_CHILD_PROCESS]: '1' } });
+        child.on('exit', (code, signal) => {
+            if (code === EXIT_CODE_RESTART && !signalReceived)
+                forkChild();
+            else
+                exitLikeChild(code, signal ?? signalReceived ?? null);
+        });
+    };
+    const onSignal = (signal) => {
+        signalReceived = signal;
+        child.kill(signal);
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    forkChild();
+    // The parent process exits when the child process exits
+    return new Promise(() => { });
+}
+// Exit with the same exit code or signal as the child process
+function exitLikeChild(code, signal) {
+    if (signal) {
+        process.removeAllListeners(signal);
+        process.kill(process.pid, signal);
+    }
+    else {
+        process.exit(code ?? 1);
+    }
+}
+// Child process — viteServer.ssrLoadModule()
+async function startServerEntry_child(viteServer, serverEntryFilePath) {
+    const { ssr } = viteServer.environments;
+    assertUsage(isRunnableDevEnvironment(ssr), `${pc.cyan('$ vike dev')} cannot run +serverEntry.js because Vite's ${pc.cyan('ssr')} environment isn't runnable`);
+    // Restart when +serverEntry.js or a file it imports changes
+    restartOnFileChange(viteServer, (filePath) => isImportedBy(ssr.moduleGraph.getModulesByFile(filePath), serverEntryFilePath));
+    // The user's server uses the current Vite development server (e.g. `app.use(devMiddleware)`) => we restart the process instead of letting Vite restart itself (e.g. upon vite.config.js changes)
+    viteServer.restart = async () => restart('Vite needs to restart');
+    closeOnSignal(viteServer);
+    try {
+        // Same module runner as the one Vike uses to load pages (`ssrLoadModule()`) => a module imported by both +serverEntry.js and a page is instantiated only once (like in production)
+        await viteServer.ssrLoadModule(serverEntryFilePath);
+    }
+    catch (err) {
+        console.error(err);
+        assertInfo(false, 'Waiting for file changes before restarting server...', { onlyOnce: false });
+        restartOnFileChange(viteServer, () => true);
+    }
+}
+function restartOnFileChange(viteServer, isRestartNeeded) {
+    const onFileChange = (filePath) => {
+        filePath = normalizePath(filePath);
+        if (isRestartNeeded(filePath))
+            restart(`${pc.cyan(path.relative(viteServer.config.root, filePath))} changed`);
+    };
+    viteServer.watcher.on('change', onFileChange);
+    viteServer.watcher.on('unlink', onFileChange);
+}
+// The user's server may handle SIGINT/SIGTERM without exiting the process (e.g. graceful shutdown: close the server and let the process exit once it's idle) => close Vite's development server, otherwise it keeps the process alive
+function closeOnSignal(viteServer) {
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.once(signal, () => {
+            void viteServer.close();
+            // Listening to a signal disables Node.js's default behavior of terminating the process => if the user's server doesn't listen to it, then we terminate the process ourselves
+            if (process.listenerCount(signal) === 0)
+                process.kill(process.pid, signal);
+        });
+    }
+}
+function restart(reason) {
+    assertInfo(false, `${reason}, restarting server...`, { onlyOnce: false });
+    process.exit(EXIT_CODE_RESTART);
+}
+// Only `$ vike dev` runs +serverEntry.js, not the programmatic API `dev()`: the parent process re-runs the command (process.argv) in the child process
+async function getServerEntryFilePath_ifDevCli() {
+    if (!isVikeCli())
+        return null;
+    const vikeConfig = await getVikeConfigInternal();
+    const serverEntryFilePath = getServerEntryFilePath_ifDev(vikeConfig);
+    return serverEntryFilePath;
+}
+// Whether one of the modules is +serverEntry.js or (transitively) imported by +serverEntry.js
+// - Pages aren't imported by +serverEntry.js: Vike loads them over its own virtual entries => changing a page doesn't restart the server (Vite's HMR handles it)
+function isImportedBy(modules, serverEntryFilePath) {
+    const visited = new Set();
+    const stack = [...(modules ?? [])];
+    while (stack.length > 0) {
+        const mod = stack.pop();
+        if (visited.has(mod))
+            continue;
+        visited.add(mod);
+        if (mod.file === serverEntryFilePath)
+            return true;
+        stack.push(...mod.importers);
+    }
+    return false;
+}
+function isServerChildProcess() {
+    return process.env[IS_SERVER_CHILD_PROCESS] === '1';
+}

package/dist/node/createDevMiddleware.js

@@ -1,12 +1,24 @@
 export { createDevMiddleware };
 import { createServer } from 'vite';
 import { prepareViteApiCall } from './api/prepareViteApiCall.js';
+import { getViteDevServer } from '../server/runtime/globalContext.js';
+import { assertWarning } from '../utils/assert.js';
+import pc from '@brillout/picocolors';
 /*
  * Create server middleware for development with HMR and lazy-transpiling.
  *
  * https://vike.dev/createDevMiddleware
  */
 async function createDevMiddleware(options = {}) {
+    {
+        const viteServer = getViteDevServer();
+        if (viteServer) {
+            assertWarning(false, 
+            // E.g. `$ vike dev` already created it (+serverEntry.js, +server.js), or createDevMiddleware() was already called
+            `Development middleware already created: use ${pc.cyan('globalContext.devMiddleware')} to access it instead of calling ${pc.cyan('createDevMiddleware()')}`, { onlyOnce: true });
+            return { devMiddleware: viteServer.middlewares, viteServer, viteConfig: viteServer.config };
+        }
+    }
     const optionsMod = {
         ...options,
         viteConfig: {

package/dist/node/prerender/resolvePrerenderConfig.d.ts

@@ -21,4 +21,4 @@ declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): P
 declare function isDistServerRemoved(prerenderConfigGlobal: {
     isPrerenderingEnabledForAllPages: boolean;
     keepDistServer: boolean;
-}): boolean;
+}, vikeConfig: Pick<VikeConfigInternal, '_pageConfigGlobal'>): boolean;

package/dist/node/prerender/resolvePrerenderConfig.js

@@ -70,9 +70,12 @@ async function resolvePrerenderConfigLocal(pageConfig) {
 }
 // Whether pre-rendering removes dist/server/ once it's done
 // https://vike.dev/prerender#keepDistServer
-function isDistServerRemoved(prerenderConfigGlobal) {
+function isDistServerRemoved(prerenderConfigGlobal, vikeConfig) {
     if (!prerenderConfigGlobal.isPrerenderingEnabledForAllPages)
         return false;
+    // +serverEntry.js => dist/server/index.mjs is the user's server entry
+    if (vikeConfig._pageConfigGlobal.configValueSources.serverEntry)
+        return false;
     return !prerenderConfigGlobal.keepDistServer;
 }
 function isObject2(value) {

package/dist/node/prerender/runPrerender.d.ts

@@ -32,13 +32,17 @@ type PrerenderContext = {
     _userRootDir: string;
     _outDirClient: string;
 };
-type Output<PageContext = PageContextPrerendered> = {
+type Output<PageContext = PageContextPrerendered> = ({
     filePath: string;
-    fileType: FileType;
+    fileType: 'HTML' | 'JSON';
     fileContent: string;
     pageContext: PageContext;
-}[];
-type FileType = 'HTML' | 'JSON';
+} | {
+    filePath: string;
+    fileType: 'CONTENT';
+    fileContent: string | Uint8Array;
+    pageContext: PageContext;
+})[];
 type PageContext = Awaited<ReturnType<typeof createPageContextPrerendering>> & {
     _urlOriginalBeforeHook?: string;
 };
@@ -72,12 +76,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     isPrerendering: boolean;
     _requestId: number;
 } & import("../../types/PageContext.js").PageContextInit & {
-    _nodeDev?: {
-        req: import("http").IncomingMessage;
-        res: import("http").ServerResponse;
-    };
-    _reqWeb?: Request;
-} & {
     _globalContext: ({
         config: import("../../types/index.js").ConfigResolved;
         _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
@@ -101,6 +99,10 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;
@@ -110,6 +112,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer | undefined;
+        devMiddleware: import("vite").Connect.Server | null;
         viteConfig: import("vite").ResolvedConfig | undefined;
     } | {
         isClientSide: false;
@@ -118,6 +121,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -128,12 +132,11 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: false;
         viteConfig: null;
     }) & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -144,6 +147,9 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        middlewares: import("../../server/runtime/universal-middleware/core.js").Middleware[];
     })) & {
         prerenderContext: PrerenderContextPublic | undefined;
     };
@@ -151,12 +157,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _baseServer: string;
     _baseAssets: string;
     _pageContextInit: import("../../types/PageContext.js").PageContextInit & {
-        _nodeDev?: {
-            req: import("http").IncomingMessage;
-            res: import("http").ServerResponse;
-        };
-        _reqWeb?: Request;
-    } & {
         headers?: Record<string, unknown>;
     };
     _urlHandler: ((url: string) => string) | null;

package/dist/node/prerender/runPrerender.js

@@ -21,6 +21,7 @@ import { preservePropertyGetters } from '../../utils/preservePropertyGetters.js'
 import { assertPosixPath } from '../../utils/path.js';
 import { urlToFile } from '../../utils/urlToFile.js';
 import { prependBase } from '../../utils/parseUrl-extras.js';
+import { parseUrl } from '../../utils/parseUrl.js';
 import { prerenderPage } from '../../server/runtime/renderPageServer/renderPageServerAfterRoute.js';
 import { createPageContextServer } from '../../server/runtime/renderPageServer/createPageContextServer.js';
 import pc from '@brillout/picocolors';
@@ -43,6 +44,8 @@ import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal, isDistServer
 import { getOutDirsAllFromRootNormalized } from '../vite/shared/getOutDirs.js';
 import fs from 'node:fs';
 import { getPublicProxy } from '../../shared-server-client/getPublicProxy.js';
+import { getPageContextPublicServer } from '../../server/runtime/renderPageServer/getPageContextPublicServer.js';
+import { isObject } from '../../utils/isObject.js';
 import { getStaticRedirectsForPrerender } from '../../server/runtime/renderPageServer/resolveRedirects.js';
 import { updateType } from '../../utils/updateType.js';
 const docLink = 'https://vike.dev/i18n#pre-rendering';
@@ -139,7 +142,7 @@ async function runPrerender(options = {}, trigger) {
     const prerenderContextPublic = getPrerenderContextPublic(prerenderContext);
     objectAssign(vikeConfig.prerenderContext, prerenderContextPublic, true);
     setGlobalContext_prerenderContext(prerenderContextPublic);
-    if (isDistServerRemoved(prerenderConfigGlobal)) {
+    if (isDistServerRemoved(prerenderConfigGlobal, vikeConfig)) {
         fs.rmSync(outDirServer, { recursive: true });
     }
 }
@@ -482,6 +485,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
     });
     const prerenderContextPublic = getPrerenderContextPublic(prerenderContext);
     let result = await execHookSingleWithoutPageContext(onPrerenderStartHook, globalContext, () => hookFn(prerenderContextPublic));
+    prerenderContext.pageContexts = prerenderContext.pageContexts.map(getPageContextOriginal);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -507,7 +511,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
     assertUsage(isObjectWithKeys(result, ['prerenderContext']) &&
         hasProp(result, 'prerenderContext', 'object') &&
         hasProp(result.prerenderContext, 'pageContexts', 'array'), rightUsage);
-    prerenderContext.pageContexts = result.prerenderContext.pageContexts;
+    prerenderContext.pageContexts = result.prerenderContext.pageContexts.map(getPageContextOriginal);
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TO-DO/next-major-release: remove
         if (pageContext.url && !isPropertyGetter(pageContext, 'url')) {
@@ -546,11 +550,12 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             assertIsNotAbort(err, pc.cyan(pageContextBeforeRender.urlOriginal));
             throw err;
         }
-        const { documentHtml, pageContext } = res;
+        const { documentHtml, content, pageContext } = res;
         const pageContextSerialized = pageContext.is404 ? null : res.pageContextSerialized;
         await onComplete({
             pageContext,
             htmlString: documentHtml,
+            content,
             pageContextSerialized,
         });
     })));
@@ -579,7 +584,13 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while there isn't any ${hookName}() hook returning an URL matching the page's route. You must use a ${hookName}() hook (https://vike.dev/${hookName}) for providing the list of URLs to be pre-rendered for that page. If you want to skip pre-rendering that page, you can remove this warning by setting +prerender to false at ${pageAt} (https://vike.dev/pre-rendering#partial) or by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
     });
 }
-async function writeFiles({ pageContext, htmlString, pageContextSerialized }, prerenderContext, onPagePrerender, logLevel) {
+async function writeFiles({ pageContext, htmlString, content, pageContextSerialized }, prerenderContext, onPagePrerender, logLevel) {
+    if (content !== null) {
+        assert(htmlString === null && pageContextSerialized === null);
+        await write(pageContext, 'CONTENT', content, onPagePrerender, prerenderContext, logLevel);
+        return;
+    }
+    assert(htmlString !== null);
     const writeJobs = [write(pageContext, 'HTML', htmlString, onPagePrerender, prerenderContext, logLevel)];
     if (pageContextSerialized !== null) {
         writeJobs.push(write(pageContext, 'JSON', pageContextSerialized, onPagePrerender, prerenderContext, logLevel));
@@ -594,10 +605,13 @@ async function write(pageContext, fileType, fileContent, onPagePrerender, preren
         const doNotCreateExtraDirectory = prerenderContext._noExtraDir ?? pageContext.is404;
         fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
-    else {
-        assert(fileType === 'JSON');
+    else if (fileType === 'JSON') {
         fileUrl = getPageContextRequestUrl(urlOriginal);
     }
+    else {
+        assert(fileType === 'CONTENT');
+        fileUrl = getContentFileUrl(pageContext);
+    }
     assertPosixPath(fileUrl);
     assert(fileUrl.startsWith('/'));
     const filePathRelative = fileUrl.slice(1);
@@ -614,14 +628,15 @@ async function write(pageContext, fileType, fileContent, onPagePrerender, preren
             fileContent,
         },
     });
-    prerenderContext.output.push({
-        filePath,
-        fileType,
-        fileContent,
-        pageContext,
-    });
+    if (fileType === 'CONTENT') {
+        prerenderContext.output.push({ filePath, fileType, fileContent, pageContext });
+    }
+    else {
+        assert(typeof fileContent === 'string');
+        prerenderContext.output.push({ filePath, fileType, fileContent, pageContext });
+    }
     if (onPagePrerender) {
-        await onPagePrerender(pageContext);
+        await onPagePrerender(getPageContextPublicPrerendered(pageContext));
     }
     else {
         const { promises } = await import('node:fs');
@@ -640,6 +655,18 @@ async function write(pageContext, fileType, fileContent, onPagePrerender, preren
         }
     }
 }
+// With `pageContext.content` the URL is the file path: `/feed.atom` => `dist/client/feed.atom`
+function getContentFileUrl(pageContext) {
+    const { urlOriginal } = pageContext;
+    // The query string and the hash are ignored: a static host serves the file at the pathname
+    const { pathnameOriginal } = parseUrl(urlOriginal, '/');
+    const errPrefix = `Cannot pre-render ${pc.cyan(urlOriginal)} with ${pc.code('pageContext.content')}`;
+    const errSuffix = "pre-rendering writes the content to the file at the URL's pathname (e.g. /feed.atom => dist/client/feed.atom)";
+    assertUsage(!pageContext.is404, `${errPrefix} because it's the 404 page`);
+    const segments = pathnameOriginal.split('/').slice(1);
+    assertUsage(segments.every((s) => s !== '' && s !== '.' && s !== '..'), `${errPrefix} because the URL's pathname isn't a file path: ${errSuffix}`);
+    return pathnameOriginal;
+}
 function normalizeOnPrerenderHookResult(prerenderResult, prerenderHookFile, hookName) {
     if (isArray(prerenderResult)) {
         return prerenderResult.map(normalize);
@@ -730,14 +757,31 @@ function getPrerenderContextPublic(prerenderContext) {
             configurable: true,
         });
     }
-    // Required because of https://vike.dev/i18n#pre-rendering
-    // - Thus, we have to let users access the original pageContext object => we cannot use ES proxies and we cannot use getPageContextPublicShared()
-    prerenderContext.pageContexts.forEach((pageContext) => {
+    prerenderContext.pageContexts = prerenderContext.pageContexts.map((pageContext) => {
+        // Required because of https://vike.dev/i18n#pre-rendering
+        // - Users copy pageContext, e.g. `{ ...pageContext, locale }`, and Vike renders the copies => the copies need to be original objects
         changeEnumerable(pageContext, '_isOriginalObject', true);
+        return getPageContextPublicServer(pageContext);
+    });
+    prerenderContext.output.forEach((file) => {
+        file.pageContext = getPageContextPublicPrerendered(file.pageContext);
     });
     const prerenderContextPublic = getPublicProxy(prerenderContext, 'prerenderContext');
     return prerenderContextPublic;
 }
+// The user may return the public pageContext objects passed to +onPrerenderStart
+function getPageContextOriginal(pageContext) {
+    const obj = pageContext;
+    if (isObject(obj) && obj._isProxyObject)
+        return obj._originalObject;
+    return pageContext;
+}
+function getPageContextPublicPrerendered(pageContext) {
+    // Pre-rendered redirects don't have any real pageContext object, but only a plain object `{ urlOriginal, pageId: null, is404: false, isRedirect: true }` which we cannot pass to getPageContextPublicServer() as it only accepts real pageContext objects (it asserts pageContext._isOriginalObject)
+    if (pageContext.isRedirect)
+        return pageContext;
+    return getPageContextPublicServer(pageContext);
+}
 async function prerenderRedirects(globalContext, onComplete, showWarningUponDynamicRedirects) {
     const redirects = globalContext.config.redirects ?? [];
     const redirectsStatic = getStaticRedirectsForPrerender(redirects, showWarningUponDynamicRedirects);
@@ -748,6 +792,7 @@ async function prerenderRedirects(globalContext, onComplete, showWarningUponDyna
         await onComplete({
             pageContext: { urlOriginal, pageId: null, is404: false, isRedirect: true },
             htmlString,
+            content: null,
             pageContextSerialized: null,
         });
     }

package/dist/node/vite/assertEnvVite.js

@@ -11,7 +11,7 @@ function assertEnvVite() {
     markSetup_vikeVitePlugin();
     assertIsNotBrowser();
     assertNodeVersion();
-    assertViteVersion(viteVersion);
+    assertViteVersion(viteVersion); // Early check — more reliable check using `this.meta.viteVersion` later
     assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite
 }
 function onLoad() {

package/dist/node/vite/index.js

@@ -32,6 +32,7 @@ import { pluginSuppressRollupWarning } from './plugins/build/pluginSuppressRollu
 import { pluginDistFileNames } from './plugins/build/pluginDistFileNames.js';
 import { pluginProdBuildEntry } from './plugins/build/pluginProdBuildEntry.js';
 import { pluginBuildConfig } from './plugins/build/pluginBuildConfig.js';
+import { pluginEnvironmentEntries } from './plugins/build/pluginEnvironmentEntries.js';
 import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
@@ -83,6 +84,7 @@ function plugin(vikeVitePluginOptions = {}) {
 function pluginBuild() {
     return [
         ...pluginBuildConfig(),
+        ...pluginEnvironmentEntries(),
         ...pluginBuildApp(),
         ...pluginProdBuildEntry(),
         ...pluginDistPackageJsonFile(),

package/dist/node/vite/plugins/build/handleAssetsManifest.js

@@ -45,7 +45,7 @@ async function fixServerAssets(config) {
 }
 async function copyAssets(filesToMove, filesToRemove, config) {
     const { outDirClient, outDirServer } = getOutDirs(config, undefined);
-    const assetsDir = getAssetsDir(config);
+    const assetsDir = getAssetsDir(config.environments.ssr.build);
     const assetsDirServer = path.posix.join(outDirServer, assetsDir);
     if (!filesToMove.length && !filesToRemove.length && !existsSync(assetsDirServer))
         return;
@@ -180,7 +180,11 @@ function getPageId(key) {
     // to:
     //   virtual:vike:page-entry:client:/pages/index
     // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
-    key = key.substring(key.indexOf('virtual:vike'));
+    const prefix = key.split('virtual:vike')[0];
+    // Skip virtual modules wrapping a Vike virtual module, e.g. virtual:vite-rsc/client-references/group/facade:virtual:vike:page-entry:client:/pages/index
+    if (prefix && !prefix.endsWith('/'))
+        return null;
+    key = key.substring(prefix.length);
     const result = parseVirtualFileId(key);
     return result && result.type === 'page-entry' ? result.pageId : null;
 }