vike 0.4.267-commit-b005535 → 0.4.267-commit-5676e14

package/dist/client/runtime-server-routing/entry.js

@@ -23,7 +23,7 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClient();
-    objectAssign(pageContext, getPageContextSerializedInHtml());
+    objectAssign(pageContext, await getPageContextSerializedInHtml());
     // Sets pageContext.config using non-global configs — overrides the pageContext.config set using global configs at createPageContextClient()
     const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
     objectAssign(pageContext, pageContextAddendum);

package/dist/client/runtime-server-routing/getGlobalContextClientInternal.d.ts

@@ -25,6 +25,10 @@ declare function getGlobalContextClientInternal(): Promise<{
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").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: true;

package/dist/client/shared/getGlobalContextClientInternalShared.d.ts

@@ -29,6 +29,10 @@ declare function getGlobalContextClientInternalShared(): Promise<{
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").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[];
 } & {
     /**

package/dist/client/shared/getJsonSerializedInHtml.d.ts

@@ -1,8 +1,8 @@
 export { getPageContextSerializedInHtml };
 export { getGlobalContextSerializedInHtml };
 import '../assertEnvClient.js';
-declare function getPageContextSerializedInHtml(): {
+declare function getPageContextSerializedInHtml(): Promise<{
     pageId: string;
     routeParams: Record<string, string>;
-};
+}>;
 declare function getGlobalContextSerializedInHtml(): object;

package/dist/client/shared/getJsonSerializedInHtml.js

@@ -9,23 +9,26 @@ import '../assertEnvClient.js';
 // 1. <script id="vike_pageContext" type="application/json"> appears before the <script> that loads Vike's client runtime (which includes this file)
 // 2. <script id="vike_pageContext" type="application/json"> is neither async nor defer
 // See https://github.com/vikejs/vike/pull/1271
-function getPageContextSerializedInHtml() {
-    const pageContextSerializedInHtml = findAndParseJson(htmlElementId_pageContext);
+async function getPageContextSerializedInHtml() {
+    const pageContextJson = findJson(htmlElementId_pageContext);
+    // A pageContext always serializes as `{…}`, so an array means streamed values https://vike.dev/passToClient#streaming
+    const pageContextSerializedInHtml = pageContextJson[0] === '['
+        ? (await import('./streamedValues.js')).parsePageContextHtml(pageContextJson)
+        : parse(pageContextJson);
     assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
     assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
     return pageContextSerializedInHtml;
 }
 function getGlobalContextSerializedInHtml() {
-    const globalContextSerializedInHtml = findAndParseJson(htmlElementId_globalContext);
+    const globalContextSerializedInHtml = parse(findJson(htmlElementId_globalContext));
     return globalContextSerializedInHtml;
 }
-function findAndParseJson(id) {
+function findJson(id) {
     const elem = document.getElementById(id);
     assertUsage(elem, 
     // It seems like it can be missing when HTML is malformed: https://github.com/vikejs/vike/issues/913
     `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
     const jsonStr = elem.textContent;
     assert(jsonStr);
-    const json = parse(jsonStr);
-    return json;
+    return jsonStr;
 }

package/dist/client/shared/streamedValues/asyncIterable.d.ts

@@ -0,0 +1,4 @@
+export { asyncIterable };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const asyncIterable: StreamedValueType;

package/dist/client/shared/streamedValues/asyncIterable.js

@@ -0,0 +1,26 @@
+export { asyncIterable };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { readableStream } from './readableStream.js';
+import '../../assertEnvClient.js';
+// A ReadableStream, consumed as an async iterable: `for await (const chunk of pageContext.someAsyncIterable)` (Safari's
+// ReadableStream isn't async-iterable)
+const asyncIterable = {
+    marker: markers.asyncIterable,
+    revive(parseValue) {
+        const streamedValue = readableStream.revive(parseValue);
+        return { ...streamedValue, value: toAsyncIterable(streamedValue.value) };
+    },
+};
+function toAsyncIterable(stream) {
+    const reader = stream.getReader();
+    const iterator = {
+        next: () => reader.read(),
+        // Called upon `break` in `for await`
+        async return(value) {
+            await reader.cancel();
+            return { done: true, value };
+        },
+        [Symbol.asyncIterator]: () => iterator,
+    };
+    return iterator;
+}

package/dist/client/shared/streamedValues/lines.d.ts

@@ -0,0 +1,11 @@
+export { decodeChunk };
+export { getLineError };
+import '../../assertEnvClient.js';
+declare function decodeChunk(line: {
+    t: string;
+} | {
+    b: string;
+} | {
+    v: unknown;
+}, parseValue: (value: unknown) => unknown): unknown;
+declare function getLineError(): Error;

package/dist/client/shared/streamedValues/lines.js

@@ -0,0 +1,19 @@
+// The decoding of the lines (see shared-server-client/streamedValues.ts)
+export { decodeChunk };
+export { getLineError };
+import '../../assertEnvClient.js';
+const textEncoder = new TextEncoder();
+function decodeChunk(line, parseValue) {
+    if ('t' in line)
+        return textEncoder.encode(line.t);
+    if ('b' in line)
+        return decodeBase64url(line.b);
+    return parseValue(line.v);
+}
+function getLineError() {
+    return new Error('A streamed pageContext value failed on the server-side (see the server logs)');
+}
+function decodeBase64url(str) {
+    const binary = atob(str.replaceAll('-', '+').replaceAll('_', '/'));
+    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}

package/dist/client/shared/streamedValues/promise.d.ts

@@ -0,0 +1,4 @@
+export { promise };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const promise: StreamedValueType;

package/dist/client/shared/streamedValues/promise.js

@@ -0,0 +1,19 @@
+export { promise };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { getLineError } from './lines.js';
+import { genPromise } from '../../../utils/genPromise.js';
+import '../../assertEnvClient.js';
+// Settled by its `v` or `error` line
+const promise = {
+    marker: markers.promise,
+    revive(parseValue) {
+        const { promise: value, resolve, reject } = genPromise({ timeout: null });
+        // Avoid an unhandled rejection if the user doesn't use the promise
+        value.catch(() => { });
+        return {
+            value,
+            push: (line) => ('v' in line ? resolve(parseValue(line.v)) : reject(getLineError())),
+            fail: reject,
+        };
+    },
+};

package/dist/client/shared/streamedValues/readableStream.d.ts

@@ -0,0 +1,4 @@
+export { readableStream };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const readableStream: StreamedValueType;

package/dist/client/shared/streamedValues/readableStream.js

@@ -0,0 +1,44 @@
+export { readableStream };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { decodeChunk, getLineError } from './lines.js';
+import '../../assertEnvClient.js';
+// Fed by its chunk lines, until its `end` or `error` line
+const readableStream = {
+    marker: markers.readableStream,
+    revive(parseValue) {
+        let controller;
+        let isClosed = false;
+        const value = new ReadableStream({
+            start(controller_) {
+                controller = controller_;
+            },
+            cancel() {
+                // Released by its consumer: the rest is ignored
+                isClosed = true;
+            },
+        });
+        const close = (err) => {
+            if (isClosed)
+                return;
+            isClosed = true;
+            if (err)
+                controller.error(err);
+            else
+                controller.close();
+        };
+        return {
+            value,
+            push(line) {
+                if (isClosed)
+                    return;
+                if ('end' in line)
+                    close();
+                else if ('error' in line)
+                    close(getLineError());
+                else
+                    controller.enqueue(decodeChunk(line, parseValue));
+            },
+            fail: close,
+        };
+    },
+};

package/dist/client/shared/streamedValues/registry.d.ts

@@ -0,0 +1,21 @@
+export { createReceiver };
+export type { StreamedValueType };
+import { type Reviver } from '@brillout/json-serializer/parse';
+import type { Line } from '../../../shared-server-client/streamedValues.js';
+import '../../assertEnvClient.js';
+type StreamedValueType = {
+    marker: string;
+    /** `parseValue()` parses the value of a `v` line, which can contain further streamed values */
+    revive: (parseValue: (value: unknown) => unknown) => StreamedValue;
+};
+type StreamedValue = {
+    value: unknown;
+    push: (line: Line) => void;
+    fail: (err: unknown) => void;
+};
+declare function createReceiver(): {
+    reviver: Reviver;
+    onLine(lineStr: string): void;
+    /** The response failed, ended or was cancelled: the values that didn't end fail */
+    fail(err: unknown): void;
+};

package/dist/client/shared/streamedValues/registry.js

@@ -0,0 +1,40 @@
+// The types of streamed pageContext values (see shared-server-client/streamedValues.ts), and the receiver: its reviver
+// replaces the markers with values, which it then feeds with their lines.
+export { createReceiver };
+import { parseTransform } from '@brillout/json-serializer/parse';
+import { assert } from '../../../utils/assert.js';
+import { readableStream } from './readableStream.js';
+import { promise } from './promise.js';
+import { asyncIterable } from './asyncIterable.js';
+import '../../assertEnvClient.js';
+const types = [readableStream, promise, asyncIterable];
+function createReceiver() {
+    const streamedValues = new Map();
+    const parseValue = (value) => parseTransform(value, { reviver });
+    const reviver = (_path, value) => {
+        const type = types.find((type) => value.startsWith(type.marker));
+        if (!type)
+            return undefined;
+        const id = value.slice(type.marker.length);
+        assert(/^\d+$/.test(id));
+        // The same value referenced twice
+        let streamedValue = streamedValues.get(Number(id));
+        if (!streamedValue) {
+            streamedValue = type.revive(parseValue);
+            streamedValues.set(Number(id), streamedValue);
+        }
+        return { replacement: streamedValue.value };
+    };
+    return {
+        reviver,
+        onLine(lineStr) {
+            const line = JSON.parse(lineStr);
+            // Unknown if contained in a chunk nobody read
+            streamedValues.get(line.s)?.push(line);
+        },
+        /** The response failed, ended or was cancelled: the values that didn't end fail */
+        fail(err) {
+            streamedValues.forEach((streamedValue) => streamedValue.fail(err));
+        },
+    };
+}

package/dist/client/shared/streamedValues.d.ts

@@ -0,0 +1,7 @@
+export { parsePageContextHtml };
+export { readPageContextJsonStreamed };
+export { cancelStreamedValues };
+import '../assertEnvClient.js';
+declare function parsePageContextHtml(pageContextJson: string): unknown;
+declare function readPageContextJsonStreamed(response: Response): Promise<Record<string, unknown>>;
+declare function cancelStreamedValues(pageContext: object, isRendered: boolean): void;

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/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/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;
 };
@@ -101,6 +105,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;

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';
@@ -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;
 }