vike 0.4.266 → 0.4.267-commit-7884d91

package/dist/server/runtime/renderPageServer/html/stream.js

@@ -16,6 +16,8 @@ export { isStreamReadableNode };
 export { getStreamName };
 export { inferStreamName };
 export { streamReadableWebToString };
+export { streamReadableWebToBytes };
+export { awaitFirstChunk };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
@@ -74,9 +76,60 @@ async function streamReadableWebToString(readableWeb) {
     str += getClosingChunk();
     return str;
 }
+async function streamReadableWebToBytes(readableWeb) {
+    const reader = readableWeb.getReader();
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        assertUsage(value instanceof Uint8Array, `The stream emitted a chunk that isn't a Uint8Array: ${String(value)}`);
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(chunks.reduce((len, chunk) => len + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return bytes;
+}
+// Resolves after the first chunk (rejects if the stream errors before), then reads on demand
+async function awaitFirstChunk(stream, onErrorWhileStreaming) {
+    const reader = stream.getReader();
+    const firstChunk = await reader.read();
+    const streamStarted = new ReadableStream({
+        start(controller) {
+            if (firstChunk.done)
+                controller.close();
+            else
+                controller.enqueue(firstChunk.value);
+        },
+        async pull(controller) {
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch (err) {
+                onErrorWhileStreaming(err);
+                controller.error(err);
+                return;
+            }
+            if (chunk.done)
+                controller.close();
+            else
+                controller.enqueue(chunk.value);
+        },
+        cancel(reason) {
+            return reader.cancel(reason);
+        },
+    });
+    return streamStarted;
+}
 async function stringToStreamReadableNode(str) {
     const { Readable } = await loadStreamNodeModule();
-    return Readable.from(str);
+    // Readable.from() iterates a Uint8Array byte by byte
+    return Readable.from(typeof str === 'string' ? str : [str]);
 }
 async function streamReadableWebToStreamReadableNode(stream) {
     const { Readable } = await loadStreamNodeModule();
@@ -156,16 +209,19 @@ function streamPipeWebToString(streamPipeWeb) {
     return promise;
 }
 async function getStreamReadableNode(htmlRender) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         return stringToStreamReadableNode(htmlRender);
     }
     if (isStreamReadableNode(htmlRender)) {
         return htmlRender;
     }
+    if (isStreamReadableWeb(htmlRender)) {
+        return streamReadableWebToStreamReadableNode(htmlRender);
+    }
     return null;
 }
 function getStreamReadableWeb(htmlRender) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         return stringToStreamReadableWeb(htmlRender);
     }
     if (isStreamReadableWeb(htmlRender)) {
@@ -181,13 +237,14 @@ function getStreamReadableWeb(htmlRender) {
     return null;
 }
 function pipeToStreamWritableWeb(htmlRender, writable) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         const streamPipeWeb = stringToStreamPipeWeb(htmlRender);
         streamPipeWeb(writable);
         return true;
     }
     if (isStreamReadableWeb(htmlRender)) {
-        htmlRender.pipeTo(writable);
+        // pipeTo() propagates a failure of either side to the other side
+        htmlRender.pipeTo(writable).catch(() => { });
         return true;
     }
     if (isStreamPipeWeb(htmlRender)) {
@@ -203,23 +260,30 @@ function pipeToStreamWritableWeb(htmlRender, writable) {
     assert(false);
 }
 function pipeToStreamWritableNode(htmlRender, writable) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         const streamPipeNode = stringToStreamPipeNode(htmlRender);
         streamPipeNode(writable);
         return true;
     }
-    if (isStreamReadableNode(htmlRender)) {
-        htmlRender.pipe(writable);
-        return true;
-    }
     if (isStreamPipeNode(htmlRender)) {
         const streamPipeNode = getStreamPipeNode(htmlRender);
         assert(streamPipeNode);
         streamPipeNode(writable);
         return true;
     }
