vike 0.4.191 → 0.4.193

package/dist/cjs/__internal/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPagesAndRoutes = exports.route = void 0;
+exports.getPageFilesAllSafe = exports.getPagesAndRoutes = exports.route = void 0;
 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}
@@ -14,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,
@@ -27,6 +26,15 @@ async function getPagesAndRoutes() {
     };
 }
 exports.getPagesAndRoutes = getPagesAndRoutes;
+// 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;
+}
+exports.getPageFilesAllSafe = getPageFilesAllSafe;
 async function route(pageContext) {
     const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
     // Old interface

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/buildConfig.js

@@ -74,7 +74,7 @@ function buildConfig() {
             name: 'vike:buildConfig:writeBundle',
             apply: 'build',
             // Make sure other writeBundle() hooks are called after this writeBundle() hook.
-            //  - set_constant_ASSETS_MAP() needs to be called before dist/server/ code is executed.
+            //  - set_ASSETS_MAP() needs to be called before dist/server/ code is executed.
             //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
             enforce: 'pre',
             writeBundle: {
@@ -97,7 +97,7 @@ function buildConfig() {
                         }
                         await promises_1.default.rm(clientManifestFilePath);
                         await promises_1.default.rm(serverManifestFilePath);
-                        await (0, index_js_1.set_constant_ASSETS_MAP)(options, bundle);
+                        await (0, index_js_1.set_ASSETS_MAP)(options, bundle);
                     }
                 }
             }

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/importBuild/index.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.set_constant_ASSETS_MAP = exports.importBuild = void 0;
+exports.set_ASSETS_MAP = exports.importBuild = void 0;
 const plugin_js_1 = require("@brillout/vite-plugin-server-entry/plugin.js");
 const utils_js_1 = require("../../utils.js");
 const path_1 = __importDefault(require("path"));
