vike 0.4.191-commit-7e0cd43 → 0.4.191-commit-e99a55e

package/dist/cjs/__internal/index.js

@@ -5,7 +5,6 @@ const index_js_1 = require("../shared/route/index.js");
 const getPageFiles_js_1 = require("../shared/getPageFiles.js");
 const globalContext_js_1 = require("../node/runtime/globalContext.js");
 const assertNodeEnv_js_1 = require("../utils/assertNodeEnv.js");
-const assert_js_1 = require("../utils/assert.js");
 const renderPageAlreadyRouted_js_1 = require("../node/runtime/renderPage/renderPageAlreadyRouted.js");
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
@@ -15,11 +14,10 @@ const renderPageAlreadyRouted_js_1 = require("../node/runtime/renderPage/renderP
  */
 async function getPagesAndRoutes() {
     (0, assertNodeEnv_js_1.handleNodeEnv_vitePluginVercel)();
-    await (0, globalContext_js_1.initGlobalContext)(true);
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
-    (0, assert_js_1.assert)(globalContext.isProduction === true);
     const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
-    const { pageFilesAll, pageConfigs, allPageIds, pageRoutes } = renderContext;
+    const { 
+    //
+    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = renderContext;
     return {
         pageRoutes,
         pageFilesAll,
@@ -28,10 +26,10 @@ async function getPagesAndRoutes() {
     };
 }
 exports.getPagesAndRoutes = getPagesAndRoutes;
-// TODO: make it cleaner once the internal refactoring about global configs is done
-async function getPageFilesAllSafe() {
-    await (0, globalContext_js_1.initGlobalContext)(false);
-    await (0, globalContext_js_1.getGlobalContextAsync)();
+// TODO: make it cleaner once the internal refactoring about global configs is done.
+// Demo usage: https://github.com/vikejs/vike/pull/1823
+async function getPageFilesAllSafe(isProduction) {
+    await (0, globalContext_js_1.initGlobalContext_getGlobalContextAsync)(isProduction);
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     const pageFilesAll = await (0, getPageFiles_js_1.getPageFilesAll)(false, globalContext.isProduction);
     return pageFilesAll;

package/dist/cjs/node/plugin/plugins/autoFullBuild.js

@@ -94,23 +94,27 @@ async function triggerFullBuild(config, configVike, bundle) {
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
-    if (configVike.prerender && !configVike.prerender.disableAutoRun) {
+    if (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
         await (0, runPrerender_js_1.runPrerenderFromAutoFullBuild)({ viteConfig: configInline });
         forceExit = true;
     }
 }
 function abortViteBuildSsr(configVike) {
-    if (!configVike.disableAutoFullBuild && (0, isViteCliCall_js_1.isViteCliCall)() && (0, isViteCliCall_js_1.getViteConfigFromCli)()?.build.ssr) {
+    if (configVike.disableAutoFullBuild !== true && (0, isViteCliCall_js_1.isViteCliCall)() && (0, isViteCliCall_js_1.getViteConfigFromCli)()?.build.ssr) {
         (0, utils_js_1.assertWarning)(false, `The CLI call ${picocolors_1.default.cyan('$ vite build --ssr')} is superfluous since ${picocolors_1.default.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${picocolors_1.default.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
 function isDisabled(configVike) {
-    if (configVike.disableAutoFullBuild === null) {
-        // TODO/v1-release: also enable autoFullBuild when running Vite's build() API
+    const { disableAutoFullBuild } = configVike;
+    if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
+        // TODO/v1-release: remove autoFullBuild for both Vite's build() API and Vite's CLI
+        //  - Tell users to use `$ vike build` instead of `$ vite build`
+        //  - Remove the whole writeBundle() hook logic
+        //  - make `$ vite build` only build the client-side
         return !(0, isViteCliCall_js_1.isViteCliCall)();
     }
     else {
-        return configVike.disableAutoFullBuild;
+        return disableAutoFullBuild;
     }
 }

package/dist/cjs/node/plugin/plugins/config/assertVikeConfig.js

@@ -30,8 +30,10 @@ function checkConfigVike(configVike) {
     }
     {
         const prop = 'disableAutoFullBuild';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
+        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') &&
+            !(0, utils_js_1.hasProp)(configVike, prop, 'undefined') &&
+            !(configVike[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
     }
     {
         const prop = 'includeAssetsImportedByServer';

package/dist/cjs/node/plugin/plugins/setGlobalContext.js

@@ -18,6 +18,11 @@ function setGlobalContext() {
                 const isDev = (0, utils_js_1.isDev3)(env);
                 (0, globalContext_js_1.setGlobalContext_isDev)(isDev);
             }
+        },
+        configResolved(config) {
+            const { outDirRoot } = (0, utils_js_1.getOutDirs)(config);
+            (0, utils_js_1.assertFilePathAbsoluteFilesystem)(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+            (0, globalContext_js_1.setGlobalContext_viteConfig)(config, outDirRoot);
         }
     };
 }

package/dist/cjs/node/prerender/runPrerender.js

@@ -83,7 +83,8 @@ async function runPrerenderFromAutoFullBuild(options) {
 exports.runPrerenderFromAutoFullBuild = runPrerenderFromAutoFullBuild;
 async function runPrerender(options, manuallyTriggered) {
     checkOutdatedOptions(options);
-    (0, getHook_js_1.setIsPrerenderering)();
+    (0, globalContext_js_1.setGlobalContext_isPrerendering)();
+    (0, getHook_js_1.getHook_setIsPrerenderering)();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${picocolors_1.default.cyan(`vike v${utils_js_1.projectInfo.projectVersion}`)} ${picocolors_1.default.green('pre-rendering HTML...')}`);
@@ -91,10 +92,9 @@ async function runPrerender(options, manuallyTriggered) {
     (0, utils_js_1.handleNodeEnv_prerender)();
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'vike pre-rendering', 'production');
-    (0, globalContext_js_1.setGlobalContext_prerender)(viteConfig);
     assertLoadedConfig(viteConfig, options);
     const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
-    const { outDirClient, outDirRoot } = (0, utils_js_1.getOutDirs)(viteConfig);
+    const { outDirClient } = (0, utils_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = configVike.prerender;
     if (!prerenderConfig) {
@@ -105,8 +105,7 @@ async function runPrerender(options, manuallyTriggered) {
     }
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
-    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
-    await (0, globalContext_js_1.initGlobalContext)(true, outDirRoot);
+    await (0, globalContext_js_1.initGlobalContext_runPrerender)();
     const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
     renderContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {};

package/dist/cjs/node/runtime/globalContext.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRuntimeManifest = exports.setGlobalContext_prerender = exports.setGlobalContext_isDev = exports.setGlobalContext_viteDevServer = exports.getViteConfig = exports.getViteDevServer = exports.getGlobalContext = exports.initGlobalContext = exports.getGlobalContextAsync = exports.getGlobalContextSync = void 0;
+exports.setGlobalContext_isPrerendering = exports.setGlobalContext_isDev = exports.setGlobalContext_viteConfig = exports.setGlobalContext_viteDevServer = exports.initGlobalContext_getGlobalContextAsync = exports.initGlobalContext_runPrerender = exports.initGlobalContext_renderPage = exports.getRuntimeManifest = exports.getViteConfig = exports.getViteDevServer = exports.getGlobalContext = exports.getGlobalContextAsync = exports.getGlobalContextSync = void 0;
 const utils_js_1 = require("./utils.js");
 const loadImportBuild_js_1 = require("./globalContext/loadImportBuild.js");
 const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
@@ -12,10 +12,13 @@ const getConfigVike_js_1 = require("../shared/getConfigVike.js");
 const assertRuntimeManifest_js_1 = require("../shared/assertRuntimeManifest.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getPageFilesExports_js_1 = require("./page-files/getPageFilesExports.js");
-let resolveGlobalContext;
-const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', {
-    globalContextPromise: new Promise((r) => (resolveGlobalContext = r))
-});
+const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', (() => {
+    const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
+    return {
+        viteDevServerPromise,
+        viteDevServerPromiseResolve
+    };
+})());
 function getGlobalContext() {
     (0, utils_js_1.assert)(globalObject.globalContext);
     return globalObject.globalContext;
@@ -28,10 +31,12 @@ function getGlobalContextSync() {
 }
 exports.getGlobalContextSync = getGlobalContextSync;
 /** @experimental https://vike.dev/getGlobalContext */
-async function getGlobalContextAsync() {
-    await globalObject.globalContextPromise;
-    (0, utils_js_1.assert)(globalObject.globalContext);
-    return makePublic(globalObject.globalContext);
+async function getGlobalContextAsync(isProduction) {
+    (0, utils_js_1.assertUsage)(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${picocolors_1.default.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${picocolors_1.default.cyan('true')} or ${picocolors_1.default.cyan('false')}`}`);
+    await initGlobalContext_getGlobalContextAsync(isProduction);
+    const { globalContext } = globalObject;
+    (0, utils_js_1.assert)(globalContext);
+    return makePublic(globalContext);
 }
 exports.getGlobalContextAsync = getGlobalContextAsync;
 function makePublic(globalContext) {
@@ -61,40 +66,84 @@ function makePublic(globalContext) {
 function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
-    (0, utils_js_1.assert)(!globalObject.globalContext);
-    globalObject.viteConfig = viteDevServer.config;
+    assertIsNotInitilizedYet();
+    (0, utils_js_1.assert)(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
+    globalObject.viteDevServerPromiseResolve(viteDevServer);
     eagerlyLoadUserFiles();
 }
 exports.setGlobalContext_viteDevServer = setGlobalContext_viteDevServer;
+function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
+    if (globalObject.viteConfig)
+        return;
+    assertIsNotInitilizedYet();
+    globalObject.viteConfig = viteConfig;
+    globalObject.outDirRoot = outDirRoot;
+}
+exports.setGlobalContext_viteConfig = setGlobalContext_viteConfig;
+function assertIsNotInitilizedYet() {
+    // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
+    (0, utils_js_1.assert)(!globalObject.globalContext);
+}
 function setGlobalContext_isDev(isDev) {
     globalObject.isDev = isDev;
 }
 exports.setGlobalContext_isDev = setGlobalContext_isDev;
+function setGlobalContext_isPrerendering() {
+    globalObject.isPrerendering = true;
+}
+exports.setGlobalContext_isPrerendering = setGlobalContext_isPrerendering;
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
 }
 exports.getViteDevServer = getViteDevServer;
-function setGlobalContext_prerender(viteConfig) {
-    if (globalObject.viteConfig)
-        return;
-    (0, utils_js_1.assert)(!globalObject.globalContext);
-    globalObject.viteConfig = viteConfig;
-}
-exports.setGlobalContext_prerender = setGlobalContext_prerender;
 function getViteConfig() {
     return globalObject.viteConfig ?? null;
 }
 exports.getViteConfig = getViteConfig;
-async function initGlobalContext(isPrerendering = false, outDir) {
-    if (globalObject.globalContext)
+async function initGlobalContext_renderPage() {
+    await initGlobalContext(!globalObject.isDev);
+}
+exports.initGlobalContext_renderPage = initGlobalContext_renderPage;
+async function initGlobalContext_runPrerender() {
+    (0, utils_js_1.assert)(globalObject.isPrerendering);
+    (0, utils_js_1.assert)(globalObject.viteConfig);
+    (0, utils_js_1.assert)(globalObject.outDirRoot);
+    // We assume initGlobalContext_runPrerender() to be called before:
+    // - initGlobalContext_renderPage()
+    // - initGlobalContext_getGlobalContextAsync()
+    (0, utils_js_1.assert)(!globalObject.globalContext);
+    await initGlobalContext(true);
+}
+exports.initGlobalContext_runPrerender = initGlobalContext_runPrerender;
+async function initGlobalContext_getGlobalContextAsync(isProduction) {
+    if (!isProduction) {
+        const waitFor = 20;
+        const timeout = setTimeout(() => {
+            (0, utils_js_1.assertWarning)(false, `Vite's development server still not created after ${waitFor} seconds.`, {
+                onlyOnce: false,
+                showStackTrace: true
+            });
+        }, waitFor * 1000);
+        await globalObject.viteDevServerPromise;
+        clearTimeout(timeout);
+    }
+    await initGlobalContext(isProduction);
+}
+exports.initGlobalContext_getGlobalContextAsync = initGlobalContext_getGlobalContextAsync;
+async function initGlobalContext(isProduction) {
+    if (globalObject.globalContext) {
+        (0, utils_js_1.assert)(globalObject.globalContext.isProduction === isProduction);
+        // We assume setGlobalContext_isPrerendering() is called before initGlobalContext()
+        (0, utils_js_1.assert)(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
-    const { viteDevServer, viteConfig, isDev } = globalObject;
+    }
+    const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject;
     (0, utils_js_1.assertNodeEnv_runtime)(isDev ?? false);
-    if (isDev) {
+    if (!isProduction) {
         (0, utils_js_1.assert)(viteConfig);
-        (0, utils_js_1.assert)(!isPrerendering);
         (0, utils_js_1.assert)(viteDevServer);
+        (0, utils_js_1.assert)(!isPrerendering);
         const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
         const pluginManifest = getRuntimeManifest(configVike);
         globalObject.globalContext = {
@@ -113,7 +162,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
         };
     }
     else {
-        const buildEntries = await (0, loadImportBuild_js_1.loadImportBuild)(outDir);
+        const buildEntries = await (0, loadImportBuild_js_1.loadImportBuild)(globalObject.outDirRoot);
         assertBuildEntries(buildEntries, isPrerendering ?? false);
         const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
         (0, getPageFiles_js_1.setPageFiles)(pageFiles);
@@ -149,9 +198,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             globalObject.globalContext = globalContext;
         }
     }
-    resolveGlobalContext(globalObject.globalContext);
 }
-exports.initGlobalContext = initGlobalContext;
 function getRuntimeManifest(configVike) {
     const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;
     const manifest = {

package/dist/cjs/node/runtime/html/stream.js

@@ -44,16 +44,15 @@ async function streamReadableNodeToString(readableNode) {
 }
 async function streamReadableWebToString(readableWeb) {
     const reader = readableWeb.getReader();
-    const decoder = new TextDecoder();
+    const { decode, getClosingChunk } = decodeChunks();
     let str = '';
     while (true) {
         const { done, value } = await reader.read();
         if (done)
             break;
-        str += decoder.decode(value, { stream: true });
+        str += decode(value);
     }
-    // https://github.com/vikejs/vike/pull/1799#discussion_r1713554096
-    str += decoder.decode();
+    str += getClosingChunk();
     return str;
 }
 exports.streamReadableWebToString = streamReadableWebToString;
@@ -119,15 +118,16 @@ async function streamPipeNodeToString(streamPipeNode) {
 }
 exports.streamPipeNodeToString = streamPipeNodeToString;
 function streamPipeWebToString(streamPipeWeb) {
+    const { decode, getClosingChunk } = decodeChunks();
     let str = '';
     let resolve;
     const promise = new Promise((r) => (resolve = r));
     const writable = new WritableStream({
         write(chunk) {
-            (0, utils_js_1.assert)(typeof chunk === 'string');
-            str += chunk;
+            str += decode(chunk);
         },
         close() {
+            str += getClosingChunk();
             resolve(str);
         }
     });
@@ -384,9 +384,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const writeChunk = (chunk) => {
             (0, utils_js_1.assert)(writableOriginal);
             writableOriginal.write(chunk);
-            if (debug.isActivated) {
-                debug('data written (Node.js Writable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Node.js Writable)', chunk);
         };
         // For libraries such as https://www.npmjs.com/package/compression
         //  - React calls writable.flush() when available
@@ -457,9 +455,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const writeChunk = (chunk) => {
             (0, utils_js_1.assert)(writerOriginal);
             writerOriginal.write(encodeForWebStream(chunk));
-            if (debug.isActivated) {
-                debug('data written (Web Writable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Web Writable)', chunk);
         };
         // Web Streams have compression built-in
         //  - https://developer.mozilla.org/en-US/docs/Web/API/Compression_Streams_API
@@ -550,14 +546,10 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
             !controllerProxyIsClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
-                if (debug.isActivated) {
-                    debug('data written (Web Readable)', getChunkAsString(chunk));
-                }
+                debugWithChunk('data written (Web Readable)', chunk);
             }
             else {
-                if (debug.isActivated) {
-                    debug('data emitted but not written (Web Readable)', getChunkAsString(chunk));
-                }
+                debugWithChunk('data emitted but not written (Web Readable)', chunk);
             }
         };
         // Readables don't have the notion of flushing
@@ -577,9 +569,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         }
         const writeChunk = (chunk) => {
             readableProxy.push(chunk);
-            if (debug.isActivated) {
-                debug('data written (Node.js Readable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Node.js Readable)', chunk);
         };
         // Readables don't have the notion of flushing
         const flushStream = null;
@@ -802,11 +792,34 @@ function inferStreamName(stream) {
     (0, utils_js_1.assert)(false);
 }
 exports.inferStreamName = inferStreamName;
-function getChunkAsString(chunk) {
+function decodeChunks() {
+    const decoder = new TextDecoder();
+    const decode = (chunk) => {
+        if (typeof chunk === 'string') {
+            return chunk;
+        }
+        else if (chunk instanceof Uint8Array) {
+            return decoder.decode(chunk, { stream: true });
+        }
+        else {
+            (0, utils_js_1.assert)(false);
+        }
+    };
+    // https://github.com/vikejs/vike/pull/1799#discussion_r1713554096
+    const getClosingChunk = () => {
+        return decoder.decode();
+    };
+    return { decode, getClosingChunk };
+}
+function debugWithChunk(msg, chunk) {
+    if (!debug.isActivated)
+        return;
+    let chunkStr;
     try {
-        return new TextDecoder().decode(chunk);
+        chunkStr = new TextDecoder().decode(chunk);
     }
     catch (err) {
-        return String(chunk);
+        chunkStr = String(chunk);
     }
+    debug(msg, chunkStr);
 }

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

@@ -67,12 +67,12 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Prepare context
     let renderContext;
     try {
-        await (0, globalContext_js_1.initGlobalContext)();
+        await (0, globalContext_js_1.initGlobalContext_renderPage)();
         renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
     }
     catch (err) {
-        // Errors are expected since assertUsage() is used in both initGlobalContext() and getRenderContext().
-        // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
+        // Errors are expected since assertUsage() is used in both initGlobalContext_renderPage() and getRenderContext().
+        // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
         const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);

package/dist/cjs/node/runtime/utils.js

@@ -75,3 +75,4 @@ __exportStar(require("../../utils/normalizeHeaders.js"), exports);
 __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
+__exportStar(require("../../utils/genPromise.js"), exports);

package/dist/cjs/shared/hooks/getHook.js

@@ -3,15 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHookTimeoutDefault = exports.setIsPrerenderering = exports.assertHook = exports.getHookFromPageConfigGlobal = exports.getHookFromPageConfig = exports.getHook = void 0;
+exports.getHookTimeoutDefault = exports.getHook_setIsPrerenderering = exports.assertHook = exports.getHookFromPageConfigGlobal = exports.getHookFromPageConfig = exports.getHook = void 0;
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
 const helpers_js_1 = require("../page-configs/helpers.js");
 const getConfigValue_js_1 = require("../page-configs/getConfigValue.js");
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('getHook.ts', {
-    isPrerendering: false
-});
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
@@ -133,7 +131,7 @@ function getHookTimeoutDefault(hookName) {
     };
 }
 exports.getHookTimeoutDefault = getHookTimeoutDefault;
-function setIsPrerenderering() {
+function getHook_setIsPrerenderering() {
     globalObject.isPrerendering = true;
 }
-exports.setIsPrerenderering = setIsPrerenderering;
+exports.getHook_setIsPrerenderering = getHook_setIsPrerenderering;

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.191-commit-7e0cd43';
+exports.PROJECT_VERSION = '0.4.191-commit-e99a55e';

package/dist/cjs/utils/genPromise.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genPromise = void 0;
+function genPromise() {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    return { promise, resolve };
+}
+exports.genPromise = genPromise;

package/dist/esm/__internal/index.d.ts

@@ -16,7 +16,7 @@ declare function getPagesAndRoutes(): Promise<{
     pageConfigs: PageConfigRuntime[];
     allPageIds: string[];
 }>;
-declare function getPageFilesAllSafe(): Promise<{
+declare function getPageFilesAllSafe(isProduction: boolean): Promise<{
     pageFilesAll: PageFile[];
     allPageIds: string[];
     pageConfigs: PageConfigRuntime[];

package/dist/esm/__internal/index.js

@@ -4,9 +4,8 @@ export { route, getPagesAndRoutes };
 export { getPageFilesAllSafe };
 import { route as routeInternal } from '../shared/route/index.js';
 import { getPageFilesAll } from '../shared/getPageFiles.js';
-import { getGlobalContext, getGlobalContextAsync, initGlobalContext } from '../node/runtime/globalContext.js';
+import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
 import { handleNodeEnv_vitePluginVercel } from '../utils/assertNodeEnv.js';
-import { assert } from '../utils/assert.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
@@ -16,11 +15,10 @@ import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRo
  */
 async function getPagesAndRoutes() {
     handleNodeEnv_vitePluginVercel();
-    await initGlobalContext(true);
-    const globalContext = getGlobalContext();
-    assert(globalContext.isProduction === true);
     const renderContext = await getRenderContext();
-    const { pageFilesAll, pageConfigs, allPageIds, pageRoutes } = renderContext;
+    const { 
+    //
+    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = renderContext;
     return {
         pageRoutes,
         pageFilesAll,
@@ -28,10 +26,10 @@ async function getPagesAndRoutes() {
         allPageIds
     };
 }
-// TODO: make it cleaner once the internal refactoring about global configs is done
-async function getPageFilesAllSafe() {
-    await initGlobalContext(false);
-    await getGlobalContextAsync();
+// TODO: make it cleaner once the internal refactoring about global configs is done.
+// Demo usage: https://github.com/vikejs/vike/pull/1823
+async function getPageFilesAllSafe(isProduction) {
+    await initGlobalContext_getGlobalContextAsync(isProduction);
     const globalContext = getGlobalContext();
     const pageFilesAll = await getPageFilesAll(false, globalContext.isProduction);
     return pageFilesAll;

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -88,23 +88,27 @@ async function triggerFullBuild(config, configVike, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (configVike.prerender && !configVike.prerender.disableAutoRun) {
+    if (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
         await runPrerenderFromAutoFullBuild({ viteConfig: configInline });
         forceExit = true;
     }
 }
 function abortViteBuildSsr(configVike) {
-    if (!configVike.disableAutoFullBuild && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+    if (configVike.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
 function isDisabled(configVike) {
-    if (configVike.disableAutoFullBuild === null) {
-        // TODO/v1-release: also enable autoFullBuild when running Vite's build() API
+    const { disableAutoFullBuild } = configVike;
+    if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
+        // TODO/v1-release: remove autoFullBuild for both Vite's build() API and Vite's CLI
+        //  - Tell users to use `$ vike build` instead of `$ vite build`
+        //  - Remove the whole writeBundle() hook logic
+        //  - make `$ vite build` only build the client-side
         return !isViteCliCall();
     }
     else {
-        return configVike.disableAutoFullBuild;
+        return disableAutoFullBuild;
     }
 }

package/dist/esm/node/plugin/plugins/config/assertVikeConfig.js

@@ -27,8 +27,10 @@ function checkConfigVike(configVike) {
     }
     {
         const prop = 'disableAutoFullBuild';
-        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
+        if (!hasProp(configVike, prop, 'boolean') &&
+            !hasProp(configVike, prop, 'undefined') &&
+            !(configVike[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
     }
     {
         const prop = 'includeAssetsImportedByServer';

package/dist/esm/node/plugin/plugins/setGlobalContext.js

@@ -1,6 +1,6 @@
 export { setGlobalContext };
-import { setGlobalContext_isDev, setGlobalContext_viteDevServer } from '../../runtime/globalContext.js';
-import { isDev3 } from '../utils.js';
+import { setGlobalContext_isDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { assertFilePathAbsoluteFilesystem, getOutDirs, isDev3 } from '../utils.js';
 function setGlobalContext() {
     return {
         name: 'vike:setGlobalContext',
@@ -16,6 +16,11 @@ function setGlobalContext() {
                 const isDev = isDev3(env);
                 setGlobalContext_isDev(isDev);
             }
+        },
+        configResolved(config) {
+            const { outDirRoot } = getOutDirs(config);
+            assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+            setGlobalContext_viteConfig(config, outDirRoot);
         }
     };
 }

package/dist/esm/node/prerender/runPrerender.js

@@ -5,11 +5,11 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertFilePathAbsoluteFilesystem, isArray, changeEnumerable } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, isArray, changeEnumerable } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
-import { getGlobalContext, initGlobalContext, setGlobalContext_prerender } from '../runtime/globalContext.js';
+import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
@@ -22,7 +22,7 @@ import { isErrorPage } from '../../shared/error-page.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
-import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
+import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
@@ -55,7 +55,8 @@ async function runPrerenderFromAutoFullBuild(options) {
 }
 async function runPrerender(options, manuallyTriggered) {
     checkOutdatedOptions(options);
-    setIsPrerenderering();
+    setGlobalContext_isPrerendering();
+    getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
@@ -63,10 +64,9 @@ async function runPrerender(options, manuallyTriggered) {
     handleNodeEnv_prerender();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
-    setGlobalContext_prerender(viteConfig);
     assertLoadedConfig(viteConfig, options);
     const configVike = await getConfigVike(viteConfig);
-    const { outDirClient, outDirRoot } = getOutDirs(viteConfig);
+    const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = configVike.prerender;
     if (!prerenderConfig) {
@@ -77,8 +77,7 @@ async function runPrerender(options, manuallyTriggered) {
     }
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
-    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
-    await initGlobalContext(true, outDirRoot);
+    await initGlobalContext_runPrerender();
     const renderContext = await getRenderContext();
     renderContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {};

package/dist/esm/node/runtime/globalContext.d.ts

@@ -1,13 +1,16 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
-export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
+export { getRuntimeManifest };
+export { initGlobalContext_renderPage };
+export { initGlobalContext_runPrerender };
+export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
+export { setGlobalContext_viteConfig };
 export { setGlobalContext_isDev };
-export { setGlobalContext_prerender };
-export { getRuntimeManifest };
+export { setGlobalContext_isPrerendering };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
@@ -46,11 +49,14 @@ declare function getGlobalContext(): GlobalContext;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
-declare function getGlobalContextAsync(): Promise<GlobalContextPublic>;
+declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
+declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
 declare function setGlobalContext_isDev(isDev: boolean): void;
+declare function setGlobalContext_isPrerendering(): void;
 declare function getViteDevServer(): ViteDevServer | null;
-declare function setGlobalContext_prerender(viteConfig: ResolvedConfig): void;
 declare function getViteConfig(): ResolvedConfig | null;
-declare function initGlobalContext(isPrerendering?: boolean, outDir?: string): Promise<void>;
+declare function initGlobalContext_renderPage(): Promise<void>;
+declare function initGlobalContext_runPrerender(): Promise<void>;
+declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
 declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;

package/dist/esm/node/runtime/globalContext.js

@@ -2,15 +2,18 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 // Internal use
-export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
+export { getRuntimeManifest };
+export { initGlobalContext_renderPage };
+export { initGlobalContext_runPrerender };
+export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
+export { setGlobalContext_viteConfig };
 export { setGlobalContext_isDev };
-export { setGlobalContext_prerender };
-export { getRuntimeManifest };
-import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys } from './utils.js';
+export { setGlobalContext_isPrerendering };
+import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -18,10 +21,13 @@ import { getConfigVike } from '../shared/getConfigVike.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
 import { getPageFilesExports } from './page-files/getPageFilesExports.js';
-let resolveGlobalContext;
-const globalObject = getGlobalObject('globalContext.ts', {
-    globalContextPromise: new Promise((r) => (resolveGlobalContext = r))
-});
+const globalObject = getGlobalObject('globalContext.ts', (() => {
+    const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
+    return {
+        viteDevServerPromise,
+        viteDevServerPromiseResolve
+    };
+})());
 function getGlobalContext() {
     assert(globalObject.globalContext);
     return globalObject.globalContext;
@@ -32,10 +38,12 @@ function getGlobalContextSync() {
     return makePublic(globalObject.globalContext);
 }
 /** @experimental https://vike.dev/getGlobalContext */
-async function getGlobalContextAsync() {
-    await globalObject.globalContextPromise;
-    assert(globalObject.globalContext);
-    return makePublic(globalObject.globalContext);
+async function getGlobalContextAsync(isProduction) {
+    assertUsage(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${pc.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${pc.cyan('true')} or ${pc.cyan('false')}`}`);
+    await initGlobalContext_getGlobalContextAsync(isProduction);
+    const { globalContext } = globalObject;
+    assert(globalContext);
+    return makePublic(globalContext);
 }
 function makePublic(globalContext) {
     const globalContextPublic = {
@@ -64,35 +72,75 @@ function makePublic(globalContext) {
 function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
-    assert(!globalObject.globalContext);
-    globalObject.viteConfig = viteDevServer.config;
+    assertIsNotInitilizedYet();
+    assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
+    globalObject.viteDevServerPromiseResolve(viteDevServer);
     eagerlyLoadUserFiles();
 }
+function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
+    if (globalObject.viteConfig)
+        return;
+    assertIsNotInitilizedYet();
+    globalObject.viteConfig = viteConfig;
+    globalObject.outDirRoot = outDirRoot;
+}
+function assertIsNotInitilizedYet() {
+    // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
+    assert(!globalObject.globalContext);
+}
 function setGlobalContext_isDev(isDev) {
     globalObject.isDev = isDev;
 }
+function setGlobalContext_isPrerendering() {
+    globalObject.isPrerendering = true;
+}
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
 }
-function setGlobalContext_prerender(viteConfig) {
-    if (globalObject.viteConfig)
-        return;
-    assert(!globalObject.globalContext);
-    globalObject.viteConfig = viteConfig;
-}
 function getViteConfig() {
     return globalObject.viteConfig ?? null;
 }
-async function initGlobalContext(isPrerendering = false, outDir) {
-    if (globalObject.globalContext)
+async function initGlobalContext_renderPage() {
+    await initGlobalContext(!globalObject.isDev);
+}
+async function initGlobalContext_runPrerender() {
+    assert(globalObject.isPrerendering);
+    assert(globalObject.viteConfig);
+    assert(globalObject.outDirRoot);
+    // We assume initGlobalContext_runPrerender() to be called before:
+    // - initGlobalContext_renderPage()
+    // - initGlobalContext_getGlobalContextAsync()
+    assert(!globalObject.globalContext);
+    await initGlobalContext(true);
+}
+async function initGlobalContext_getGlobalContextAsync(isProduction) {
+    if (!isProduction) {
+        const waitFor = 20;
+        const timeout = setTimeout(() => {
+            assertWarning(false, `Vite's development server still not created after ${waitFor} seconds.`, {
+                onlyOnce: false,
+                showStackTrace: true
+            });
+        }, waitFor * 1000);
+        await globalObject.viteDevServerPromise;
+        clearTimeout(timeout);
+    }
+    await initGlobalContext(isProduction);
+}
+async function initGlobalContext(isProduction) {
+    if (globalObject.globalContext) {
+        assert(globalObject.globalContext.isProduction === isProduction);
+        // We assume setGlobalContext_isPrerendering() is called before initGlobalContext()
+        assert(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
-    const { viteDevServer, viteConfig, isDev } = globalObject;
+    }
+    const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject;
     assertNodeEnv_runtime(isDev ?? false);
-    if (isDev) {
+    if (!isProduction) {
         assert(viteConfig);
-        assert(!isPrerendering);
         assert(viteDevServer);
+        assert(!isPrerendering);
         const configVike = await getConfigVike(viteConfig);
         const pluginManifest = getRuntimeManifest(configVike);
         globalObject.globalContext = {
@@ -111,7 +159,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
         };
     }
     else {
-        const buildEntries = await loadImportBuild(outDir);
+        const buildEntries = await loadImportBuild(globalObject.outDirRoot);
         assertBuildEntries(buildEntries, isPrerendering ?? false);
         const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
         setPageFiles(pageFiles);
@@ -147,7 +195,6 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             globalObject.globalContext = globalContext;
         }
     }
-    resolveGlobalContext(globalObject.globalContext);
 }
 function getRuntimeManifest(configVike) {
     const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;

package/dist/esm/node/runtime/html/stream.js

@@ -55,16 +55,15 @@ async function streamReadableNodeToString(readableNode) {
 }
 async function streamReadableWebToString(readableWeb) {
     const reader = readableWeb.getReader();
-    const decoder = new TextDecoder();
+    const { decode, getClosingChunk } = decodeChunks();
     let str = '';
     while (true) {
         const { done, value } = await reader.read();
         if (done)
             break;
-        str += decoder.decode(value, { stream: true });
+        str += decode(value);
     }
-    // https://github.com/vikejs/vike/pull/1799#discussion_r1713554096
-    str += decoder.decode();
+    str += getClosingChunk();
     return str;
 }
 async function stringToStreamReadableNode(str) {
@@ -128,15 +127,16 @@ async function streamPipeNodeToString(streamPipeNode) {
     return promise;
 }
 function streamPipeWebToString(streamPipeWeb) {
+    const { decode, getClosingChunk } = decodeChunks();
     let str = '';
     let resolve;
     const promise = new Promise((r) => (resolve = r));
     const writable = new WritableStream({
         write(chunk) {
-            assert(typeof chunk === 'string');
-            str += chunk;
+            str += decode(chunk);
         },
         close() {
+            str += getClosingChunk();
             resolve(str);
         }
     });
@@ -388,9 +388,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const writeChunk = (chunk) => {
             assert(writableOriginal);
             writableOriginal.write(chunk);
-            if (debug.isActivated) {
-                debug('data written (Node.js Writable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Node.js Writable)', chunk);
         };
         // For libraries such as https://www.npmjs.com/package/compression
         //  - React calls writable.flush() when available
@@ -461,9 +459,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const writeChunk = (chunk) => {
             assert(writerOriginal);
             writerOriginal.write(encodeForWebStream(chunk));
-            if (debug.isActivated) {
-                debug('data written (Web Writable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Web Writable)', chunk);
         };
         // Web Streams have compression built-in
         //  - https://developer.mozilla.org/en-US/docs/Web/API/Compression_Streams_API
@@ -554,14 +550,10 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
             !controllerProxyIsClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
-                if (debug.isActivated) {
-                    debug('data written (Web Readable)', getChunkAsString(chunk));
-                }
+                debugWithChunk('data written (Web Readable)', chunk);
             }
             else {
-                if (debug.isActivated) {
-                    debug('data emitted but not written (Web Readable)', getChunkAsString(chunk));
-                }
+                debugWithChunk('data emitted but not written (Web Readable)', chunk);
             }
         };
         // Readables don't have the notion of flushing
@@ -581,9 +573,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         }
         const writeChunk = (chunk) => {
             readableProxy.push(chunk);
-            if (debug.isActivated) {
-                debug('data written (Node.js Readable)', getChunkAsString(chunk));
-            }
+            debugWithChunk('data written (Node.js Readable)', chunk);
         };
         // Readables don't have the notion of flushing
         const flushStream = null;
@@ -796,11 +786,34 @@ function inferStreamName(stream) {
     }
     assert(false);
 }
-function getChunkAsString(chunk) {
+function decodeChunks() {
+    const decoder = new TextDecoder();
+    const decode = (chunk) => {
+        if (typeof chunk === 'string') {
+            return chunk;
+        }
+        else if (chunk instanceof Uint8Array) {
+            return decoder.decode(chunk, { stream: true });
+        }
+        else {
+            assert(false);
+        }
+    };
+    // https://github.com/vikejs/vike/pull/1799#discussion_r1713554096
+    const getClosingChunk = () => {
+        return decoder.decode();
+    };
+    return { decode, getClosingChunk };
+}
+function debugWithChunk(msg, chunk) {
+    if (!debug.isActivated)
+        return;
+    let chunkStr;
     try {
-        return new TextDecoder().decode(chunk);
+        chunkStr = new TextDecoder().decode(chunk);
     }
     catch (err) {
-        return String(chunk);
+        chunkStr = String(chunk);
     }
+    debug(msg, chunkStr);
 }

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

@@ -4,7 +4,7 @@ import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted }
 import { route } from '../../shared/route/index.js';
 import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
-import { getGlobalContext, initGlobalContext } from './globalContext.js';
+import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
 import { createHttpResponseObjectRedirect, createHttpResponsePageContextJson } from './renderPage/createHttpResponseObject.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
@@ -61,12 +61,12 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Prepare context
     let renderContext;
     try {
-        await initGlobalContext();
+        await initGlobalContext_renderPage();
         renderContext = await getRenderContext();
     }
     catch (err) {
-        // Errors are expected since assertUsage() is used in both initGlobalContext() and getRenderContext().
-        // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
+        // Errors are expected since assertUsage() is used in both initGlobalContext_renderPage() and getRenderContext().
+        // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);

package/dist/esm/node/runtime/utils.d.ts

@@ -56,3 +56,4 @@ export * from '../../utils/normalizeHeaders.js';
 export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
+export * from '../../utils/genPromise.js';

package/dist/esm/node/runtime/utils.js

@@ -59,3 +59,4 @@ export * from '../../utils/normalizeHeaders.js';
 export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
+export * from '../../utils/genPromise.js';

package/dist/esm/shared/ConfigVike.d.ts

@@ -7,7 +7,7 @@ type ConfigVikeResolved = {
         partial: boolean;
         disableAutoRun: boolean;
     };
-    disableAutoFullBuild: boolean | null;
+    disableAutoFullBuild: boolean | 'prerender' | null;
     includeAssetsImportedByServer: boolean;
     baseAssets: string;
     baseServer: string;
@@ -63,13 +63,13 @@ type ConfigVikeUserProvided = {
         disableAutoRun?: boolean;
     };
     /**
-     * Set to `true` to disable the automatic chaining of all the build steps.
+     * Disable the automatic chaining of build steps.
      *
      * https://vike.dev/disableAutoFullBuild
      *
      * @default false
      */
-    disableAutoFullBuild?: boolean;
+    disableAutoFullBuild?: boolean | 'prerender';
     /** The Base URL of your server.
      *
      * https://vike.dev/base-url

package/dist/esm/shared/hooks/getHook.d.ts

@@ -2,7 +2,7 @@ export { getHook };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { assertHook };
-export { setIsPrerenderering };
+export { getHook_setIsPrerenderering };
 export type { Hook };
 export type { HookName };
 export type { HookLoc };
@@ -33,4 +33,4 @@ declare function assertHook<TPageContext extends PageContextExports, THookName e
     exports: Record<THookName, Function | undefined>;
 };
 declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;
-declare function setIsPrerenderering(): void;
+declare function getHook_setIsPrerenderering(): void;

package/dist/esm/shared/hooks/getHook.js

@@ -2,7 +2,7 @@ export { getHook };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { assertHook };
-export { setIsPrerenderering };
+export { getHook_setIsPrerenderering };
 // TODO/v1-release: remove
 // We export for old V0.4 design which doesn't support configooksTimeout
 export { getHookTimeoutDefault };
@@ -11,9 +11,7 @@ import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('getHook.ts', {
-    isPrerendering: false
-});
+const globalObject = getGlobalObject('getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
@@ -130,6 +128,6 @@ function getHookTimeoutDefault(hookName) {
         warning: 4 * 1000
     };
 }
-function setIsPrerenderering() {
+function getHook_setIsPrerenderering() {
     globalObject.isPrerendering = true;
 }

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.191-commit-7e0cd43";
+export declare const PROJECT_VERSION: "0.4.191-commit-e99a55e";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.191-commit-7e0cd43';
+export const PROJECT_VERSION = '0.4.191-commit-e99a55e';

package/dist/esm/utils/genPromise.d.ts

@@ -0,0 +1,4 @@
+export declare function genPromise<T>(): {
+    promise: Promise<T>;
+    resolve: (val: T) => void;
+};

package/dist/esm/utils/genPromise.js

@@ -0,0 +1,5 @@
+export function genPromise() {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    return { promise, resolve };
+}

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.191-commit-7e0cd43";
+    projectVersion: "0.4.191-commit-e99a55e";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.191-commit-7e0cd43",
+  "version": "0.4.191-commit-e99a55e",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",