-    if (isStreamReadableWeb(htmlRender)) {
-        streamReadableWebToStreamReadableNode(htmlRender).then((s) => s.pipe(writable));
+    if (isStreamReadableNode(htmlRender) || isStreamReadableWeb(htmlRender)) {
+        getStreamReadableNode(htmlRender).then(async (readable) => {
+            assert(readable);
+            const { pipeline } = await loadStreamNodeModule();
+            // pipeline() throws if the writable is already destroyed (e.g. the client left before the first chunk)
+            if (writable.destroyed)
+                return readable.destroy();
+            // Unlike pipe(), pipeline() destroys the readable if the writable closes early, and the writable if the readable errors or closes before its end
+            pipeline(readable, writable, () => { });
+            // E.g. compression() holds the writes until flush()
+            const w = writable;
+            readable.on('data', () => w.flush?.());
+        });
         return true;
     }
     if (isStreamPipeWeb(htmlRender)) {
@@ -228,7 +292,7 @@ function pipeToStreamWritableNode(htmlRender, writable) {
     checkType(htmlRender);
     assert(false);
 }
-async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }) {
+async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, onCancel, }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
     let streamOriginalEnded = false;
@@ -275,6 +339,8 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
             resolveReadyToWrite();
         },
         onError(err) {
+            // The HTML won't end: its streamed pageContext values won't be sent
+            onCancel();
             if (!promiseHasResolved) {
                 reject(err);
             }
@@ -303,7 +369,10 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                     streamOriginalEnded = true;
                 });
                 if (injectStringAtEnd && !isCancel) {
-                    const injectedChunk = await injectStringAtEnd();
+                    const injectedChunk = await injectStringAtEnd((html) => {
+                        writeStream(html);
+                        flushStream();
+                    });
                     writeStream(injectedChunk);
                 }
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
@@ -326,6 +395,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         onFlush() {
             flushStream();
         },
+        onCancel,
     });
     wrapperCreated = true;
     flushBuffer(); // In case onReadyToWrite() was already called (the flushBuffer() of onReadyToWrite() wasn't called because `wrapperCreated === false`)
@@ -388,7 +458,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         return !enableEagerStreaming && !streamOriginalHasStartedEmitting;
     }
 }