@@ -59,23 +59,33 @@ function getEntryCode(config, configVike) {
     return importerCode;
 }
 /** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
-async function set_constant_ASSETS_MAP(options, bundle) {
+async function set_ASSETS_MAP(options, bundle) {
     const { dir } = options;
     (0, utils_js_1.assert)(dir);
-    // This will probably fail with @vitejs/plugin-legacy
-    //  - See `git log -p` for how we used to workaround the @vitejs/plugin-legacy issue.
-    const serverEntry = (0, plugin_js_1.findServerEntry)(bundle);
-    const serverEntryFilePath = path_1.default.join(dir, serverEntry.fileName);
+    const chunkPath = find_ASSETS_MAP(bundle);
+    const chunkFilePath = path_1.default.join(dir, chunkPath);
     const assetsJsonFilePath = path_1.default.join(dir, '..', 'assets.json');
-    const [assetsJsonString, serverEntryFileContent] = await Promise.all([
+    const [assetsJsonString, chunkFileContent] = await Promise.all([
         await promises_1.default.readFile(assetsJsonFilePath, 'utf8'),
-        await promises_1.default.readFile(serverEntryFilePath, 'utf8')
+        await promises_1.default.readFile(chunkFilePath, 'utf8')
     ]);
-    const serverEntryFileContentPatched = serverEntryFileContent.replace(ASSETS_MAP, assetsJsonString);
-    (0, utils_js_1.assert)(serverEntryFileContentPatched !== serverEntryFileContent);
-    await promises_1.default.writeFile(serverEntryFilePath, serverEntryFileContentPatched);
+    const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MAP, assetsJsonString);
+    (0, utils_js_1.assert)(serverEntryFileContentPatched !== chunkFileContent);
+    await promises_1.default.writeFile(chunkFilePath, serverEntryFileContentPatched);
+}
+exports.set_ASSETS_MAP = set_ASSETS_MAP;
+function find_ASSETS_MAP(bundle) {
+    let chunkPath;
+    for (const filePath in bundle) {
+        const chunk = bundle[filePath];
+        if ('code' in chunk && chunk.code.includes(ASSETS_MAP)) {
+            (0, utils_js_1.assert)(!chunkPath);
+            chunkPath = filePath;
+        }
+    }
+    (0, utils_js_1.assert)(chunkPath);
+    return chunkPath;
 }
-exports.set_constant_ASSETS_MAP = set_constant_ASSETS_MAP;
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
     const filePathAbsolute = (0, utils_js_1.toPosixPath)(

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -33,7 +33,8 @@ const configDefinitionsBuiltIn = {
         cumulative: true
     },
     route: {
-        env: { server: true, client: 'if-client-routing', eager: true }
+        env: { server: true, client: 'if-client-routing' },
+        eager: true
     },
     guard: {
         env: { server: true, client: 'if-client-routing' }
@@ -42,7 +43,8 @@ const configDefinitionsBuiltIn = {
         env: { server: true }
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
-        env: { server: true, client: 'if-client-routing', eager: true }
+        env: { server: true, client: 'if-client-routing' },
+        eager: true
     },
     filesystemRoutingRoot: {
         env: { config: true }
@@ -54,7 +56,8 @@ const configDefinitionsBuiltIn = {
     },
     clientRouting: {
         // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
-        env: { server: true, client: true, config: true, eager: true }
+        env: { server: true, client: true, config: true },
+        eager: true
     },
     clientHooks: {
         env: { config: true }
@@ -75,7 +78,8 @@ const configDefinitionsBuiltIn = {
         env: { config: true }
     },
     clientEntryLoaded: {
-        env: { server: true, client: true, eager: true },
+        env: { server: true, client: true },
+        eager: true,
         _computed: (configValueSources) => {
             {
                 const source = getConfigValueSource(configValueSources, 'clientHooks');
@@ -118,10 +122,12 @@ const configDefinitionsBuiltIn = {
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: { server: true, production: true, eager: true }
+        env: { server: true, production: true },
+        eager: true
     },
     onBeforeRoute: {
-        env: { server: true, client: 'if-client-routing', eager: true }
+        env: { server: true, client: 'if-client-routing' },
+        eager: true
     },
     prerender: {
         env: { config: true }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -35,7 +35,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const importStatements = [];
     const isClientRouting = (0, getConfigValueBuildTime_js_1.getConfigValueBuildTime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false, isDev }), ''));
+    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: false }, ''));
     lines.push('};');
     if (!(0, fixServerAssets_js_1.fixServerAssets_isEnabled)() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, false))}'`);

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -35,7 +35,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
         lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true, isDev }), '    '));
+        lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -45,7 +45,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfigGlobal, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true, isDev }), '    '));
+    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfigGlobal, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/isRuntimeEnvMatch.js

@@ -13,9 +13,6 @@ function isRuntimeEnvMatch(configEnv, runtime) {
         if (configEnv.client === 'if-client-routing' && !runtime.isClientRouting)
             return false;
     }
-    // Eager
-    if (runtime.isEager !== !!configEnv.eager)
-        return false;
     // Production/development
     if (
     //

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");
@@ -11,10 +11,14 @@ const assertPluginManifest_js_1 = require("../shared/assertPluginManifest.js");
 const getConfigVike_js_1 = require("../shared/getConfigVike.js");
 const assertRuntimeManifest_js_1 = require("../shared/assertRuntimeManifest.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-let resolveGlobalContext;
-const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', {
-    globalContextPromise: new Promise((r) => (resolveGlobalContext = r))
-});
+const getPageFilesExports_js_1 = require("./page-files/getPageFilesExports.js");
+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;
@@ -27,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) {
@@ -60,39 +66,87 @@ 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() {
+    if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
-    const { viteDevServer, viteConfig, isDev } = globalObject;
+    globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
+    (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, 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 = {
@@ -111,7 +165,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);
@@ -147,9 +201,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 = {
@@ -186,3 +238,8 @@ function assertViteManifest(manifest) {
       })
     */
 }
+function eagerlyLoadUserFiles() {
+    // Other than here, the getPageFilesExports() function is only called only upon calling the renderPage() function.
+    // We call it as early as possible here for better performance.
+    (0, getPageFilesExports_js_1.getPageFilesExports)();
+}

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/page-files/getPageFilesExports.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageFilesExports = void 0;
+const utils_js_1 = require("../utils.js");
+const globalContext_js_1 = require("../globalContext.js");
+const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
+async function getPageFilesExports() {
+    const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
+    (0, utils_js_1.assert)(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        (0, utils_js_1.debugGlob)(`Glob error: ${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    (0, utils_js_1.debugGlob)('Glob result: ', moduleExports);
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
+    return moduleExports;
+}
+exports.getPageFilesExports = getPageFilesExports;