-async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, }) {
+async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, onCancel, }) {
     if (isStreamFromReactStreamingPackage(streamOriginal)) {
         debug(`onRenderHtml() hook returned ${pc.cyan('react-streaming')} result`);
         const stream = getStreamOfReactStreamingPackage(streamOriginal);
@@ -400,6 +470,16 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const pipeProxy = (writable_) => {
             writableOriginal = writable_;
             debug('original Node.js Writable received');
+            // Let the source know when the response closes early (no-op once it has ended)
+            const onClose = () => {
+                if (!hasEnded)
+                    onCancel();
+                writableProxy.destroy();
+            };
+            if (writableOriginal.destroyed)
+                onClose();
+            else
+                writableOriginal.on('close', onClose);
             onReadyToWrite();
             if (hasEnded) {
                 // onReadyToWrite() already wrote everything; we can close the stream right away
@@ -463,6 +543,11 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const pipeProxy = (writableOriginal) => {
             writerOriginal = writableOriginal.getWriter();
             debug('original Web Writable received');
+            // Let the source know when the response closes early
+            writerOriginal.closed.catch((err) => {
+                onCancel();
+                readerProxy?.cancel(err);
+            });
             (async () => {
                 // CloudFlare Workers does not implement `ready` property
                 //  - https://github.com/vuejs/vue-next/issues/4287
@@ -480,7 +565,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         stampPipe(pipeProxy, 'web-stream');
         const writeChunk = (chunk) => {
             assert(writerOriginal);
-            writerOriginal.write(encodeForWebStream(chunk));
+            writerOriginal.write(encodeForWebStream(chunk)).catch(() => { });
             debugWithChunk('data written (Web Writable)', chunk);
         };
         // Web Streams have compression built-in
@@ -491,10 +576,11 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const endStream = () => {
             hasEnded = true;
             if (writerOriginal) {
-                writerOriginal.close();
+                writerOriginal.close().catch(() => { });
             }
         };
         let writableProxy;
+        let readerProxy;
         if (typeof ReadableStream !== 'function') {
             writableProxy = new WritableStream({
                 write(chunk) {
@@ -513,7 +599,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         else {
             const { readable, writable } = new TransformStream();
             writableProxy = writable;
-            handleReadableWeb(readable, {
+            readerProxy = readable.getReader();
+            handleReadableWeb(readerProxy, {
                 onData,
                 onError(err) {
                     onError(err);
@@ -531,7 +618,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     }
     if (isStreamReadableWeb(streamOriginal)) {
         debug('onRenderHtml() hook returned Web Readable');
-        const readableOriginal = streamOriginal;
+        const readerOriginal = streamOriginal.getReader();
         let isClosed = false;
         let isCancel = false;
         const closeStream = async () => {
@@ -548,7 +635,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             start(controller) {
                 controllerProxy = controller;
                 onReadyToWrite();
-                handleReadableWeb(readableOriginal, {
+                handleReadableWeb(readerOriginal, {
                     onData,
                     onError(err) {
                         onError(err);
@@ -559,18 +646,16 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                     },
                 });
             },
-            async cancel(...args) {
+            async cancel(reason) {
                 debug('stream cancelled');
                 isCancel = true;
-                await readableOriginal.cancel(...args);
-                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
-                await closeStream();
+                onCancel();
+                // Ends handleReadableWeb() which then calls closeStream()
+                await readerOriginal.cancel(reason);
             },
         });
         const writeChunk = (chunk) => {
-            if (!isCancel &&
-                // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
-                !isClosed) {
+            if (!isCancel && !isClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
                 debugWithChunk('data written (Web Readable)', chunk);
             }
@@ -603,6 +688,12 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             readableProxy.push(null);
         };
         const readableProxy = new Readable({ read() { } });
+        // Destroy the source when the consumer closes early
+        readableProxy.once('close', () => {
+            if (!readableProxy.readableEnded)
+                onCancel();
+            readableOriginal.destroy();
+        });
         onReadyToWrite();
         readableOriginal.on('data', (chunk) => {
             onData(chunk);
@@ -622,8 +713,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     }
     assert(false);
 }
-async function handleReadableWeb(readable, { onData, onError, onEnd, }) {
-    const reader = readable.getReader();
+async function handleReadableWeb(reader, { onData, onError, onEnd, }) {
     while (true) {
         let result;
         try {
@@ -776,8 +866,8 @@ function encodeForWebStream(thing) {
 // Because of Cloudflare Workers, we cannot statically import the `stream` module, instead we dynamically import it.
 async function loadStreamNodeModule() {
     const streamModule = (await import_('stream')).default;
-    const { Readable, Writable } = streamModule;
-    return { Readable, Writable };
+    const { Readable, Writable, pipeline } = streamModule;
+    return { Readable, Writable, pipeline };
 }
 function getStreamName(kind, type) {
     let typeName = capitalizeFirstLetter(type);

package/dist/server/runtime/renderPageServer/html/streamedValuesHtml.d.ts

@@ -0,0 +1,30 @@
+export { serializePageContextHtml };
+export { getStreamedValuesHtml };
+export { writeStreamedValuesHtmlAtStreamEnd };
+export { cancelStreamedValuesHtml };
+export { getStreamedValuesLinesPrerendered };
+export type { PageContextStreamedValuesHtml };
+import { type PageContextSerialization } from './serializeContext.js';
+import type { PageContextCreatedServer } from '../createPageContextServer.js';
+import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
+import { type PageContextCspNonce } from '../csp.js';
+import '../../../assertEnvServer.js';
+type StreamedValuesHtml = {
+    done: Promise<void>;
+    cancel: () => void;
+    /** The `<script>` tags not sent yet */
+    pending: string[];
+    /** Set once the HTML stream is ending */
+    writeHtml: null | ((html: string) => void);
+    /** Pre-rendering: all lines */
+    lines: null | string[];
+};
+type PageContextStreamedValuesHtml = PageContextCreatedServer & PageContextCspNonce & {
+    _requestId: number;
+    _streamedValuesHtml?: StreamedValuesHtml;
+};
+declare function serializePageContextHtml(pageContext: PageContextStreamedValuesHtml & PageContextSerialization, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage): string;
+declare function getStreamedValuesHtml(pageContext: PageContextStreamedValuesHtml): Promise<null | string>;
+declare function writeStreamedValuesHtmlAtStreamEnd(pageContext: PageContextStreamedValuesHtml, htmlEnd: string, writeHtml: (html: string) => void): Promise<string>;
+declare function cancelStreamedValuesHtml(pageContext: PageContextStreamedValuesHtml): void;
+declare function getStreamedValuesLinesPrerendered(pageContext: PageContextStreamedValuesHtml): Promise<null | string[]>;

package/dist/server/runtime/renderPageServer/html/streamedValuesHtml.js

@@ -0,0 +1,92 @@
+// The streamed pageContext values (see shared-server-client/streamedValues.ts) of the HTML's
+// `<script id="vike_pageContext">`: each line is sent as a `<script>` that pushes it to `self.__vike_streamed` (read by
+// Vike's client runtime, see client/shared/streamedValues.ts).
+// - HTML stream of react-streaming: the lines are injected into the stream as they're produced.
+// - HTML stream: the lines produced while the stream is running are sent after it ends, and the lines produced
+//   afterwards are sent as they're produced; the HTML ends once all values have ended.
+// - HTML string: the lines are appended to the HTML once all values have ended.
+// - Pre-rendering: the lines are also collected for `index.pageContext.json`, so that the values are read once.
+export { serializePageContextHtml };
+export { getStreamedValuesHtml };
+export { writeStreamedValuesHtmlAtStreamEnd };
+export { cancelStreamedValuesHtml };
+export { getStreamedValuesLinesPrerendered };
+import { assert } from '../../../../utils/assert.js';
+import { pumpStreamedValues } from '../streamedValues/pump.js';
+import { getPageContextClientSerialized } from './serializeContext.js';
+import { inferNonceAttr } from '../csp.js';
+import '../../../assertEnvServer.js';
+// The pageContext of `<script id="vike_pageContext">`, as `[pageContext]` if it has streamed values (which start streaming)
+function serializePageContextHtml(pageContext, streamFromReactStreamingPackage) {
+    const { pageContextSerialized, streamedValues } = getPageContextClientSerialized(pageContext, true);
+    if (streamedValues.length === 0)
+        return pageContextSerialized;
+    // The pageContext is serialized once per HTML
+    assert(!pageContext._streamedValuesHtml);
+    const { isPrerendering } = pageContext;
+    const write = (line) => {
+        streamedValuesHtml.lines?.push(line);
+        const script = getScript(line, pageContext);
+        if (streamedValuesHtml.writeHtml) {
+            streamedValuesHtml.writeHtml(script);
+        }
+        else if (streamFromReactStreamingPackage && !streamFromReactStreamingPackage.hasStreamEnded()) {
+            streamFromReactStreamingPackage.injectToStream(script, { flush: true });
+        }
+        else {
+            streamedValuesHtml.pending.push(script);
+        }
+    };
+    const streamedValuesHtml = {
+        // A pre-rendered page can't have a failed value
+        ...pumpStreamedValues(pageContext, streamedValues, write, { failFast: isPrerendering }),
+        pending: [],
+        writeHtml: null,
+        lines: isPrerendering ? [] : null,
+    };
+    // Pre-rendering: the error is thrown by getStreamedValuesLinesPrerendered()
+    streamedValuesHtml.done.catch(() => { });
+    pageContext._streamedValuesHtml = streamedValuesHtml;
+    return `[${pageContextSerialized}]`;
+}
+// HTML string
+async function getStreamedValuesHtml(pageContext) {
+    const streamedValuesHtml = pageContext._streamedValuesHtml;
+    if (!streamedValuesHtml)
+        return null;
+    await streamedValuesHtml.done.catch(() => { });
+    return streamedValuesHtml.pending.join('');
+}
+// HTML stream: `htmlEnd` is what Vike appends after the HTML stream ended. The lines are sent before `</body>`.
+async function writeStreamedValuesHtmlAtStreamEnd(pageContext, htmlEnd, writeHtml) {
+    const streamedValuesHtml = pageContext._streamedValuesHtml;
+    if (!streamedValuesHtml)
+        return htmlEnd;
+    let i = htmlEnd.lastIndexOf('</body>');
+    if (i === -1)
+        i = htmlEnd.length;
+    writeHtml(htmlEnd.slice(0, i) + streamedValuesHtml.pending.join(''));
+    streamedValuesHtml.writeHtml = writeHtml;
+    await streamedValuesHtml.done.catch(() => { });
+    return htmlEnd.slice(i);
+}
+// The HTML response was cancelled (e.g. the user closed the tab) or failed
+function cancelStreamedValuesHtml(pageContext) {
+    pageContext._streamedValuesHtml?.cancel();
+}
+// Pre-rendering: the lines for `index.pageContext.json` (the values are read once, while rendering the HTML)
+async function getStreamedValuesLinesPrerendered(pageContext) {
+    const streamedValuesHtml = pageContext._streamedValuesHtml;
+    if (!streamedValuesHtml)
+        return null;
+    await streamedValuesHtml.done;
+    assert(streamedValuesHtml.lines);
+    return streamedValuesHtml.lines;
+}
+function getScript(line, pageContext) {
+    // A JavaScript string literal: JSON.stringify() escapes quotes, backslashes and line breaks; `<` is escaped so that the
+    // script never contains `</script>` nor `<!--`; `/` is escaped for the same reason as in `<script id="vike_pageContext">`
+    // (https://github.com/vikejs/vike/pull/2603)
+    const literal = JSON.stringify(line).replaceAll('<', '\\u003c').replaceAll('/', '\\/');
+    return `<script${inferNonceAttr(pageContext)}>(self.__vike_streamed=self.__vike_streamed||[]).push(${literal})</script>`;
+}

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.d.ts

@@ -52,6 +52,10 @@ declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPage
         _pageFilesAll: import("../../../shared-server-client/getPageFiles.js").PageFile[];
         _pageConfigs: PageConfigRuntime[];
         _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: PageConfigRuntime[];
+            pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.js

@@ -15,6 +15,7 @@ import { loadAndParseVirtualFilePageEntry } from '../../../shared-server-client/
 import { execHookServer } from './execHookServer.js';
 import { resolveHeadersResponseEarly } from './headersResponse.js';
 import { resolvePageContextCspNone } from './csp.js';
+import { loadPageContextEnvironments } from './loadPageContextEnvironments.js';
 import '../../assertEnvServer.js';
 async function loadPageConfigsLazyServerSide(pageContext) {
     objectAssign(pageContext, {
@@ -109,7 +110,7 @@ async function resolvePageContext(pageContext) {
     return pageContext;
 }
 async function loadPageUserFiles(pageContext) {
-    const [{ pageContextAddendum }] = await Promise.all([
+    const [{ pageContextAddendum }, pageContextEnvironments] = await Promise.all([
         (async () => {
             const pageFilesServerSide = getPageFilesServerSide(pageContext._pageFilesAll, pageContext.pageId);
             const isDev = !pageContext._globalContext._isProduction;
@@ -120,9 +121,12 @@ async function loadPageUserFiles(pageContext) {
             const pageContextAddendum = resolvePageContextConfig(pageFilesServerSide, pageConfigLoaded, pageContext._globalContext._pageConfigGlobal);
             return { pageContextAddendum };
         })(),
+        pageContext._pageConfig && loadPageContextEnvironments(pageContext),
         analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
             sharedPageFilesAlreadyLoaded: true,
         }),
     ]);
+    if (pageContextEnvironments)
+        objectAssign(pageContextAddendum, pageContextEnvironments);
     return pageContextAddendum;
 }

package/dist/server/runtime/renderPageServer/loadPageContextEnvironments.d.ts

@@ -0,0 +1,15 @@
+export { loadPageContextEnvironments };
+import type { GlobalContextServerInternal } from '../globalContext.js';
+import type { PageContextPublicMinimum } from '../../../shared-server-client/getPageContextPublicShared.js';
+import '../../assertEnvServer.js';
+declare function loadPageContextEnvironments(pageContext: PageContextPublicMinimum & {
+    pageId: string;
+    _globalContext: GlobalContextServerInternal;
+}): Promise<{
+    environments: {
+        [k: string]: {
+            config: import("../../../types/index.js").ConfigResolved;
+            pageContext: object;
+        };
+    };
+}>;

package/dist/server/runtime/renderPageServer/loadPageContextEnvironments.js

@@ -0,0 +1,61 @@
+export { loadPageContextEnvironments };
+import { resolvePageContextConfig } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import { parseGlobalEntryPageConfigs, } from '../../../shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js';
+import { findPageConfig } from '../../../shared-server-client/page-configs/findPageConfig.js';
+import { loadAndParseVirtualFilePageEntry } from '../../../shared-server-client/page-configs/loadAndParseVirtualFilePageEntry.js';
+import { generateVirtualFileIdAdditionalEnvironment } from '../../../shared-server-node/virtualFileId.js';
+import { isRunnableDevEnvironment } from '../../../utils/isRunnableDevEnvironment.js';
+import { assert, assertUsage } from '../../../utils/assert.js';
+import { getPageContextPublicServer } from './getPageContextPublicServer.js';
+import '../../assertEnvServer.js';
+// Additional environments (e.g. `rsc`) run in the same runtime as the server environment => their functions can be called directly
+// - `pageContext.environments[environmentName]` holds the environment's config values and its view of pageContext, which its functions are called with
+async function loadPageContextEnvironments(pageContext) {
+    const environmentEntries = pageContext._globalContext._environmentEntries;
+    const environments = Object.fromEntries(await Promise.all(Object.entries(environmentEntries).map(async ([environmentName, environmentEntry]) => {
+        const pageContextConfigEnv = await loadPageContextConfig(pageContext, environmentName, environmentEntry);
+        const environment = {
+            config: pageContextConfigEnv.config,
+            pageContext: getPageContextEnvView(getPageContextPublicServer(pageContext), pageContextConfigEnv),
+        };
+        return [environmentName, environment];
+    })));
+    const pageContextEnvironments = { environments };
+    return pageContextEnvironments;
+}
+// The same pageContext object, except for the config values (and what's derived from them) which are the environment's
+function getPageContextEnvView(pageContext, pageContextConfig) {
+    // TO-DO/soon/flat-pageContext make this clean using same mechanism as [Flat `pageContext`](https://github.com/vikejs/vike/issues/1268)
+    return new Proxy(pageContext, {
+        get(target, prop) {
+            if (prop === 'Page')
+                return pageContextConfig.exports.Page;
+            if (prop in pageContextConfig)
+                return pageContextConfig[prop];
+            return Reflect.get(target, prop);
+        },
+    });
+}
+async function loadPageContextConfig(pageContext, environmentName, environmentEntry) {
+    const globalContext = pageContext._globalContext;
+    const { pageConfigs, pageConfigGlobal } = await importEnvironmentEntry(globalContext, environmentName, environmentEntry);
+    const pageConfig = findPageConfig(pageConfigs, pageContext.pageId);
+    assert(pageConfig);
+    const pageConfigLoaded = await loadAndParseVirtualFilePageEntry(pageConfig, !globalContext._isProduction);
+    return resolvePageContextConfig([], pageConfigLoaded, pageConfigGlobal);
+}
+async function importEnvironmentEntry(globalContext, environmentName, environmentEntry) {
+    if (environmentEntry) {
+        // Prod
+        assert(globalContext._isProduction);
+        return environmentEntry;
+    }
+    else {
+        // Dev
+        assert(!globalContext._isProduction);
+        const environment = globalContext._viteDevServer?.environments[environmentName];
+        assertUsage(isRunnableDevEnvironment(environment), `The Vike environment ${environmentName} should be a server-side environment running in the same runtime (process or worker) as Vike's server`);
+        const virtualFileId = generateVirtualFileIdAdditionalEnvironment(environmentName);
+        return parseGlobalEntryPageConfigs(await environment.runner.import(virtualFileId));
+    }
+}